阻焊仓堆垛机对接

wankeda

2025-03-05 7086c88c6c080aa9ff15664c5c97aee7bbcdc55b

阻焊仓堆垛机对接

阻焊仓堆垛机对接

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/.vs/WIDESEAWCS_Server/FileContentIndex/472a85b1-322e-46ee-835a-853cb266cbd8.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/.vs/WIDESEAWCS_Server/FileContentIndex/5761a620-5bca-4675-84e1-2980dbca5573.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/.vs/WIDESEAWCS_Server/FileContentIndex/7fca402a-0c47-4aac-bdef-736d4f6e2f32.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/.vs/WIDESEAWCS_Server/FileContentIndex/c3952f00-6f03-46e1-a8c4-0c2746ff48ae.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/.vs/WIDESEAWCS_Server/FileContentIndex/read.lock

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoService/TaskService.cs

@@ -211,6 +211,12 @@
                                task.DeviceCode = stationManger.StackerCraneCode;
                                task.TaskState = TaskStatusEnum.SC_Execute.ObjToInt();
                            }
                            else if (item.TaskType == TaskTypeEnum.MesOutbound.ObjToInt() && item.RoadWay.Contains("ZH"))
                            {
                                task.NextAddress = stationManger.StackerCraneStationCode;
                                task.DeviceCode = stationManger.StackerCraneCode;
                                task.TaskState = TaskStatusEnum.SC_Execute.ObjToInt();
                            }
                            else
                            {
                                task.NextAddress = taskTypeGroup == TaskTypeGroup.InboundGroup ? task.TargetAddress : router.NextPosi;
@@ -251,7 +257,6 @@
                                return WebResponseContent.Instance.Error($"未找到路由配置信息");
                            }
                            router = routers.FirstOrDefault();

                            task.NextAddress = router?.StartPosi ?? "";
                            task.DeviceCode = item.RoadWay;
                            task.TaskState = TaskStatusEnum.SC_Execute.ObjToInt();

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/PP²Ö/TSJConveyorLineJob_PP.cs

@@ -96,14 +96,17 @@

                        //}
                        #endregion
                        //2016出库站台任务完成
                        if (item.StationType == StationTypeEnum.StationType_OnlyOutbound.ObjToInt())
                        {
                            if (conveyorLineSignalRead.STB)
                            {
                                device.SetValue(W_ConveyorLineDB.ACK, true, item.StationCode);

                                Thread.Sleep(500);
                                device.SetValue(W_ConveyorLineDB.ACK, false, item.StationCode);
                                _taskService.TaskCompleted(conveyorLineInfoRead.TaskNum);
                            }
                            Thread.Sleep(500);
                            device.SetValue(W_ConveyorLineDB.ACK, false, item.StationCode);
                        }
                        else if (item.StationType == StationTypeEnum.StationType_InboundAndOutbound.ObjToInt())
                        {

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/×躸²Ö/GroundStationJob_ZH.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,153 @@
using Quartz;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Common;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_IBasicInfoRepository;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_Tasks.HoisterJob;

namespace WIDESEAWCS_Tasks
{
    /// <summary>
    /// é˜»ç„Šä»“地面站
    /// </summary>
    [DisallowConcurrentExecution]
    public class GroundStationJob_ZH : JobBase, IJob
    {
        private readonly ITaskService _taskService;
        private readonly ITaskExecuteDetailService _taskExecuteDetailService;
        private readonly ITaskRepository _taskRepository;
        private readonly IStationMangerRepository _stationMangerRepository;

        public GroundStationJob_ZH(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, ITaskRepository taskRepository, IStationMangerRepository stationMangerRepository)
        {
            _taskService = taskService;
            _taskExecuteDetailService = taskExecuteDetailService;
            _taskRepository = taskRepository;
            _stationMangerRepository = stationMangerRepository;
        }

        public Task Execute(IJobExecutionContext context)
        {
            OtherDevice device = (OtherDevice)context.JobDetail.JobDataMap.Get("JobParams");
            try
            {
                if (device == null)
                {
                    WriteError(nameof(GroundStationJob_CSJ), "调度错误,设备对象传值为null");
                    return Task.CompletedTask;
                }
                List<string> deviceStations = device.DeviceProDTOs.Select(x => x.DeviceChildCode).ToList();
                List<Dt_StationManger> stationMangers = _stationMangerRepository.QueryData(x => x.StationDeviceCode == device.DeviceCode);
                foreach (var item in stationMangers.Where(x => deviceStations.Contains(x.StationCode)))
                {
                    try
                    {
                        short isTraytype = device.GetValue<GroundStationDBName, short>(GroundStationDBName.R_TakePalletType, item.StationCode);
                        bool isCanPut = device.GetValue<GroundStationDBName, bool>(GroundStationDBName.R_IsCanPut, item.StationCode);
                        bool isCanTake = device.GetValue<GroundStationDBName, bool>(GroundStationDBName.R_IsCanTake, item.StationCode);
                        short takePalletType = device.GetValue<GroundStationDBName, short>(GroundStationDBName.W_PutPalletType, item.StationCode);
                        bool putRequest = device.GetValue<GroundStationDBName, bool>(GroundStationDBName.W_PutRequest, item.StationCode);
                        bool putFinish = device.GetValue<GroundStationDBName, bool>(GroundStationDBName.W_PutFinish, item.StationCode);
                        bool takeRequest = device.GetValue<GroundStationDBName, bool>(GroundStationDBName.W_TakeRequest, item.StationCode);
                        bool takeFinish = device.GetValue<GroundStationDBName, bool>(GroundStationDBName.W_TakeFinish, item.StationCode);

                        if (item.StationType == StationTypeEnum.StationType_OnlyOutbound.ObjToInt())
                        {

                            //device.SetValue(GroundStationDBName.W_TakeRequest, true, item.StationCode);
                            //device.SetValue(GroundStationDBName.W_PutPalletType, 1, item.StationCode);//task.PalletType


                            //device.SetValue(GroundStationDBName.W_TakeFinish, true, item.StationCode);
                            ////判断AGV任务完成，后写给地面站取货完成
                            //device.SetValue(GroundStationDBName.W_TakeRequest, false, item.StationCode);
                            //device.SetValue(GroundStationDBName.W_TakeFinish, false, item.StationCode);
                            Dt_Task task = _taskRepository.QueryFirst(x => x.DeviceCode == item.StackerCraneCode && x.TaskState == TaskStatusEnum.SC_Execute.ObjToInt() && string.IsNullOrEmpty(x.NextAddress));
                            if (task != null && isCanPut && !isCanTake && !putRequest && !putFinish && !takeRequest && !takeFinish)
                            {
                                _taskService.UpdateTask(task, TaskStatusEnum.SC_Execute, nextAddress: item.StationCode);
                            }
                        }
                        if (item.StationType == StationTypeEnum.StationType_OnlyInbound.ObjToInt())
                        {
                            Dt_Task task = _taskRepository.QueryFirst(x => (x.TargetAddress == item.StackerCraneCode || string.IsNullOrEmpty(x.TargetAddress) || x.NextAddress == item.StackerCraneCode || string.IsNullOrEmpty(x.NextAddress)) && (x.TaskState == TaskStatusEnum.New.ObjToInt() || x.TaskState == TaskStatusEnum.AGV_Finish.ObjToInt()) && (x.SourceAddress == item.StationCode || x.CurrentAddress == item.AGVStationCode || x.CurrentAddress == item.StationCode));
                            if (task != null)
                            {
                                if (isCanPut)
                                {
                                    device.SetValue(GroundStationDBName.W_PutRequest, true, item.StationCode);
                                    device.SetValue(GroundStationDBName.W_PutPalletType, 1, item.StationCode);//task.PalletType
                                }
                                //判断AGV任务完成，后写给地面站放货完成
                                device.SetValue(GroundStationDBName.W_PutFinish, true, item.StationCode);

                                string oldAddress = task.NextAddress;
                                int oldStatus = task.TaskState;
                                Dt_StationManger? stationManger = stationMangers.FirstOrDefault(x => x.StationCode == item.StationCode);
                                if (stationManger == null)
                                {
                                    WriteError(item.StationName, $"未找到对应站台信息,设备编号:{item.StationCode},任务号:{task.TaskNum}");
                                    continue;
                                }
                                string? locationCode = _taskService.RequestAssignLocation(task.TaskNum, stationManger.StackerCraneCode);
                                if (string.IsNullOrEmpty(locationCode))
                                {
                                    WriteError(item.StationName, $"请求分配货位返回信息错误,设备编号:{item.StationCode},任务号:{task.TaskNum}");
                                    continue;
                                }
                                _taskService.UpdateTask(task, TaskStatusEnum.SC_Execute, currentAddress: stationManger.StackerCraneStationCode, targetAddress: locationCode, nextAddress: locationCode, deviceCode: stationManger.StackerCraneCode);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        WriteError(device.DeviceCode, $"{item}交互错误", ex);
                    }
                }

                foreach (var item in stationMangers.Where(x => !deviceStations.Contains(x.StationCode)))
                {
                    try
                    {
                        Dt_Task task = _taskRepository.QueryFirst(x => x.TaskState == TaskStatusEnum.New.ObjToInt() && x.SourceAddress == item.StationCode && _taskService.TaskInboundTypes.Contains(x.TaskType));
                        if (task != null)
                        {
                            Dt_StationManger? stationManger = stationMangers.FirstOrDefault(x => x.StationCode == item.StationCode);
                            if (stationManger == null)
                            {
                                WriteError(item.StationName, $"未找到对应站台信息,设备编号:{item.StationCode},任务号:{task.TaskNum}");
                                continue;
                            }
                            string? locationCode = _taskService.RequestAssignLocation(task.TaskNum, stationManger.StackerCraneCode);
                            if (string.IsNullOrEmpty(locationCode))
                            {
                                WriteError(item.StationName, $"请求分配货位返回信息错误,设备编号:{item.StationCode},任务号:{task.TaskNum}");
                                continue;
                            }
                            _taskService.UpdateTask(task, TaskStatusEnum.SC_Execute, currentAddress: stationManger.StackerCraneStationCode, targetAddress: locationCode, nextAddress: locationCode, deviceCode: stationManger.StackerCraneCode);
                        }
                    }
                    catch (Exception ex)
                    {

                    }
                }
            }
            catch (Exception ex)
            {
                WriteError(device.DeviceName, "", ex);
            }
            return Task.CompletedTask;
        }
    }
}

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/×躸²Ö/StackerCraneJob_ZH.cs

@@ -20,6 +20,7 @@
using WIDESEAWCS_Tasks.HoisterJob;
using WIDESEAWCS_Tasks.StackerCraneJob;
using WIDESEAWCS_Tasks;
using WIDESEAWCS_Core;

namespace WIDESEAWCS_Tasks
{
@@ -69,7 +70,9 @@
                                    if (sendFlag)
                                    {
                                        commonStackerCrane.LastTaskType = task.TaskType;
                                       // _taskService.UpdateTaskStatusToNext(task.TaskNum);
                                        task.Dispatchertime = DateTime.Now;
                                        task.ExceptionMessage = "";
                                        _taskService.UpdateTask(task, TaskStatusEnum.SC_Executing);
                                    }
                                }
                            }
@@ -97,9 +100,54 @@
                if (commonStackerCrane.GetValue<StackerCraneDBName, short>(StackerCraneDBName.WorkType) != 5)
                {
                    Console.Out.WriteLine("TaskCompleted" + e.TaskNum);
                   // _taskService.StackCraneTaskCompleted(e.TaskNum);
                    StackerCraneTaskCompleted(e.TaskNum, commonStackerCrane.DeviceCode);
                    commonStackerCrane.SetValue(StackerCraneDBName.WorkType, 5);
                }
            }
        }

        public WebResponseContent StackerCraneTaskCompleted(int taskNum, string deviceCode)
        {
            try
            {
                Dt_Task task = _taskRepository.QueryFirst(x => x.TaskNum == taskNum);
                if (task != null)
                {
                    if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                    {
                        Dt_StationManger stationManger = _stationMangerRepository.QueryFirst(x => x.StackerCraneStationCode == task.NextAddress);
                        if (stationManger == null)
                        {
                            _taskExecuteDetailService.AddTaskExecuteDetail(taskNum, $"AGV站点未配置,{task.NextAddress}");
                            _taskService.UpdateTaskExceptionMessage(taskNum, $"AGV站点未配置,{task.NextAddress}");
                            return WebResponseContent.Instance.Error($"AGV站点未配置,{task.NextAddress}");
                        }

                        _taskService.UpdateTask(task, TaskStatusEnum.AGV_Execute, deviceCode: "AGV_ZH", currentAddress: stationManger.AGVStationCode ?? throw new Exception($"agv站点错误"), nextAddress: task.TargetAddress);
                    }
                    else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup || task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)
                    {
                        _taskService.TaskCompleted(taskNum);
                    }
                    else
                    {
                        WriteError(deviceCode, $"未找到该任务类型回调WMS任务完成接口,{task.TaskType}");
                        _taskExecuteDetailService.AddTaskExecuteDetail(taskNum, $"未找到该任务类型回调WMS任务完成接口,{task.TaskType}");
                        _taskService.UpdateTaskExceptionMessage(taskNum, $"未找到该任务类型回调WMS任务完成接口,{task.TaskType}");
                    }
                }
                else
                {
                    WriteError(deviceCode, $"未找到任务信息,任务号:{taskNum}");
                    return WebResponseContent.Instance.Error($"未找到任务信息,任务号:{taskNum}");
                }

                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                WriteError(deviceCode, $"任务完成错误", ex);
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

@@ -166,7 +214,7 @@
        /// <returns>如果未被占用，返回传入的任务信息，否则，返回null</returns>
        private Dt_Task? OutTaskStationIsOccupied([NotNull] Dt_Task task)
        {
            Dt_StationManger? stationManger = _stationMangerRepository.QueryFirst(x => x.StationCode == task.TargetAddress && x.StackerCraneCode == task.DeviceCode);
            Dt_StationManger? stationManger = _stationMangerRepository.QueryFirst(x => (x.StationCode == task.NextAddress || x.StackerCraneStationCode == task.NextAddress) && x.StackerCraneCode == task.DeviceCode);
            if (stationManger != null)
            {
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceCode == stationManger.StationDeviceCode);
@@ -175,21 +223,22 @@
                    OtherDevice client = (OtherDevice)device;
                    if (client.GetValue<GroundStationDBName, bool>(GroundStationDBName.R_IsCanPut, stationManger.StationCode))//出库站台未被占用
                    {
                        task.TargetAddress = stationManger.StackerCraneStationCode;
                        task.NextAddress = stationManger.StackerCraneStationCode;
                        _taskRepository.UpdateData(task);
                        client.SetValue(GroundStationDBName.R_IsCanPut, true, stationManger.StationCode);
                        return task;
                    }
                }
                else
                {
                    WriteError(task.DeviceCode, $"未找到出库站台【{stationManger.StationDeviceCode}】对应的通讯对象，无法判断出库站台是否被占用");
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"未找到出库站台【{stationManger.StationDeviceCode}】对应的通讯对象，无法判断出库站台是否被占用");
                    WriteInfo(nameof(StackerCraneJob_ZH), $"未找到出库站台【{stationManger.StationDeviceCode}】对应的通讯对象，无法判断出库站台是否被占用");
                }
            }
            else
            {
                WriteError(task.DeviceCode, $"未找到站台【{task.NextAddress}】信息，无法校验站台");
                _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"未找到站台【{task.NextAddress}】信息，无法校验站台");
                WriteInfo(nameof(StackerCraneJob_ZH), $"未找到站台【{task.NextAddress}】信息，无法校验站台");
            }
            return null;
        }
@@ -210,15 +259,35 @@
            stackerCraneTaskCommand.TrayType = 1;
            if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)//判断是否是入库任务
            {
                //List<Dt_Router> routers = _routerService.QueryNextRoutes(task.CurrentAddress, task.Roadway);
                //if (routers.Count > 0)
                //{

                string[] startCodes = task.CurrentAddress.Split("-");

                stackerCraneTaskCommand.StartRow = Convert.ToInt16(startCodes[0]);
                stackerCraneTaskCommand.StartColumn = Convert.ToInt16(startCodes[1]);
                stackerCraneTaskCommand.StartLayer = Convert.ToInt16(startCodes[2]);

                if (startCodes.Length == 3)
                {
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(startCodes[0]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(startCodes[1]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(startCodes[2]);
                }
                else
                {
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"入库任务起点错误，起点：【{task.CurrentAddress}】");
                    return null;
                }
                string[] targetCodes = task.NextAddress.Split("-");
                if (targetCodes.Length == 5)
                {
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[1]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[2]);
                    stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[3]);
                }
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"入库任务终点错误，终点：【{task.NextAddress}】");
                    return null;
                }
            }
            else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
            {
                string[] targetCodes = task.NextAddress.Split("-");
                if (targetCodes.Length == 3)
                {
@@ -229,77 +298,49 @@
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"入库任务终点错误，起点：【{task.NextAddress}】");
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"出库任务下一地址点错误，起点：【{task.NextAddress}】");
                    return null;
                }
                //}
                //else
                //{
                //    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"未找到站台【{task.NextAddress}】信息，无法获取对应的堆垛机取货站台信息");
                //    return null;
                //}
            }
            else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
            {
                //List<Dt_Router> routers = _routerService.QueryNextRoutes(task.Roadway, task.TargetAddress);
                //if (routers.Count > 0)
                string[] sourceCodes = task.CurrentAddress.Split("-");
                if (sourceCodes.Length == 5)
                {
                    string[] targetCodes = task.NextAddress.Split("-");

                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[0]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[1]);
                    stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[2]);

                    string[] sourceCodes = task.CurrentAddress.Split("-");
                    if (sourceCodes.Length == 3)
                    {
                        stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[0]);
                        stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[1]);
                        stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[2]);
                    }
                    else
                    {
                        //数据配置错误
                        _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"出库任务起点错误，起点：【{task.CurrentAddress}】");
                        WriteInfo(nameof(StackerCraneJob_ZH), $"出库任务起点错误，起点：【{task.CurrentAddress}】");
                        return null;
                    }
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[3]);
                }
                //else
                //{
                //    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"未找到站台【{task.NextAddress}】信息，无法获取对应的堆垛机放货站台信息");
                //    return null;
                //}
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"出库任务起点错误，起点：【{task.CurrentAddress}】");
                    return null;
                }
            }
            else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)
            {
                string[] targetCodes = task.NextAddress.Split("-");
                if (targetCodes.Length == 3)
                if (targetCodes.Length == 5)
                {
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[0]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[1]);
                    stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[2]);
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[1]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[2]);
                    stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[3]);
                }
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"移库任务终点错误，起点：【{task.NextAddress}】");
                    WriteInfo(nameof(StackerCraneJob_ZH), $"移库任务终点错误，起点：【{task.NextAddress}】");
                    return null;
                }
                string[] sourceCodes = task.CurrentAddress.Split("-");
                if (sourceCodes.Length == 3)
                if (sourceCodes.Length == 5)
                {
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[0]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[3]);
                }
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"移库任务起点错误，起点：【{task.CurrentAddress}】");

                    WriteInfo(nameof(StackerCraneJob_ZH), $"移库任务起点错误，起点：【{task.CurrentAddress}】");
                    return null;
                }
            }

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/extension/outbound/extend/PPStockSelect.vue

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,332 @@
<template>
  <div>
    <vol-box
      v-model="showDetialBox"
      :lazy="true"
      width="60%"
      :padding="15"
      title="指定库存"
    >
      <div class="box-head">
        <el-alert :closable="false" style="width: 100%">
          <el-row>
            <el-col :span="16">
              <span class="less-style">物料名称： {{ row.materielName }} </span>
              <el-divider direction="vertical"></el-divider>
              <span class="less-style">物料编号： {{ row.materielCode }} </span>
              <el-divider direction="vertical"></el-divider>
              <span class="less-style"
                >需求数量： {{ row.orderQuantity }}
              </span>
              <el-divider direction="vertical"></el-divider>
              <span :class="selectionClass"
                >已选数量： {{ selectionSum }}
              </span>
            </el-col>
            <el-col :span="8">
              <el-link
                type="primary"
                size="small"
                style="float: right; height: 20px"
                @click="getData(false)"
                >{{ kcname }}</el-link
              >
              <el-link
                type="primary"
                size="small"
                style="float: right; height: 20px; margin-right: 10px"
                @click="getData"
                >刷新</el-link
              >
              <el-link
                type="primary"
                size="small"
                style="float: right; height: 20px; margin-right: 10px"
                @click="revokeAssign"
                >撤销分配</el-link
              >
            </el-col>
          </el-row>
        </el-alert>
      </div>
      <div class="box-table" style="margin-top: 1%">
        <el-table
          ref="singleTable"
          :data="tableData"
          style="width: 100%; height: 100%"
          highlight-current-row
          @row-click="handleRowClick"
          height="500px"
          @selection-change="handleSelectionChange"
        >
          >
          <el-table-column type="selection" width="55"> </el-table-column>
          <el-table-column
            label="序号"
            type="index"
            fixed="left"
            width="55"
            align="center"
          ></el-table-column>
          <el-table-column
            v-for="(item, index) in tableColumns.filter((x) => !x.hidden)"
            :key="index"
            :prop="item.prop"
            :label="item.title"
            :width="item.width"
            align="center"
          >
            <template #default="scoped" v-if="item.type == 'icon'">
              <el-tooltip
                class="item"
                effect="dark"
                :content="item.title"
                placement="bottom"
                ><el-button
                  type="text"
                  @click="tableButtonClick(scoped.row, item)"
                  ><i :class="item.icon" style="font-size: 22px"></i></el-button
              ></el-tooltip>
            </template>
          </el-table-column>
        </el-table>
      </div>
      <template #footer>
        <el-button type="primary" size="small" @click="outbound"
          >直接出库</el-button
        >
        <el-button type="primary" size="small" @click="lockStock"
          >锁定库存</el-button
        >
        <el-button type="danger" size="small" @click="showDetialBox = false"
          >关闭</el-button
        >
      </template>
    </vol-box>
  </div>
</template>
<script>
import VolBox from "@/components/basic/VolBox.vue";
import { fa } from "element-plus/es/locales.mjs";
export default {
  components: { VolBox },
  data() {
    return {
      row: null,
      kcname: "",
      pkcx: false,
      showDetialBox: false,
      tableData: [],
      tableColumns: [
        {
          prop: "materielCode",
          title: "物料编号",
          type: "string",
          width: 150,
        },
        {
          prop: "materielName",
          title: "物料名称",
          type: "string",
          width: 150,
        },
        {
          prop: "palletCode",
          title: "托盘编号",
          type: "string",
          width: 150,
        },
        {
          prop: "locationCode",
          title: "货位编号",
          type: "string",
          width: 180,
        },
        {
          prop: "unit",
          title: "单位",
          type: "string",
          width: 90,
        },
        {
          prop: "cutedWidth",
          title: "裁切宽",
          type: "string",
          width: 100,
          align: "left",
        },
        {
          prop: "useableQuantity",
          title: "可用数量",
          type: "string",
        },
      ],
      selection: [],
      selectionSum: 0,
      selectionClass: "less-style",
      originalQuantity: 0,
    };
  },
  methods: {
    open(row) {
      console.log(row);
      this.row = row;
      this.showDetialBox = true;
      this.originalQuantity = this.row.lockQuantity;
      this.selectionSum = this.row.lockQuantity;
      this.getData();
      if (this.selectionSum == this.row.orderQuantity) {
        this.selectionClass = "equle-style";
      } else if (this.selectionSum < this.row.orderQuantity) {
        this.selectionClass = "less-style";
      } else {
        this.selectionClass = "more-style";
      }
    },
    lockStock() {
      this.http
        .post(
          "api/OutboundOrderDetail/LockOutboundStock?id=" + this.row.id,
          this.selection,
          "数据处理中"
        )
        .then((x) => {
          if (!x.status) return this.$message.error(x.message);
          this.$message.success("操作成功");
          this.showDetialBox = false;
          this.$emit("parentCall", ($vue) => {
            $vue.getData();
          });
        });
    },
    outbound() {
      if (this.selection.length <= 0) {
        return this.$message.error("请勾选");
      }
      let url = this.pkcx
        ? "api/Mes/PPGeneratePKOutboundTask?orderDetailId="
        : "api/Mes/PPCutOutGenerateOutboundTasks?orderDetailId=";
      this.http
        .post(url + this.row.id, this.selection, "数据处理中")
        .then((x) => {
          if (!x.status) return this.$message.error(x.message);
          this.$message.success("操作成功");
          this.showDetialBox = false;
          this.$emit("parentCall", ($vue) => {
            $vue.getData();
          });
        });
    },
    getData(a) {
      if (!a) this.pkcx = !this.pkcx;
      let url = this.pkcx
        ? "api/StockInfo/PPGetPKStockSelectViews?materielCode="
        : "api/StockInfo/PPGetStockSelectViews?materielCode=";
      this.kcname = this.pkcx ? "立库库存" : "平库库存";
      console.log(this.row.materielCode),
        this.http
          .post(
            url + this.row.materielCode + "&orderId=" + this.row.orderId,
            null,
            "查询中"
          )
          .then((x) => {
            this.tableData = x;
          });
    },
    revokeAssign() {
      console.log(this.row);
      this.http
        .post(
          "api/OutboundOrderDetail/RevokeLockOutboundStock?id=" + this.row.id,
          null,
          "数据处理中"
        )
        .then((x) => {
          if (!x.status) return this.$message.error(x.message);
          this.$message.success("操作成功");
          this.showDetialBox = false;
          this.$emit("parentCall", ($vue) => {
            $vue.getData();
          });
        });
    },
    handleSelectionChange(val) {
      this.selection = val;
      this.selectionSum =
        val.reduce(
          (accumulator, currentValue) =>
            accumulator + currentValue["useableQuantity"],
          0
        ) + this.originalQuantity;
      if (this.selectionSum == this.row.orderQuantity) {
        this.selectionClass = "equle-style";
      } else if (this.selectionSum < this.row.orderQuantity) {
        this.selectionClass = "less-style";
      } else {
        this.selectionClass = "more-style";
      }
    },
    toggleSelection(rows) {
      if (rows) {
        rows.forEach((row) => {
          this.$refs.singleTable.toggleRowSelection(row);
        });
      } else {
        this.$refs.singleTable.clearSelection();
      }
    },
    clearSelection() {
      this.$refs.singleTable.clearSelection();
    },
    handleRowClick(row) {
      this.$refs.singleTable.toggleRowSelection(row);
    },
  },
};
</script>
<style scoped>
.less-style {
  color: black;
}

.equle-style {
  color: green;
}

.more-style {
  color: red;
}
</style>

<style>
.text-button:hover {
  background-color: #f0f9eb !important;
}

.el-table .warning-row {
  background: oldlace;
}

.box-table .el-table tbody tr:hover > td {
  background-color: #d8e0d4 !important;
  /* color: #ffffff; */
}

.box-table .el-table tbody tr.current-row > td {
  background-color: #f0f9eb !important;
  /* color: #ffffff; */
}

.el-table .success-row {
  background: #f0f9eb;
}

.box-table .el-table {
  border: 1px solid #ebeef5;
}

.box-head .el-alert__content {
  width: 100%;
}
</style>

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/extension/outbound/extend/mesPPCutOutOrderDetail.vue

@@ -91,9 +91,9 @@
        </el-table>
      </div>
    </vol-box>
    <stock-select ref="child" @parentCall="parentCall"></stock-select>
    <pp-stock-select ref="childs" ></pp-stock-select>
    <selected-stock
      ref="selectedStock"
      ref="SelectedStock"
      @parentCall="parentCall"
    ></selected-stock>
  </div>
@@ -101,10 +101,10 @@
<script>
import VolBox from "@/components/basic/VolBox.vue";
import VolForm from "@/components/basic/VolForm.vue";
import StockSelect from "./StockSelect.vue";
import PPStockSelect from "./PPStockSelect.vue";
import SelectedStock from "./SelectedStock.vue";
export default {
  components: { VolBox, VolForm, StockSelect, SelectedStock },
  components: { VolBox, VolForm,"pp-stock-select":PPStockSelect, SelectedStock },
  data() {
    return {
      row: null,
@@ -297,10 +297,12 @@
    },
    tableButtonClick(row, column) {
      if (column.prop == "assignStock") {
        this.$refs.child.open(row);
        console.log(row);
        console.log(this.$refs.childs);
        this.$refs.childs.open(row);
      } else {
        //点击打开出库详情
        this.$refs.selectedStock.open(row);
        this.$refs.SelectedStock.open(row);
      }
    },
    lockstocks() {
@@ -326,7 +328,7 @@
      var keys = this.selection.map((item) => item.id); // èŽ·å–选中行的id

      this.http
        .post("api/Task/GenerateOutboundTasks", keys, "数据处理中")
        .post("api/Mes/PPCutOutGenerateOutboundTasks", keys, "数据处理中")
        .then((x) => {
          if (!x.status) return this.$message.error(x.message);
          this.$message.success("操作成功");

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/extension/outbound/extend/mesPPoutOrderDetail.vue

@@ -271,7 +271,7 @@
      this.http
        .post("api/MesPPOutboundOrderDetail/GetPageData", param, "查询中")
        .then((x) => {
            // console.log(x.rows);
            console.log(x.rows);
          this.tableData = x.rows;
        });
    },
@@ -306,7 +306,7 @@
      var keys = this.selection.map((item) => item.id); // èŽ·å–选中行的id

      this.http
        .post("api/Task/MESPPGenerateOutboundTasks", keys, "数据处理中")
        .post("api/Mes/MESPPGenerateOutboundTasks", keys, "数据处理中")
        .then((x) => {
          if (!x.status) return this.$message.error(x.message);
          this.$message.success("操作成功");

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/extension/outbound/mesPPOutboundOrderDetail.js

@@ -1,57 +1,72 @@

//此js文件是用来自定义扩展业务代码，可以扩展一些自定义页面或者重新配置生成的代码
let extension = {
    components: {
      //查询界面扩展组件
      gridHeader: '',
      gridBody: gridBody,
      gridFooter: '',
      //新建、编辑弹出框扩展组件
      modelHeader: '',
      modelBody: '',
      modelFooter: ''
  components: {
    //查询界面扩展组件
    gridHeader: '',
    gridBody: gridBody,
    gridFooter: '',
    //新建、编辑弹出框扩展组件
    modelHeader: '',
    modelBody: '',
    modelFooter: ''
  },
  tableAction: '', //指定某张表的权限(这里填写表名,默认不用填写)
  buttons: { view: [], box: [], detail: [] }, //扩展的按钮
  methods: {
     //下面这些方法可以保留也可以删除
    onInit() {  
      //扩展页面初始化操作
      this.columns.push({
        field: '操作',
        title: '操作',
        width: 90,
        fixed: 'right',
        align: 'center',
        formatter: (row) => {
            return (
                '<i style="cursor: pointer;color: #2d8cf0;"class="el-icon-view">查看明细</i>'
            );
        },
        click: (row) => {
            this.$refs.gridBody.open(row);
        }
    });
    },
    tableAction: '', //指定某张表的权限(这里填写表名,默认不用填写)
    buttons: { view: [], box: [], detail: [] }, //扩展的按钮
    methods: {
       //下面这些方法可以保留也可以删除
      onInit() {  
      },
      onInited() {
        //框架初始化配置后
        //如果要配置明细表,在此方法操作
        //this.detailOptions.columns.forEach(column=>{ });
      },
      searchBefore(param) {
        //界面查询前,可以给param.wheres添加查询参数
        //返回false，则不会执行查询
        return true;
      },
      searchAfter(result) {
        //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
        return true;
      },
      addBefore(formData) {
        //新建保存前formData为对象，包括明细表，可以给给表单设置值，自己输出看formData的值
        return true;
      },
      updateBefore(formData) {
        //编辑保存前formData为对象，包括明细表、删除行的Id
        return true;
      },
      rowClick({ row, column, event }) {
        //查询界面点击行事件
        this.$refs.table.$refs.table.toggleRowSelection(row); //单击行时选中当前行;
      },
      modelOpenAfter(row) {
        //点击编辑、新建按钮弹出框后，可以在此处写逻辑，如，从后台获取数据
        //(1)判断是编辑还是新建操作： this.currentAction=='Add';
        //(2)给弹出框设置默认值
        //(3)this.editFormFields.字段='xxx';
        //如果需要给下拉框设置默认值，请遍历this.editFormOptions找到字段配置对应data属性的key值
        //看不懂就把输出看：console.log(this.editFormOptions)
      }
    onInited() {
      //框架初始化配置后
      //如果要配置明细表,在此方法操作
      //this.detailOptions.columns.forEach(column=>{ });
    },
    searchBefore(param) {
      //界面查询前,可以给param.wheres添加查询参数
      //返回false，则不会执行查询
      return true;
    },
    searchAfter(result) {
      //查询后，result返回的查询数据,可以在显示到表格前处理表格的值
      return true;
    },
    addBefore(formData) {
      //新建保存前formData为对象，包括明细表，可以给给表单设置值，自己输出看formData的值
      return true;
    },
    updateBefore(formData) {
      //编辑保存前formData为对象，包括明细表、删除行的Id
      return true;
    },
    rowClick({ row, column, event }) {
      //查询界面点击行事件
      this.$refs.table.$refs.table.toggleRowSelection(row); //单击行时选中当前行;
    },
    modelOpenAfter(row) {
      //点击编辑、新建按钮弹出框后，可以在此处写逻辑，如，从后台获取数据
      //(1)判断是编辑还是新建操作： this.currentAction=='Add';
      //(2)给弹出框设置默认值
      //(3)this.editFormFields.字段='xxx';
      //如果需要给下拉框设置默认值，请遍历this.editFormOptions找到字段配置对应data属性的key值
      //看不懂就把输出看：console.log(this.editFormOptions)
    }
  };
  export default extension;
  
  }
};
export default extension;

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSClient/src/views/outbound/mesPPCutOutboundOrder.vue

@@ -194,7 +194,7 @@
    ]);
    const detail = ref({
      cnName: "出库明细单",
      table: "OnboundOrderDetail",
      table: "mesPPCutOutOrderDetail",
      columns: [
        {
          field: "id",

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/16bda44f-cb60-43e3-8deb-16983a6c8720.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/1ffecc40-5215-4fbe-92a8-4f08c948917b.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/3a86d184-9f6a-4b52-8eb2-6a125517673d.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/6573eb92-5634-4b4e-a7f1-96f2790803c7.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/7465d6d9-8464-4852-a7e6-98848228a1cf.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/bcaff427-9b5a-40c5-b7b6-df06507540f9.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/c003f52c-46e5-4779-9a5b-7d482547a022.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/d7d7cdfe-7831-4766-872e-1bbd2ae71185.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/d988a5f8-54ef-40e6-acc3-7fcd73682004.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/fed89d2c-c26e-4f31-9fa3-8a0b7f92a8fd.vsidx

Binary files differ

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicRepository/LocationInfoRepository.cs

@@ -86,6 +86,16 @@
        }

        /// <summary>
        /// èŽ·å–可出库货位编号
        /// </summary>
        /// <param name="warehouseId"></param>
        /// <returns></returns>
        public List<string> PPGetCanOutLocationCodes(int warehouseId)
        {
            return QueryData(x => x.LocationCode, x => x.WarehouseId == warehouseId && x.LocationType == LocationTypeEnum.Undefined.ObjToInt() && x.LocationStatus == LocationStatusEnum.InStock.ObjToInt() && (x.EnableStatus == EnableStatusEnum.OnlyOut.ObjToInt() || x.EnableStatus == EnableStatusEnum.Normal.ObjToInt())).Distinct().ToList();
        }

        /// <summary>
        /// èŽ·å–MES指定可出库货位编号
        /// </summary>
        /// <param name="warehouseId"></param>

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_BasicService/Service/LocationInfoService_Common.cs

@@ -55,7 +55,7 @@
                "HA58" => AssignLocation_PP(roadwayNo, palletType, palletTypeInfo, beRelocationCode),
                "HA152" => AssignLocation_GM(roadwayNo, palletType, palletTypeInfo, beRelocationCode),
                "HA64" => AssignLocation_CSJ(roadwayNo, palletType, palletTypeInfo, beRelocationCode),
                "阻焊仓" => AssignLocation_ZH(roadwayNo, palletType, palletTypeInfo, beRelocationCode),
                "HA154" => AssignLocation_ZH(roadwayNo, palletType, palletTypeInfo, beRelocationCode),
                "HA153" => AssignLocation(roadwayNo),
                "HA71" => AssignLocation(roadwayNo),
                "HA60" => AssignLocation(roadwayNo),

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_DTO/Stock/PPStockSelectViewDTO.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,24 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WIDESEA_DTO.Stock
{
    public class PPStockSelectViewDTO
    {
        public string MaterielCode { get; set; }

        public string MaterielName { get; set; }

        public float UseableQuantity { get; set; }

        public string PalletCode { get; set; }

        public string LocationCode { get; set; }

        public string Unit {  get; set; }
        public float CutedWidth {  get; set; }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IBasicRepository/ILocationInfoRepository.cs

@@ -53,6 +53,8 @@
        /// <returns></returns>
        List<string> GetCanOutLocationCodes(int warehouseId);

        List<string> PPGetCanOutLocationCodes(int warehouseId);

        /// <summary>
        /// èŽ·å–MES指定可出库货位编号
        /// </summary>

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IOutboundRepository/IOutboundRepository.cs

@@ -14,5 +14,7 @@
        IOutboundOrderRepository OutboundOrderRepository { get; }

        IOutStockLockInfoRepository OutboundStockLockInfoRepository { get; }

        IMesPPCutOutboundOrderRepository MesPPCutOutboundOrderRepository { get; }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IOutboundService/IMesPPCutOutboundOrderDetailService.cs

@@ -3,12 +3,32 @@
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_DTO.Stock;
using WIDESEA_IOutboundRepository;
using WIDESEA_Model.Models;

namespace WIDESEA_IOutboundService
{
    public interface IMesPPCutOutboundOrderDetailService : IService<Dt_MesPPCutOutboundOrderDetail>
    {
        IMesPPCutOutboundOrderDetailRepository Repository { get; }

        (List<Dt_StockInfo>, Dt_MesPPCutOutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPCutOutboundOrderDetail mesOutboundOrder,List<PPStockSelectViewDTO> stockSelectViewDTOs);

        /// <summary>
        /// é”å®šå‡ºåº“库存(修改数据)
        /// </summary>
        /// <param name="stockInfos">库存明细集合</param>
        /// <param name="outboundOrderDetails">出库单明细集合</param>
        /// <param name="outStockLockInfos">出库锁定明细集合</param>
        /// <param name="locationInfos">货位结合</param>
        /// <param name="locationStatus">货位状态修改的值</param>
        /// <param name="tasks">任务信息</param>
        /// <returns></returns>
        WebResponseContent LockOutboundStockDataUpdate(List<Dt_StockInfo> stockInfos, List<Dt_MesPPCutOutboundOrderDetail> outboundOrderDetails, List<Dt_OutStockLockInfo> outStockLockInfos, List<Dt_LocationInfo> locationInfos, LocationStatusEnum locationStatus = LocationStatusEnum.Lock, List<Dt_Task>? tasks = null);

    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IOutboundService/IMesPPOutboundOrderDetailService.cs

@@ -3,7 +3,6 @@
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Hosting.Server;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
@@ -16,11 +15,7 @@
    {
        IMesPPOutboundOrderDetailRepository Repository { get; }



        //(List<Dt_StockInfo>, List<Dt_MesPPOutboundOrderDetail>, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(List<Dt_MesPPOutboundOrderDetail> mesPPOutboundOrderDetails);

        (List<Dt_StockInfo>, Dt_MesPPOutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPOutboundOrderDetail mesOutboundOrder);
        (List<Dt_StockInfo>, List<Dt_MesPPOutboundOrderDetail>, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>, Dt_MesPPOutboundOrder mesPPOutboundOrder) AssignStockOutbound(List<Dt_MesPPOutboundOrderDetail> mesOutboundOrder);

        /// <summary>
        /// é”å®šå‡ºåº“库存(修改数据)
@@ -32,7 +27,8 @@
        /// <param name="locationStatus">货位状态修改的值</param>
        /// <param name="tasks">任务信息</param>
        /// <returns></returns>
        WebResponseContent LockOutboundStockDataUpdate(List<Dt_StockInfo> stockInfos, List<Dt_MesPPOutboundOrderDetail> outboundOrderDetails, List<Dt_OutStockLockInfo> outStockLockInfos, List<Dt_LocationInfo> locationInfos, LocationStatusEnum locationStatus = LocationStatusEnum.Lock, List<Dt_Task>? tasks = null);
        WebResponseContent LockOutboundStockDataUpdate(Dt_MesPPOutboundOrder mesPPOutboundOrder,List<Dt_StockInfo> stockInfos, List<Dt_MesPPOutboundOrderDetail> outboundOrderDetails, List<Dt_OutStockLockInfo> outStockLockInfos, List<Dt_LocationInfo> locationInfos, LocationStatusEnum locationStatus = LocationStatusEnum.Lock, List<Dt_Task>? tasks = null);


    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IOutboundService/IMesPPOutboundOrderService.cs

@@ -13,8 +13,9 @@
    {
        IMesPPOutboundOrderRepository Repository { get; }

        (List<Dt_StockInfo>, Dt_MesPPOutboundOrder, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPOutboundOrder mesOutboundOrder);
        //(List<Dt_StockInfo>, Dt_MesPPOutboundOrder, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPOutboundOrder mesOutboundOrder);

        (List<Dt_StockInfo>, Dt_MesPPCutOutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPCutOutboundOrder mesPPOutboundOrder, Dt_MesPPCutOutboundOrderDetail  mesPPCutOutboundOrderDetail);
        //(List<Dt_StockInfo>, Dt_MesPPCutOutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPCutOutboundOrder mesPPOutboundOrder, Dt_MesPPCutOutboundOrderDetail  mesPPCutOutboundOrderDetail);
  
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IOutboundService/IOutStockLockInfoService.cs

@@ -58,7 +58,7 @@
        /// <param name="assignQuantity"></param>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        Dt_OutStockLockInfo GetOutStockLockInfo(Dt_MesPPCutOutboundOrder mesPPCutOutboundOrder,Dt_MesPPCutOutboundOrderDetail  mesPPCutOutboundOrderDetail, Dt_StockInfo outStock, float assignQuantity, int? taskNum = null);
        List<Dt_OutStockLockInfo> GetOutStockLockInfos(Dt_MesPPCutOutboundOrder mesPPCutOutboundOrder,Dt_MesPPCutOutboundOrderDetail  mesPPCutOutboundOrderDetail, List<Dt_StockInfo> outStock, int? taskNum = null);

        /// <summary>
        /// 

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IStockService/IStockInfoService.cs

@@ -22,7 +22,12 @@

        List<Dt_StockInfo> GetUseableStocks(string materielCode, string batchNo, int warehoseId);

        List<Dt_StockInfo> GetUseableStocks(string materielCode, string batchNo, string palletcode,int warehoseId);
        //List<Dt_StockInfo> GetUseableStocks(string materielCode, string batchNo,,string , int warehoseId);

        List<Dt_StockInfo> GetUseableStocks(string materielCode, string batchNo, string palletcode, int warehoseId);
        WebResponseContent StockQueryData(SaveModel saveModel);

        List<PPStockSelectViewDTO> PPGetStockSelectViews(int orderId, string materielCode);
        List<PPStockSelectViewDTO> PPGetPKStockSelectViews(int orderId, string materielCode);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_ITaskInfoService/ITaskService.cs

@@ -160,12 +160,12 @@
        WebResponseContent GenerateOutboundTasks(int[] keys);


        /// <summary>
        /// ç”ŸæˆMESPP大卷出库任务
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        WebResponseContent MESPPGenerateOutboundTasks(int[] keys);
        ///// <summary>
        ///// ç”ŸæˆMESPP大卷出库任务
        ///// </summary>
        ///// <param name="keys"></param>
        ///// <returns></returns>
        //WebResponseContent MESPPGenerateOutboundTasks(int[] keys);

        /// <summary>
        /// å‡ºåº“任务完成
@@ -327,5 +327,25 @@
        /// </summary>
        /// <returns></returns>
        MesResponseContent BagInfoSync(MesBagInfoModel bagInfoModel);

        /// <summary>
        /// ç”ŸæˆMESPP大卷出库任务
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        WebResponseContent MESPPGenerateOutboundTasks(int[] keys);

        /// <summary>
        /// ç”ŸæˆMESPP小卷出库任务
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        //WebResponseContent PPCutOutGenerateOutboundTasks(int[] keys);

        WebResponseContent PPCutOutGenerateOutboundTasks(int orderDetailId, List<PPStockSelectViewDTO> stockSelectViews);

        WebResponseContent PPGeneratePKOutboundTask(int orderDetailId, List<PPStockSelectViewDTO> stockSelectViews);


    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Model/Models/Outbound/Dt_MesPPOutboundOrderDetail.cs

@@ -11,7 +11,7 @@
    /// <summary>
    /// PP仓大卷MES出库单明细
    /// </summary>
    [SugarTable(nameof(Dt_MesPPOutboundOrderDetail))]
    [SugarTable(nameof(Dt_MesPPOutboundOrderDetail), "PP仓大卷MES出库单明细")]
    public class Dt_MesPPOutboundOrderDetail : BaseEntity
    {
        /// <summary>
@@ -40,7 +40,7 @@
        /// <summary>
        /// è®¢å•æ˜Žç»†çŠ¶æ€
        /// </summary>
        [SugarColumn(IsNullable = false,ColumnDescription = "订单明细状态")]
        [SugarColumn(IsNullable = false, ColumnDescription = "订单明细状态")]
        public int OrderDetailStatus { get; set; }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundRepository/OutboundRepository.cs

@@ -15,11 +15,14 @@

        public IOutStockLockInfoRepository OutboundStockLockInfoRepository { get; }

        public OutboundRepository(IOutboundOrderDetailRepository outboundOrderDetailRepository, IOutboundOrderRepository outboundOrderRepository, IOutStockLockInfoRepository outboundStockLockInfoRepository)
        public IMesPPCutOutboundOrderRepository MesPPCutOutboundOrderRepository { get; }

        public OutboundRepository(IOutboundOrderDetailRepository outboundOrderDetailRepository, IOutboundOrderRepository outboundOrderRepository, IOutStockLockInfoRepository outboundStockLockInfoRepository,IMesPPCutOutboundOrderRepository mesPPCutOutboundOrderRepository)
        {
            OutboundOrderDetailRepository = outboundOrderDetailRepository;
            OutboundOrderRepository = outboundOrderRepository;
            OutboundStockLockInfoRepository = outboundStockLockInfoRepository;
            MesPPCutOutboundOrderRepository = mesPPCutOutboundOrderRepository;
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/MesPPCutOutboundOrderDetailService.cs

@@ -3,7 +3,12 @@
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SqlSugar.Extensions;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.OrderEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseServices;
using WIDESEA_DTO.Stock;
using WIDESEA_IBasicRepository;
using WIDESEA_IBasicService;
using WIDESEA_IOutboundRepository;
@@ -33,5 +38,188 @@
            _basicService = basicService;
            _recordService = recordService;
        }

        public (List<Dt_StockInfo>, Dt_MesPPCutOutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPCutOutboundOrderDetail mesPPOutboundOrderDetails, List<PPStockSelectViewDTO> stockSelectViews)
        {
            #region
            //Dt_MesPPCutOutboundOrder OutboundOrder = BaseDal.Db.Queryable<Dt_MesPPCutOutboundOrder>().Where(x => x.Id == mesPPOutboundOrderDetails.OrderId).First();
            //List<Dt_StockInfo> outStocks = new List<Dt_StockInfo>();
            //List<Dt_MesPPCutOutboundOrderDetail> groupDetails = mesPPOutboundOrderDetails.GroupBy(x => new { x.MaterielCode, x.BatchNo }).Select(x => new Dt_MesPPCutOutboundOrderDetail { OrderQuantity = x.Sum(v => v.OrderQuantity) - x.Sum(v => v.LockQuantity), MaterielCode = x.Key.MaterielCode, BatchNo = x.Key.BatchNo, }).ToList();

            //List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
            //List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();
            //foreach (var item in groupDetails)
            //{
            //    float originalNeedQuantity = item.OrderQuantity;

            //    float needQuantity = originalNeedQuantity;

            //    List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseableStocks(item.MaterielCode, item.BatchNo, OutboundOrder.WarehouseId);
            //    if (!stockInfos.Any())
            //    {
            //        throw new Exception($"未找到可分配库存");
            //    }
            //    List<Dt_StockInfo> autoAssignStocks = _stockService.StockInfoService.GetOutboundStocks(stockInfos, item.MaterielCode, needQuantity, out float residueQuantity);
            //    item.LockQuantity += needQuantity - residueQuantity;
            //    outStocks.AddRange(autoAssignStocks);
            //    float assignQuantity = needQuantity - residueQuantity;

            //    List<Dt_MesPPCutOutboundOrderDetail> details = mesPPOutboundOrderDetails.Where(x => !string.IsNullOrEmpty(x.BatchNo) ? x.BatchNo == item.BatchNo : true && x.MaterielCode == item.MaterielCode).ToList();

            //    for (int i = 0; i < details.Count; i++)
            //    {
            //        float orderQuantity = details[i].OrderQuantity;
            //        for (int j = 0; j < autoAssignStocks.Count; j++)
            //        {
            //            float detailAssignQuantity = outStockLockInfos.Where(x => !string.IsNullOrEmpty(x.BatchNo) ? x.BatchNo == item.BatchNo : true && x.MaterielCode == item.MaterielCode && x.OrderDetailId == details[i].Id).Sum(x => x.AssignQuantity);//出库订单明细已分配数量

            //            float palletAssignQuantity = outStockLockInfos.Where(x => x.BatchNo == item.BatchNo && x.MaterielCode == item.MaterielCode && x.PalletCode == autoAssignStocks[j].PalletCode).Sum(x => x.AssignQuantity);//出库详情已分配数量
            //            if (string.IsNullOrEmpty(item.BatchNo))
            //            {
            //                palletAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == item.MaterielCode && x.PalletCode == autoAssignStocks[j].PalletCode).Sum(x => x.AssignQuantity);//出库详情已分配数量
            //            }
            //            float palletOutboundQuantity = autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity);
            //            if (palletAssignQuantity < palletOutboundQuantity)//如果出库详情已分配数量小于托盘已分配数量，则可以继续添加该托盘出库信息
            //            {
            //                float orderDetailNeedQuantity = details[i].OrderQuantity - detailAssignQuantity;
            //                if (orderDetailNeedQuantity > autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity)
            //                {
            //                    details[i].LockQuantity += autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity;
            //                    Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(OutboundOrder, details[i], autoAssignStocks[j], autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity);
            //                    outStockLockInfos.Add(outStockLockInfo);
            //                }
            //                else
            //                {
            //                    Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(OutboundOrder, details[i], autoAssignStocks[j], details[i].OrderQuantity - details[i].LockQuantity);
            //                    outStockLockInfos.Add(outStockLockInfo);
            //                    details[i].LockQuantity = details[i].OrderQuantity;
            //                    break;
            //                }

            //            }
            //        }
            //    }


            //    locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList()));

            //}
            #endregion
            (bool, string) checkResult = CheckSelectStockDeital(mesPPOutboundOrderDetails, stockSelectViews);
            if (!checkResult.Item1) throw new Exception(checkResult.Item2);
            Dt_MesPPCutOutboundOrder OutboundOrder = BaseDal.Db.Queryable<Dt_MesPPCutOutboundOrder>().Where(x => x.Id == mesPPOutboundOrderDetails.OrderId).First();
            float originalNeedQuantity = mesPPOutboundOrderDetails.OrderQuantity - mesPPOutboundOrderDetails.LockQuantity;

            float needQuantity = originalNeedQuantity;

            List<Dt_StockInfo> outStocks = _stockService.StockInfoService.Repository.GetStockInfosByPalletCodes(stockSelectViews.Select(x => x.PalletCode).ToList());
            float assignQuantity = 0;
            outStocks.ForEach(x =>
                {
                    x.Details.ForEach(v =>
                    {
                        assignQuantity += v.StockQuantity - v.OutboundQuantity;
                    });
                });

            mesPPOutboundOrderDetails.LockQuantity += assignQuantity;
            outStocks.ForEach(x =>
            {
                x.Details.ForEach(v =>
                {
                    v.OutboundQuantity = v.StockQuantity;
                });
            });
            needQuantity -= assignQuantity;
            if (mesPPOutboundOrderDetails.OrderQuantity > mesPPOutboundOrderDetails.LockQuantity)
            {
                List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseableStocks(mesPPOutboundOrderDetails.MaterielCode, mesPPOutboundOrderDetails.BatchNo, OutboundOrder.WarehouseId);
                stockInfos = stockInfos.Where(x => !stockSelectViews.Select(v => v.PalletCode).Contains(x.PalletCode)).ToList();
                List<Dt_StockInfo> autoAssignStocks = _stockService.StockInfoService.GetOutboundStocks(stockInfos, mesPPOutboundOrderDetails.MaterielCode, needQuantity, out float residueQuantity);
                mesPPOutboundOrderDetails.LockQuantity += needQuantity - residueQuantity;
                outStocks.AddRange(autoAssignStocks);
                mesPPOutboundOrderDetails.OrderDetailStatus = OrderDetailStatusEnum.AssignOver.ObjToInt();
                if (residueQuantity > 0)
                {
                    mesPPOutboundOrderDetails.OrderDetailStatus = OrderDetailStatusEnum.AssignOverPartial.ObjToInt();
                }
            }

            List<Dt_OutStockLockInfo> outStockLockInfos = _outStockLockInfoService.GetOutStockLockInfos(OutboundOrder, mesPPOutboundOrderDetails, outStocks);


            List<Dt_LocationInfo> locationInfos = _basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList());
            return (outStocks, mesPPOutboundOrderDetails, outStockLockInfos, locationInfos);
        }
        private (bool, string) CheckSelectStockDeital(Dt_MesPPCutOutboundOrderDetail outboundOrderDetail, List<PPStockSelectViewDTO> stockSelectViews)
        {
            if (outboundOrderDetail == null)
            {
                return (false, "未找到出库单明细信息");
            }
            if (outboundOrderDetail.OrderDetailStatus != OrderDetailStatusEnum.New.ObjToInt() && outboundOrderDetail.OrderDetailStatus != OrderDetailStatusEnum.AssignOverPartial.ObjToInt())
            {
                return (false, "该明细不可操作");
            }
            if (stockSelectViews.Sum(x => x.UseableQuantity) > outboundOrderDetail.OrderQuantity - outboundOrderDetail.LockQuantity)
            {
                return (false, "选择数量超出单据数量");
            }
            return (true, "成功");
        }


        /// <summary>
        /// å‡ºåº“库存分配后，更新数据库数据
        /// </summary>
        /// <param name="stockInfos"></param>
        /// <param name="outboundOrderDetails"></param>
        /// <param name="outStockLockInfos"></param>
        /// <param name="locationInfos"></param>
        /// <param name="locationStatus"></param>
        /// <param name="tasks"></param>
        /// <returns></returns>
        public WebResponseContent LockOutboundStockDataUpdate(List<Dt_StockInfo> stockInfos, List<Dt_MesPPCutOutboundOrderDetail> outboundOrderDetails, List<Dt_OutStockLockInfo> outStockLockInfos, List<Dt_LocationInfo> locationInfos, LocationStatusEnum locationStatus = LocationStatusEnum.Lock, List<Dt_Task>? tasks = null)
        {
            try
            {
                _stockService.StockInfoService.Repository.UpdateData(stockInfos);
                List<Dt_StockInfoDetail> stockInfoDetails = new List<Dt_StockInfoDetail>();
                foreach (var item in stockInfos)
                {
                    stockInfoDetails.AddRange(item.Details);
                }
                _stockService.StockInfoDetailService.Repository.UpdateData(stockInfoDetails);
                BaseDal.UpdateData(outboundOrderDetails);

                List<Dt_OutStockLockInfo> addOutStockLockInfos = outStockLockInfos.Where(x => x.Id == 0).ToList();
                if (addOutStockLockInfos != null && addOutStockLockInfos.Any())
                {
                    if (tasks != null)
                    {
                        addOutStockLockInfos.ForEach(x =>
                        {
                            x.TaskNum = tasks.FirstOrDefault(v => v.PalletCode == x.PalletCode)?.TaskNum;
                        });
                    }

                    _outStockLockInfoService.Repository.AddData(addOutStockLockInfos);
                }
                List<Dt_OutStockLockInfo> updateOutStockLockInfos = outStockLockInfos.Where(x => x.Id > 0).ToList();
                if (updateOutStockLockInfos != null && updateOutStockLockInfos.Any())
                {
                    _outStockLockInfoService.Repository.UpdateData(updateOutStockLockInfos);
                }

                _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfos, locationStatus, LocationChangeType.OutboundAssignLocation, "", tasks?.Select(x => x.TaskNum).ToList());
                _basicService.LocationInfoService.Repository.UpdateLocationStatus(locationInfos, locationStatus);
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/MesPPOutboundOrderDetailService.cs

@@ -24,18 +24,74 @@
        private readonly IOutStockLockInfoService _outStockLockInfoService;
        private readonly IBasicService _basicService;
        private readonly IRecordService _recordService;
        private readonly IOutboundService _outboundService;

        private readonly IMesPPOutboundOrderService _mesPPOutboundOrderService;
        public IMesPPOutboundOrderDetailRepository Repository => BaseDal;

        public MesPPOutboundOrderDetailService(IMesPPOutboundOrderDetailRepository BaseDal, IBasicRepository basicRepository, IOutboundService outboundService, IStockService stockService, IOutStockLockInfoService outStockLockInfoService, IBasicService basicService, IRecordService recordService) : base(BaseDal)
        public MesPPOutboundOrderDetailService(IMesPPOutboundOrderDetailRepository BaseDal,IMesPPOutboundOrderService mesPPOutboundOrderService ,IBasicRepository basicRepository, IStockService stockService, IOutStockLockInfoService outStockLockInfoService, IBasicService basicService, IRecordService recordService) : base(BaseDal)
        {
            _basicRepository = basicRepository;
            _stockService = stockService;
            _outStockLockInfoService = outStockLockInfoService;
            _basicService = basicService;
            _recordService = recordService;
            _outboundService = outboundService;
            _mesPPOutboundOrderService=mesPPOutboundOrderService;
        }

        public (List<Dt_StockInfo>, List<Dt_MesPPOutboundOrderDetail>, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>, Dt_MesPPOutboundOrder  mesPPOutboundOrder) AssignStockOutbound(List<Dt_MesPPOutboundOrderDetail> mesPPOutboundOrderDetails)
        {
            List<Dt_StockInfo> outStocks = new List<Dt_StockInfo>();

            List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
            List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();
            Dt_MesPPOutboundOrder OutboundOrder = BaseDal.Db.Queryable<Dt_MesPPOutboundOrder>().Where(x => x.Id == mesPPOutboundOrderDetails.FirstOrDefault().OrderId).First();
            float originalNeedQuantity = OutboundOrder.OrderQuantity;

            float needQuantity = originalNeedQuantity;
            //Dt_MesPPOutboundOrder outboundOrder = _outboundRepository.QueryFirst(x => x.Id == outboundOrderDetails.FirstOrDefault().OrderId);

            List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseableStocks(OutboundOrder.MaterialCode, "", mesPPOutboundOrderDetails.FirstOrDefault()?.CarrierCode ?? "", OutboundOrder.WarehouseId);
            if (!stockInfos.Any())
            {
                throw new Exception($"未找到可分配库存");
            }
            List<Dt_StockInfo> autoAssignStocks = _stockService.StockInfoService.GetOutboundStocks(stockInfos, OutboundOrder.MaterialCode, needQuantity, out float residueQuantity);
            OutboundOrder.LockQuantity += needQuantity - residueQuantity;
            autoAssignStocks.OrderBy(x => x.Details.FirstOrDefault()?.StockQuantity).ToList();
            outStocks.AddRange(autoAssignStocks);
            float assignQuantity = needQuantity - residueQuantity;

            float orderQuantity = OutboundOrder.OrderQuantity;

            for (int j = 0; j < autoAssignStocks.Count; j++)
            {
                float detailAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == OutboundOrder.MaterialCode).Sum(x => x.AssignQuantity);//出库订单明细已分配数量

                float palletAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == OutboundOrder.MaterialCode && x.PalletCode == autoAssignStocks[j].PalletCode).Sum(x => x.AssignQuantity);//出库详情已分配数量

                float palletOutboundQuantity = autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity);
                if (palletAssignQuantity < palletOutboundQuantity)//如果出库详情已分配数量小于托盘已分配数量，则可以继续添加该托盘出库信息
                {
                    float orderDetailNeedQuantity = OutboundOrder.OrderQuantity - detailAssignQuantity;
                    if (orderDetailNeedQuantity > autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity)
                    {
                        OutboundOrder.LockQuantity += autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity;
                        //Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(OutboundOrder, autoAssignStocks[j], autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity);
                        Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(OutboundOrder, autoAssignStocks[j], assignQuantity);
                        outStockLockInfos.Add(outStockLockInfo);
                    }
                    else
                    {
                        //Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(OutboundOrder, autoAssignStocks[j], OutboundOrder.OrderQuantity - OutboundOrder.LockQuantity);
                        Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(OutboundOrder, autoAssignStocks[j], assignQuantity);
                        outStockLockInfos.Add(outStockLockInfo);
                        OutboundOrder.LockQuantity = OutboundOrder.OrderQuantity;
                        break;
                    }
                }
            }
            locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList()));

            return (outStocks, mesPPOutboundOrderDetails, outStockLockInfos, locationInfos, OutboundOrder);
        }

        /// <summary>
@@ -48,7 +104,7 @@
        /// <param name="locationStatus"></param>
        /// <param name="tasks"></param>
        /// <returns></returns>
        public WebResponseContent LockOutboundStockDataUpdate(List<Dt_StockInfo> stockInfos, List<Dt_MesPPOutboundOrderDetail> outboundOrderDetails, List<Dt_OutStockLockInfo> outStockLockInfos, List<Dt_LocationInfo> locationInfos, LocationStatusEnum locationStatus = LocationStatusEnum.Lock, List<Dt_Task>? tasks = null)
        public WebResponseContent LockOutboundStockDataUpdate(Dt_MesPPOutboundOrder mesPPOutboundOrder, List<Dt_StockInfo> stockInfos, List<Dt_MesPPOutboundOrderDetail> outboundOrderDetails, List<Dt_OutStockLockInfo> outStockLockInfos, List<Dt_LocationInfo> locationInfos, LocationStatusEnum locationStatus = LocationStatusEnum.Lock, List<Dt_Task>? tasks = null)
        {
            try
            {
@@ -79,6 +135,10 @@
                {
                    _outStockLockInfoService.Repository.UpdateData(updateOutStockLockInfos);
                }
                if (mesPPOutboundOrder != null)
                {
                 _mesPPOutboundOrderService.UpdateData(mesPPOutboundOrder);
                }

                _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfos, locationStatus, LocationChangeType.OutboundAssignLocation, "", tasks?.Select(x => x.TaskNum).ToList());
                _basicService.LocationInfoService.Repository.UpdateLocationStatus(locationInfos, locationStatus);
@@ -90,125 +150,5 @@
            }
        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="outboundOrderDetails"></param>
        /// <returns></returns>
        public (List<Dt_StockInfo>, List<Dt_MesPPOutboundOrderDetail>, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(List<Dt_MesPPOutboundOrderDetail> outboundOrderDetails)
        {
            if (!outboundOrderDetails.Any())
            {
                throw new Exception($"未找到出库单明细信息");
            }

            if (outboundOrderDetails.GroupBy(x => x.OrderId).Count() > 1)
            {
                throw new Exception($"请勿同时操作多个单据明细");
            }
            Dt_MesPPOutboundOrder mesPPOutboundOrder = BaseDal.Db.Queryable<Dt_MesPPOutboundOrder>().Where(x => x.Id == outboundOrderDetails.FirstOrDefault().OrderId).First();
            List<Dt_StockInfo> outStocks = new List<Dt_StockInfo>();

            List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
            List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();


            List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseableStocks(mesPPOutboundOrder.MaterialCode, "", outboundOrderDetails.FirstOrDefault()?.CarrierCode ?? "", mesPPOutboundOrder.WarehouseId);
            if (!stockInfos.Any())
            {
                throw new Exception($"未找到可分配库存");
            }
            float originalNeedQuantity = mesPPOutboundOrder.OrderQuantity;

            float needQuantity = originalNeedQuantity;
            List<Dt_StockInfo> autoAssignStocks = _stockService.StockInfoService.GetOutboundStocks(stockInfos, mesPPOutboundOrder.MaterialCode, needQuantity, out float residueQuantity);
            mesPPOutboundOrder.LockQuantity += needQuantity - residueQuantity;
            outStocks.AddRange(autoAssignStocks);
            float assignQuantity = needQuantity - residueQuantity;

            float orderQuantity = mesPPOutboundOrder.OrderQuantity;
            for (int j = 0; j < autoAssignStocks.Count; j++)
            {
                float detailAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPOutboundOrder.MaterialCode).Sum(x => x.AssignQuantity);//出库订单明细已分配数量

                float palletAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPOutboundOrder.MaterialCode && x.PalletCode == autoAssignStocks[j].PalletCode).Sum(x => x.AssignQuantity);//出库详情已分配数量

                float palletOutboundQuantity = autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity);
                if (palletAssignQuantity < palletOutboundQuantity)//如果出库详情已分配数量小于托盘已分配数量，则可以继续添加该托盘出库信息
                {
                    float orderDetailNeedQuantity = mesPPOutboundOrder.OrderQuantity - detailAssignQuantity;
                    if (orderDetailNeedQuantity > autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity)
                    {
                        mesPPOutboundOrder.LockQuantity += autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity;
                        Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, autoAssignStocks[j], autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity);
                        outStockLockInfos.Add(outStockLockInfo);
                    }
                    else
                    {
                        Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, autoAssignStocks[j], mesPPOutboundOrder.OrderQuantity - mesPPOutboundOrder.LockQuantity);
                        outStockLockInfos.Add(outStockLockInfo);
                        mesPPOutboundOrder.LockQuantity = mesPPOutboundOrder.OrderQuantity;
                        break;
                    }
                }
            }
            locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList()));

            return (outStocks, outboundOrderDetails, outStockLockInfos, locationInfos);
        }


        public (List<Dt_StockInfo>, Dt_MesPPOutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPOutboundOrderDetail mesPPOutboundOrder)
        {
            List<Dt_StockInfo> outStocks = new List<Dt_StockInfo>();

            List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
            List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();

            //float originalNeedQuantity = mesPPOutboundOrder.OrderQuantity;

            //float needQuantity = originalNeedQuantity;

            //List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseableStocks(mesPPOutboundOrder.MaterialCode, "", mesPPOutboundOrder.Details.FirstOrDefault()?.CarrierCode ?? "", mesPPOutboundOrder.WarehouseId);
            //if (!stockInfos.Any())
            //{
            //    throw new Exception($"未找到可分配库存");
            //}
            //List<Dt_StockInfo> autoAssignStocks = _stockService.StockInfoService.GetOutboundStocks(stockInfos, mesPPOutboundOrder.MaterialCode, needQuantity, out float residueQuantity);
            //mesPPOutboundOrder.LockQuantity += needQuantity - residueQuantity;
            //outStocks.AddRange(autoAssignStocks);
            //float assignQuantity = needQuantity - residueQuantity;

            //float orderQuantity = mesPPOutboundOrder.OrderQuantity;
            //for (int j = 0; j < autoAssignStocks.Count; j++)
            //{
            //    float detailAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPOutboundOrder.MaterialCode).Sum(x => x.AssignQuantity);//出库订单明细已分配数量

            //    float palletAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPOutboundOrder.MaterialCode && x.PalletCode == autoAssignStocks[j].PalletCode).Sum(x => x.AssignQuantity);//出库详情已分配数量

            //    float palletOutboundQuantity = autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity);
            //    if (palletAssignQuantity < palletOutboundQuantity)//如果出库详情已分配数量小于托盘已分配数量，则可以继续添加该托盘出库信息
            //    {
            //        float orderDetailNeedQuantity = mesPPOutboundOrder.OrderQuantity - detailAssignQuantity;
            //        if (orderDetailNeedQuantity > autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity)
            //        {
            //            mesPPOutboundOrder.LockQuantity += autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity;
            //            Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, autoAssignStocks[j], autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity);
            //            outStockLockInfos.Add(outStockLockInfo);
            //        }
            //        else
            //        {
            //            Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, autoAssignStocks[j], mesPPOutboundOrder.OrderQuantity - mesPPOutboundOrder.LockQuantity);
            //            outStockLockInfos.Add(outStockLockInfo);
            //            mesPPOutboundOrder.LockQuantity = mesPPOutboundOrder.OrderQuantity;
            //            break;
            //        }
            //    }
            //}
            //locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList()));

            return (outStocks, mesPPOutboundOrder, outStockLockInfos, locationInfos);
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/MesPPOutboundOrderService.cs

@@ -34,109 +34,110 @@
            _recordService = recordService;
        }

        public (List<Dt_StockInfo>, Dt_MesPPOutboundOrder, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPOutboundOrder mesPPOutboundOrder)
        {
            List<Dt_StockInfo> outStocks = new List<Dt_StockInfo>();
        //public (List<Dt_StockInfo>, Dt_MesPPOutboundOrder, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPOutboundOrder mesPPOutboundOrder)
        //{
        //    List<Dt_StockInfo> outStocks = new List<Dt_StockInfo>();

            List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
            List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();
        //    List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
        //    List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();

            float originalNeedQuantity = mesPPOutboundOrder.OrderQuantity;
        //    float originalNeedQuantity = mesPPOutboundOrder.OrderQuantity;

            float needQuantity = originalNeedQuantity;
        //    float needQuantity = originalNeedQuantity;

            List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseableStocks(mesPPOutboundOrder.MaterialCode, "", mesPPOutboundOrder.Details.FirstOrDefault()?.CarrierCode ?? "",mesPPOutboundOrder.WarehouseId);
            if (!stockInfos.Any())
            {
                throw new Exception($"未找到可分配库存");
            }
            List<Dt_StockInfo> autoAssignStocks = _stockService.StockInfoService.GetOutboundStocks(stockInfos, mesPPOutboundOrder.MaterialCode, needQuantity, out float residueQuantity);
            mesPPOutboundOrder.LockQuantity += needQuantity - residueQuantity;
            outStocks.AddRange(autoAssignStocks);
            float assignQuantity = needQuantity - residueQuantity;
        //    List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseableStocks(mesPPOutboundOrder.MaterialCode, "", mesPPOutboundOrder.Details.FirstOrDefault()?.CarrierCode ?? "",mesPPOutboundOrder.WarehouseId);
        //    if (!stockInfos.Any())
        //    {
        //        throw new Exception($"未找到可分配库存");
        //    }
        //    List<Dt_StockInfo> autoAssignStocks = _stockService.StockInfoService.GetOutboundStocks(stockInfos, mesPPOutboundOrder.MaterialCode, needQuantity, out float residueQuantity);
        //    mesPPOutboundOrder.LockQuantity += needQuantity - residueQuantity;
        //    outStocks.AddRange(autoAssignStocks);
        //    float assignQuantity = needQuantity - residueQuantity;

            float orderQuantity = mesPPOutboundOrder.OrderQuantity;
            for (int j = 0; j < autoAssignStocks.Count; j++)
            {
                float detailAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPOutboundOrder.MaterialCode).Sum(x => x.AssignQuantity);//出库订单明细已分配数量
        //    float orderQuantity = mesPPOutboundOrder.OrderQuantity;
        //    for (int j = 0; j < autoAssignStocks.Count; j++)
        //    {
        //        float detailAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPOutboundOrder.MaterialCode).Sum(x => x.AssignQuantity);//出库订单明细已分配数量

                float palletAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPOutboundOrder.MaterialCode && x.PalletCode == autoAssignStocks[j].PalletCode).Sum(x => x.AssignQuantity);//出库详情已分配数量
        //        float palletAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPOutboundOrder.MaterialCode && x.PalletCode == autoAssignStocks[j].PalletCode).Sum(x => x.AssignQuantity);//出库详情已分配数量

                float palletOutboundQuantity = autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity);
                if (palletAssignQuantity < palletOutboundQuantity)//如果出库详情已分配数量小于托盘已分配数量，则可以继续添加该托盘出库信息
                {
                    float orderDetailNeedQuantity = mesPPOutboundOrder.OrderQuantity - detailAssignQuantity;
                    if (orderDetailNeedQuantity > autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity)
                    {
                        mesPPOutboundOrder.LockQuantity += autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity;
                        Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, autoAssignStocks[j], autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity);
                        outStockLockInfos.Add(outStockLockInfo);
                    }
                    else
                    {
                        Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, autoAssignStocks[j], mesPPOutboundOrder.OrderQuantity - mesPPOutboundOrder.LockQuantity);
                        outStockLockInfos.Add(outStockLockInfo);
                        mesPPOutboundOrder.LockQuantity = mesPPOutboundOrder.OrderQuantity;
                        break;
                    }
                }
            }
            locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList()));
        //        float palletOutboundQuantity = autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity);
        //        if (palletAssignQuantity < palletOutboundQuantity)//如果出库详情已分配数量小于托盘已分配数量，则可以继续添加该托盘出库信息
        //        {
        //            float orderDetailNeedQuantity = mesPPOutboundOrder.OrderQuantity - detailAssignQuantity;
        //            if (orderDetailNeedQuantity > autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity)
        //            {
        //                mesPPOutboundOrder.LockQuantity += autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity;
        //                Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, autoAssignStocks[j], autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity);
        //                outStockLockInfos.Add(outStockLockInfo);
        //            }
        //            else
        //            {
        //                Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, autoAssignStocks[j], mesPPOutboundOrder.OrderQuantity - mesPPOutboundOrder.LockQuantity);
        //                outStockLockInfos.Add(outStockLockInfo);
        //                mesPPOutboundOrder.LockQuantity = mesPPOutboundOrder.OrderQuantity;
        //                break;
        //            }
        //        }
        //    }
        //    locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList()));

            return (outStocks, mesPPOutboundOrder, outStockLockInfos, locationInfos);
        }
        //    return (outStocks, mesPPOutboundOrder, outStockLockInfos, locationInfos);
        //}


        public (List<Dt_StockInfo>, Dt_MesPPCutOutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPCutOutboundOrder mesPPOutboundOrder, Dt_MesPPCutOutboundOrderDetail mesPPCutOutboundOrderDetail)
        {
            List<Dt_StockInfo> outStocks = new List<Dt_StockInfo>();
        //public (List<Dt_StockInfo>, Dt_MesPPCutOutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesPPCutOutboundOrder mesPPOutboundOrder, Dt_MesPPCutOutboundOrderDetail mesPPCutOutboundOrderDetail)
        //{
        //    List<Dt_StockInfo> outStocks = new List<Dt_StockInfo>();

            List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
            List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();
            //Dt_MesPPCutOutboundOrder outboundOrder = BaseDal.Db.Queryable<Dt_MesPPCutOutboundOrder>().Where(x=>x.Id==mesPPOutboundOrder.OrderId).First();
            float originalNeedQuantity = mesPPCutOutboundOrderDetail.OrderQuantity;
        //    List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
        //    List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();
        //    //Dt_MesPPCutOutboundOrder outboundOrder = BaseDal.Db.Queryable<Dt_MesPPCutOutboundOrder>().Where(x=>x.Id==mesPPOutboundOrder.OrderId).First();
        //    float originalNeedQuantity = mesPPCutOutboundOrderDetail.OrderQuantity;

            float needQuantity = originalNeedQuantity;
        //    float needQuantity = originalNeedQuantity;

            List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseableStocks(mesPPCutOutboundOrderDetail.MaterielCode,  "", mesPPOutboundOrder.WarehouseId);
            if (!stockInfos.Any())
            {
                throw new Exception($"未找到可分配库存");
            }
            List<Dt_StockInfo> autoAssignStocks = _stockService.StockInfoService.GetOutboundStocks(stockInfos, mesPPCutOutboundOrderDetail.MaterielCode, needQuantity, out float residueQuantity);
            mesPPCutOutboundOrderDetail.LockQuantity += needQuantity - residueQuantity;
            outStocks.AddRange(autoAssignStocks);
            float assignQuantity = needQuantity - residueQuantity;
        //    List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseableStocks(mesPPCutOutboundOrderDetail.MaterielCode,  "", mesPPOutboundOrder.WarehouseId);
        //    if (!stockInfos.Any())
        //    {
        //        throw new Exception($"未找到可分配库存");
        //    }
        //    List<Dt_StockInfo> autoAssignStocks = _stockService.StockInfoService.GetOutboundStocks(stockInfos, mesPPCutOutboundOrderDetail.MaterielCode, needQuantity, out float residueQuantity);
        //    mesPPCutOutboundOrderDetail.LockQuantity += needQuantity - residueQuantity;
        //    outStocks.AddRange(autoAssignStocks);
        //    float assignQuantity = needQuantity - residueQuantity;

            float orderQuantity = mesPPCutOutboundOrderDetail.OrderQuantity;
            for (int j = 0; j < autoAssignStocks.Count; j++)
            {
                float detailAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPCutOutboundOrderDetail.MaterielCode).Sum(x => x.AssignQuantity);//出库订单明细已分配数量
        //    float orderQuantity = mesPPCutOutboundOrderDetail.OrderQuantity;
        //    for (int j = 0; j < autoAssignStocks.Count; j++)
        //    {
        //        float detailAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPCutOutboundOrderDetail.MaterielCode).Sum(x => x.AssignQuantity);//出库订单明细已分配数量

                float palletAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPCutOutboundOrderDetail.MaterielCode && x.PalletCode == autoAssignStocks[j].PalletCode).Sum(x => x.AssignQuantity);//出库详情已分配数量
        //        float palletAssignQuantity = outStockLockInfos.Where(x => x.MaterielCode == mesPPCutOutboundOrderDetail.MaterielCode && x.PalletCode == autoAssignStocks[j].PalletCode).Sum(x => x.AssignQuantity);//出库详情已分配数量

                float palletOutboundQuantity = autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity);
                if (palletAssignQuantity < palletOutboundQuantity)//如果出库详情已分配数量小于托盘已分配数量，则可以继续添加该托盘出库信息
                {
                    float orderDetailNeedQuantity = mesPPCutOutboundOrderDetail.OrderQuantity - detailAssignQuantity;
                    if (orderDetailNeedQuantity > autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity)
                    {
                        mesPPCutOutboundOrderDetail.LockQuantity += autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity;
                        Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, mesPPCutOutboundOrderDetail, autoAssignStocks[j], autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity);
                        outStockLockInfos.Add(outStockLockInfo);
                    }
                    else
                    {
                        Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, mesPPCutOutboundOrderDetail, autoAssignStocks[j], mesPPCutOutboundOrderDetail.OrderQuantity - mesPPCutOutboundOrderDetail.LockQuantity);
                        outStockLockInfos.Add(outStockLockInfo);
                        mesPPCutOutboundOrderDetail.LockQuantity = mesPPCutOutboundOrderDetail.OrderQuantity;
                        break;
                    }
                }
            }
            locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList()));
        //        float palletOutboundQuantity = autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity);
        //        if (palletAssignQuantity < palletOutboundQuantity)//如果出库详情已分配数量小于托盘已分配数量，则可以继续添加该托盘出库信息
        //        {
        //            float orderDetailNeedQuantity = mesPPCutOutboundOrderDetail.OrderQuantity - detailAssignQuantity;
        //            if (orderDetailNeedQuantity > autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity)
        //            {
        //                mesPPCutOutboundOrderDetail.LockQuantity += autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity;
        //                Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, mesPPCutOutboundOrderDetail, autoAssignStocks[j], autoAssignStocks[j].Details.Sum(x => x.OutboundQuantity) - palletAssignQuantity);
        //                outStockLockInfos.Add(outStockLockInfo);
        //            }
        //            else
        //            {
        //                Dt_OutStockLockInfo outStockLockInfo = _outStockLockInfoService.GetOutStockLockInfo(mesPPOutboundOrder, mesPPCutOutboundOrderDetail, autoAssignStocks[j], mesPPCutOutboundOrderDetail.OrderQuantity - mesPPCutOutboundOrderDetail.LockQuantity);
        //                outStockLockInfos.Add(outStockLockInfo);
        //                mesPPCutOutboundOrderDetail.LockQuantity = mesPPCutOutboundOrderDetail.OrderQuantity;
        //                break;
        //            }
        //        }
        //    }
        //    locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList()));

            return (outStocks, mesPPCutOutboundOrderDetail, outStockLockInfos, locationInfos);
        }
        //    return (outStocks, mesPPCutOutboundOrderDetail, outStockLockInfos, locationInfos);
        //}
  
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/OutStockLockInfoService.cs

@@ -124,32 +124,37 @@
        /// <param name="assignQuantity"></param>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        public Dt_OutStockLockInfo GetOutStockLockInfo(Dt_MesPPCutOutboundOrder mesPPCutOutboundOrder,Dt_MesPPCutOutboundOrderDetail  mesPPCutOutboundOrderDetail, Dt_StockInfo outStock, float assignQuantity, int? taskNum = null)
        public List<Dt_OutStockLockInfo> GetOutStockLockInfos(Dt_MesPPCutOutboundOrder mesPPCutOutboundOrder, Dt_MesPPCutOutboundOrderDetail mesPPCutOutboundOrderDetail, List<Dt_StockInfo> outStock, int? taskNum = null)
        {
            List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();

            Dt_OutStockLockInfo outStockLockInfo = new Dt_OutStockLockInfo()
            foreach (var item in outStock)
            {
                PalletCode = outStock.PalletCode,
                AssignQuantity = assignQuantity,
                MaterielCode = mesPPCutOutboundOrderDetail.MaterielCode,
                BatchNo = outStock.Details.FirstOrDefault()?.BatchNo ?? "",
                LocationCode = outStock.LocationCode,
                MaterielName = mesPPCutOutboundOrderDetail.MaterielName,
                OrderDetailId = mesPPCutOutboundOrderDetail.Id,
                OrderNo = mesPPCutOutboundOrder.OrderNo,
                OrderType = mesPPCutOutboundOrder.OrderType,
                OriginalQuantity = outStock.Details.Where(x => x.MaterielCode == mesPPCutOutboundOrderDetail.MaterielCode).Sum(x => x.StockQuantity),
                Status = taskNum == null ? OutLockStockStatusEnum.已分配.ObjToInt() : OutLockStockStatusEnum.出库中.ObjToInt(),
                StockId = outStock.Id,
                TaskNum = taskNum,
                OrderQuantity = mesPPCutOutboundOrderDetail.OrderQuantity,
                Unit = mesPPCutOutboundOrderDetail.Unit
            };
                Dt_OutStockLockInfo outStockLockInfo = new Dt_OutStockLockInfo()
                {
                    PalletCode = item.PalletCode,
                    AssignQuantity = item.Details.Where(x => x.MaterielCode == mesPPCutOutboundOrderDetail.MaterielCode).Sum(x => x.OutboundQuantity),
                    MaterielCode = mesPPCutOutboundOrderDetail.MaterielCode,
                    BatchNo = item.Details.FirstOrDefault().BatchNo,
                    LocationCode = item.LocationCode,
                    MaterielName = mesPPCutOutboundOrderDetail.MaterielName,
                    OrderDetailId = mesPPCutOutboundOrderDetail.Id,
                    OrderNo = mesPPCutOutboundOrder.OrderNo,
                    OrderType = mesPPCutOutboundOrder.OrderType,
                    OriginalQuantity = item.Details.Where(x => x.MaterielCode == mesPPCutOutboundOrderDetail.MaterielCode).Sum(x => x.StockQuantity),
                    Status = taskNum == null ? OutLockStockStatusEnum.已分配.ObjToInt() : OutLockStockStatusEnum.出库中.ObjToInt(),
                    StockId = item.Id,
                    TaskNum = taskNum,
                    OrderQuantity = mesPPCutOutboundOrderDetail.OrderQuantity,
                    Unit = mesPPCutOutboundOrderDetail.Unit
                };
                outStockLockInfos.Add(outStockLockInfo);
            }

            return outStockLockInfo;
            return outStockLockInfos;
        }

        public Dt_OutStockLockInfo GetOutStockLockInfo(Dt_MesPPOutboundOrder  mesPPOutboundOrder, Dt_StockInfo outStock, float assignQuantity, int? taskNum = null)
        public Dt_OutStockLockInfo GetOutStockLockInfo(Dt_MesPPOutboundOrder mesPPOutboundOrder, Dt_StockInfo outStock, float assignQuantity, int? taskNum = null)
        {

            Dt_OutStockLockInfo outStockLockInfo = new Dt_OutStockLockInfo()

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_OutboundService/OutboundService.cs

@@ -19,20 +19,22 @@

        public IMesPPOutboundOrderService MesPPOutboundOrderService { get; }

        public IMesPPOutboundOrderDetailService MesPPOutboundOrderDetailService { get; }
        public IMesPPOutboundOrderDetailService  MesPPOutboundOrderDetailService { get; }

        public IMesPPCutOutboundOrderService MesPPCutOutboundOrderService { get; }

        public IMesPPCutOutboundOrderDetailService MesPPCutOutboundOrderDetailService { get; }

        public OutboundService(IOutboundOrderDetailService outboundOrderDetailService,IMesPPOutboundOrderService mesPPOutboundOrderService, IOutboundOrderService outboundOrderService, IOutStockLockInfoService outboundStockLockInfoService, IMesOutboundOrderService mesOutboundOrderService)
        public OutboundService(IOutboundOrderDetailService outboundOrderDetailService, IMesPPOutboundOrderDetailService mesPPOutboundOrderDetailService, IMesPPCutOutboundOrderDetailService mesPPCutOutboundOrderDetailService, IMesPPCutOutboundOrderService mesPPCutOutboundOrderService, IMesPPOutboundOrderService mesPPOutboundOrderService, IOutboundOrderService outboundOrderService, IOutStockLockInfoService outboundStockLockInfoService, IMesOutboundOrderService mesOutboundOrderService)
        {
            OutboundOrderDetailService = outboundOrderDetailService;
            OutboundOrderService = outboundOrderService;
            OutboundStockLockInfoService = outboundStockLockInfoService;
            MesOutboundOrderService = mesOutboundOrderService;
            MesPPOutboundOrderService = mesPPOutboundOrderService;

            MesPPCutOutboundOrderService = mesPPCutOutboundOrderService;
            MesPPCutOutboundOrderDetailService = mesPPCutOutboundOrderDetailService;
            MesPPOutboundOrderDetailService = mesPPOutboundOrderDetailService;
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockService/StockInfoService.cs

@@ -55,7 +55,7 @@
                    throw new Exception($"未找到出库单信息");
                }

                List<string> locationCodes = _basicRepository.LocationInfoRepository.GetCanOutLocationCodes(outboundOrder.WarehouseId);
                List<string> locationCodes = _basicRepository.LocationInfoRepository.PPGetCanOutLocationCodes(outboundOrder.WarehouseId);

                return BaseDal.QueryTabs<Dt_StockInfo, Dt_StockInfoDetail, StockSelectViewDTO>((a, b) => a.Id == b.StockId, (a, b) => new StockSelectViewDTO
                {
@@ -115,6 +115,92 @@
                return null;
            }
        }
        /// <summary>
        /// æŸ¥è¯¢è®¢å•PP立库库存视图
        /// </summary>
        /// <param name="orderId"></param>
        /// <param name="materielCode"></param>
        /// <returns></returns>
        public List<PPStockSelectViewDTO> PPGetStockSelectViews(int orderId, string materielCode)
        {
            try
            {
                Dt_MesPPCutOutboundOrder mesPPCutOutboundOrder = _outboundRepository.MesPPCutOutboundOrderRepository.QueryFirst(x => x.Id == orderId);
                if (mesPPCutOutboundOrder == null)
                {
                    throw new Exception($"未找到出库单信息");
                }
                List<string> locationCodes = _basicRepository.LocationInfoRepository.PPGetCanOutLocationCodes(mesPPCutOutboundOrder.WarehouseId);

                return BaseDal.QueryTabs<Dt_StockInfo, Dt_StockInfoDetail, PPStockSelectViewDTO>((a, b) => a.Id == b.StockId, (a, b) => new PPStockSelectViewDTO
                {
                    LocationCode = a.LocationCode,
                    MaterielCode = b.MaterielCode,
                    MaterielName = b.MaterielName,
                    PalletCode = a.PalletCode,
                    Unit = b.Unit,
                    CutedWidth = b.CutedWidth,
                    UseableQuantity = b.StockQuantity - b.OutboundQuantity
                }, a => locationCodes.Contains(a.LocationCode), b => b.StockQuantity > b.OutboundQuantity && b.MaterielCode == materielCode, x => true).GroupBy(x => x.PalletCode).Select(x => new PPStockSelectViewDTO
                {
                    LocationCode = x.FirstOrDefault()?.LocationCode ?? "",
                    MaterielCode = x.FirstOrDefault()?.MaterielCode ?? "",
                    MaterielName = x.FirstOrDefault()?.MaterielName ?? "",
                    Unit = x.FirstOrDefault()?.Unit ?? "",
                    CutedWidth = x.Sum(x => x.CutedWidth),
                    PalletCode = x.Key,
                    UseableQuantity = x.Sum(x => x.UseableQuantity)
                }).ToList();
            }
            catch (Exception ex)
            {

                return null;
            }
        }

        /// <summary>
        /// æŸ¥è¯¢è®¢å•PP平库库存视图
        /// </summary>
        /// <param name="orderId"></param>
        /// <param name="materielCode"></param>
        /// <returns></returns>
        public List<PPStockSelectViewDTO> PPGetPKStockSelectViews(int orderId, string materielCode)
        {
            try
            {
                Dt_MesPPCutOutboundOrder outboundOrder = _outboundRepository.MesPPCutOutboundOrderRepository.QueryFirst(x => x.Id == orderId);
                if (outboundOrder == null)
                {
                    throw new Exception($"未找到出库单信息");
                }
                return BaseDal.QueryTabs<Dt_StockInfo, Dt_StockInfoDetail, PPStockSelectViewDTO>((a, b) => a.Id == b.StockId && a.WarehouseId == outboundOrder.WarehouseId, (a, b) => new PPStockSelectViewDTO
                {
                    LocationCode = a.LocationCode,
                    MaterielCode = b.MaterielCode,
                    MaterielName = b.MaterielName,
                    PalletCode = a.PalletCode,
                    Unit = b.Unit,
                    CutedWidth = b.CutedWidth,
                    UseableQuantity = b.StockQuantity - b.OutboundQuantity
                }, a => a.LocationCode.Contains("AGV_PP"), b => b.StockQuantity > b.OutboundQuantity && b.MaterielCode == materielCode, x => true).GroupBy(x => x.PalletCode).Select(x => new PPStockSelectViewDTO
                {
                    LocationCode = x.FirstOrDefault()?.LocationCode ?? "",
                    MaterielCode = x.FirstOrDefault()?.MaterielCode ?? "",
                    MaterielName = x.FirstOrDefault()?.MaterielName ?? "",
                    Unit = x.FirstOrDefault()?.Unit ?? "",
                    CutedWidth = x.Sum(x => x.CutedWidth),
                    PalletCode = x.Key,
                    UseableQuantity = x.Sum(x => x.UseableQuantity)
                }).ToList();
            }
            catch (Exception ex)
            {
                return null;
            }
        }



        public WebResponseContent StockQueryData(SaveModel saveModel)
        {

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/MesTaskService.cs

@@ -28,6 +28,7 @@
using System.Reflection.Metadata;
using WIDESEA_DTO.Task;
using WIDESEA_DTO.Stock;
using SqlSugar;

namespace WIDESEA_TaskInfoService
{
@@ -530,7 +531,14 @@
                List<Dt_MesPPOutboundOrderDetail> mesPPOutboundOrderDetail = new List<Dt_MesPPOutboundOrderDetail>();
                foreach (var item in model.Carriers)
                {
                    mesPPOutboundOrderDetail.Add(_mapper.Map<Dt_MesPPOutboundOrderDetail>(item));
                    //mesPPOutboundOrderDetail.Add(_mapper.Map<Dt_MesPPOutboundOrderDetail>(item));
                    Dt_MesPPOutboundOrderDetail dt_MesPPOutboundOrderDetail = new Dt_MesPPOutboundOrderDetail
                    {
                        CarrierCode = item.CarrierCode,
                        Warehouse = item.Warehouse,
                        OrderDetailStatus = OrderDetailStatusEnum.New.ObjToInt()
                    };
                    mesPPOutboundOrderDetail.Add(dt_MesPPOutboundOrderDetail);
                }
                Dt_MesPPOutboundOrder mesOutboundOrder = new Dt_MesPPOutboundOrder()
                {
@@ -542,8 +550,8 @@
                    Unit = model.Unit,//PP需要转换成米(需求平方(PNL数*面积)/宽度)
                    Width = model.Width,
                    TargetAddressCode = model.TargetAddressCode,
                    OrderType = TaskTypeEnum.MesHandPickOutbound.ObjToInt(),
                    OrderStatus = OutOrderStatusEnum.未开始.ObjToInt(),
                    OrderType = OutOrderTypeEnum.Issue.ObjToInt(),
                    WarehouseId = warehouse.WarehouseId,
                    Details = mesPPOutboundOrderDetail
                };
@@ -555,7 +563,7 @@
                //    List<Dt_OutStockLockInfo>? outStockLockInfos = null;
                //    List<Dt_LocationInfo>? locationInfos = null;
                //    {
                (List<Dt_StockInfo>, Dt_MesPPOutboundOrder, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) result = _outboundService.MesPPOutboundOrderService.AssignStockOutbound(mesOutboundOrder);
                //(List<Dt_StockInfo>, Dt_MesPPOutboundOrder, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) result = _outboundService.MesPPOutboundOrderService.AssignStockOutbound(mesOutboundOrder);
                //        if (result.Item1 != null && result.Item1.Count > 0)
                //        {
                //            tasks = GetTasks(result.Item1, TaskTypeEnum.MesOutbound);
@@ -645,12 +653,14 @@
                {
                    CreateType = OrderCreateTypeEnum.UpperSystemPush.ObjToInt(),
                    TaskNo = model.TaskNo,
                    OrderType = TaskTypeEnum.MesOutbound.ObjToInt(),
                    OrderType = OutOrderTypeEnum.Issue.ObjToInt(),
                    OrderStatus = OutOrderStatusEnum.未开始.ObjToInt(),
                    WarehouseId = warehouse.WarehouseId,
                    Details = mesPPCutOutboundOrderDetail,
                };
                _unitOfWorkManage.BeginTran();
                Db.InsertNav(mesPPOutboundOrder).Include(x => x.Details).ExecuteCommand();
                _unitOfWorkManage.CommitTran();
                #region
                //List<Dt_Task> tasks = new List<Dt_Task>();

@@ -710,7 +720,7 @@
            }
            catch (Exception ex)
            {

                _unitOfWorkManage.RollbackTran();
                return MesResponseContent.Instance.Error(ex.Message);
            }
        }
@@ -895,7 +905,7 @@
                {
                    content.Content = new
                    {
                        MaterialCode= stock.MaterielCode,
                        MaterialCode = stock.MaterielCode,
                        Quantity = stock.StockQuantity,
                        Unit = stock.Unit,
                        Warehouse = warehouse.WarehouseCode,
@@ -980,8 +990,11 @@
            return MesResponseContent.Instance.OK();
        }




        /// <summary>
        /// ç”Ÿæˆå‡ºåº“任务
        /// ç”ŸæˆPP大卷出库任务
        /// </summary>
        /// <param name="keys">出库单明细主键</param>
        /// <returns></returns>
@@ -996,7 +1009,7 @@
                List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
                List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();

                (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_MesPPOutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?) result = MESPPOutboundTaskDataHandle(keys);
                (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_MesPPOutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?, Dt_MesPPOutboundOrder mesPPOutboundOrder) result = MESPPOutboundTaskDataHandle(keys);
                if (result.Item2 != null && result.Item2.Count > 0)
                {
                    stockInfos.AddRange(result.Item2);
@@ -1017,13 +1030,131 @@
                {
                    tasks.AddRange(result.Item1);
                }
                if (result.mesPPOutboundOrder != null)
                {

                WebResponseContent content = MESPPGenerateOutboundTaskDataUpdate(tasks, stockInfos, outboundOrderDetails, outStockLockInfos, locationInfos);
                }

                WebResponseContent content = MESPPGenerateOutboundTaskDataUpdate(tasks, stockInfos, outboundOrderDetails, outStockLockInfos, locationInfos, result.mesPPOutboundOrder);
                return content;
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        /// <summary>
        /// PP大卷出库任务数据处理
        /// </summary>
        /// <param name="orderDetailId"></param>
        /// <param name="stockSelectViews"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_MesPPOutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?, Dt_MesPPOutboundOrder mesPPOutboundOrder) MESPPOutboundTaskDataHandle(int[] keys)
        {
            List<Dt_Task> tasks = new List<Dt_Task>();
            List<Dt_MesPPOutboundOrderDetail> outboundOrderDetails = BaseDal.Db.Queryable<Dt_MesPPOutboundOrderDetail>().Where(x => keys.Contains(x.Id)).ToList();
            if (outboundOrderDetails == null || outboundOrderDetails.Count == 0)
            {
                throw new Exception("未找到出库单明细信息");
            }
            if (outboundOrderDetails.FirstOrDefault(x => x.OrderDetailStatus > OrderDetailStatusEnum.New.ObjToInt() && x.OrderDetailStatus != OrderDetailStatusEnum.AssignOverPartial.ObjToInt()) != null)
            {
                throw new Exception("所选出库单明细存在出库中或已完成");
            }
            List<Dt_StockInfo>? stockInfos = null;
            List<Dt_MesPPOutboundOrderDetail>? orderDetails = null;
            List<Dt_OutStockLockInfo>? outStockLockInfos = null;
            List<Dt_LocationInfo>? locationInfos = null;
            Dt_MesPPOutboundOrder? mesPPOutboundOrders = null;
            if (outboundOrderDetails.FirstOrDefault().OrderDetailStatus == OrderDetailStatusEnum.New.ObjToInt())
            {
                (List<Dt_StockInfo>, List<Dt_MesPPOutboundOrderDetail>, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>, Dt_MesPPOutboundOrder mesPPOutboundOrder) result = _outboundService.MesPPOutboundOrderDetailService.AssignStockOutbound(outboundOrderDetails);
                if (result.Item1 != null && result.Item1.Count > 0)
                {
                    Dt_MesPPOutboundOrder outboundOrder = _outboundService.MesPPOutboundOrderService.Repository.QueryFirst(x => x.Id == outboundOrderDetails.FirstOrDefault().OrderId);
                    TaskTypeEnum typeEnum = outboundOrder.OrderType switch
                    {
                        (int)OutOrderTypeEnum.Issue => TaskTypeEnum.Outbound,
                        (int)OutOrderTypeEnum.Allocate => TaskTypeEnum.OutAllocate,
                        (int)OutOrderTypeEnum.Quality => TaskTypeEnum.OutQuality,
                        _ => new TaskTypeEnum()
                    };
                    tasks = GetTasks(result.Item1, typeEnum);
                    result.Item2.ForEach(x =>
                    {
                        x.OrderDetailStatus = OrderDetailStatusEnum.Outbound.ObjToInt();
                    });
                    result.Item3.ForEach(x =>
                    {
                        x.Status = OutLockStockStatusEnum.出库中.ObjToInt();
                    });

                    stockInfos = result.Item1;
                    orderDetails = result.Item2;
                    outStockLockInfos = result.Item3;
                    locationInfos = result.Item4;
                    mesPPOutboundOrders = result.mesPPOutboundOrder;
                }
                else
                {
                    throw new Exception("无库存");
                }
            }
            //else
            //{
            //    List<Dt_OutStockLockInfo> stockLockInfos = _outboundService.OutboundStockLockInfoService.GetByOrderDetailId(outboundOrderDetails.oi, OutLockStockStatusEnum.已分配);
            //    if (stockLockInfos != null && stockLockInfos.Count > 0)
            //    {
            //        List<Dt_StockInfo> stocks = _stockService.StockInfoService.Repository.GetStockInfosByPalletCodes(stockLockInfos.Select(x => x.PalletCode).Distinct().ToList());
            //        tasks = GetTasks(stocks);
            //    }
            //}

            return (tasks, stockInfos, orderDetails, outStockLockInfos, locationInfos, mesPPOutboundOrders);
        }

        /// <summary>
        /// PP平库直接出库
        /// </summary>
        /// <param name="orderDetailId"></param>
        /// <param name="stockSelectViews"></param>
        /// <returns></returns>
        public WebResponseContent PPGeneratePKOutboundTask(int orderDetailId, List<PPStockSelectViewDTO> stockSelectViews)
        {
            try
            {
                (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_MesPPCutOutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?) result = PPOutboundTaskDataHandle(orderDetailId, stockSelectViews);

                WebResponseContent content = PPGenerateOutboundTaskDataUpdate(result.Item1, result.Item2, result.Item3, result.Item4, result.Item5);

                return content;
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
        /// <summary>
        /// PP立库小卷直接出库
        /// </summary>
        /// <param name="orderDetailId"></param>
        /// <param name="stockSelectViews"></param>
        /// <returns></returns>
        public WebResponseContent PPCutOutGenerateOutboundTasks(int orderDetailId, List<PPStockSelectViewDTO> stockSelectViews)
        {
            try
            {
                (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_MesPPCutOutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?) result = PPOutboundTaskDataHandle(orderDetailId, stockSelectViews);

                WebResponseContent content = PPGenerateOutboundTaskDataUpdate(result.Item1, result.Item2, result.Item3, result.Item4, result.Item5);

                return content;
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
@@ -1035,85 +1166,68 @@
        /// <param name="stockSelectViews"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_MesPPOutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?) MESPPOutboundTaskDataHandle(int[] keys)
        public (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_MesPPCutOutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?) PPOutboundTaskDataHandle(int orderDetailId, List<PPStockSelectViewDTO> stockSelectViews)
        {
            List<Dt_Task> tasks = new List<Dt_Task>();
            //List<Dt_MesPPOutboundOrderDetail> outboundOrderDetailss = _outboundService.MesPPOutboundOrderDetailService.Repository.QueryData(x => keys.Contains(x.Id));
            Dt_MesPPCutOutboundOrderDetail outboundOrderDetail = _outboundService.MesPPCutOutboundOrderDetailService.Repository.QueryFirst(x => x.Id == orderDetailId);

            //List<Dt_MesPPOutboundOrderDetail> outboundOrderDetails = BaseDal.Db.Queryable<Dt_MesPPOutboundOrderDetail>().Where(x => keys.Contains(x.Id)).ToList();
            //List<Dt_MesPPOutboundOrder> mesPPOutboundOrder = BaseDal.Db.Queryable<Dt_MesPPOutboundOrder>().Where(x => keys.Contains(10)).ToList();
            Dt_MesPPOutboundOrderDetail outboundOrderDetails = BaseDal.Db.Queryable<Dt_MesPPOutboundOrderDetail>().Where(x => keys.Contains(x.Id)).First();
            Dt_MesPPOutboundOrder mesPPOutboundOrder = BaseDal.Db.Queryable<Dt_MesPPOutboundOrder>().Where(x => x.Id == 10).First();
            //if (outboundOrderDetails == null || outboundOrderDetails.Count == 0)
            //{
            //    throw new Exception("未找到出库单明细信息");
            //}
            //if (outboundOrderDetails.FirstOrDefault(x => x.OrderDetailStatus > OrderDetailStatusEnum.New.ObjToInt() && x.OrderDetailStatus != OrderDetailStatusEnum.AssignOverPartial.ObjToInt()) != null)
            //{
            //    throw new Exception("所选出库单明细存在出库中或已完成");
            //}
            if (outboundOrderDetail == null)
            {
                throw new Exception("未找到出库单明细信息");
            }

            if (stockSelectViews.Sum(x => x.UseableQuantity) > outboundOrderDetail.OrderQuantity - outboundOrderDetail.LockQuantity)
            {
                throw new Exception("选择数量超出单据数量");
            }
            List<Dt_StockInfo>? stockInfos = null;
            List<Dt_MesPPOutboundOrderDetail>? orderDetails = null;
            Dt_MesPPCutOutboundOrderDetail? orderDetail = null;
            List<Dt_OutStockLockInfo>? outStockLockInfos = null;
            List<Dt_LocationInfo>? locationInfos = null;
            //if (outboundOrderDetails == OrderDetailStatusEnum.New.ObjToInt())
            if (outboundOrderDetail.OrderDetailStatus == OrderDetailStatusEnum.New.ObjToInt())
            {
                //(List<Dt_StockInfo>, Dt_MesPPOutboundOrder, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) result = _outboundService.MesPPOutboundOrderService.AssignStockOutbound(mesPPOutboundOrder);
                //(List<Dt_StockInfo>, List<Dt_MesPPOutboundOrderDetail>, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) result = _outboundService.MesPPOutboundOrderDetailService.AssignStockOutbound(outboundOrderDetails);
                (List<Dt_StockInfo>, Dt_MesPPOutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) result1 = _outboundService.MesPPOutboundOrderDetailService.AssignStockOutbound(outboundOrderDetails);
                //if (result.Item1 != null && result.Item1.Count > 0)
                //{
                //    Dt_MesPPOutboundOrder outboundOrder = _outboundService.MesPPOutboundOrderService.Repository.QueryFirst(x => x.Id == outboundOrderDetails.FirstOrDefault().OrderId);
                //    TaskTypeEnum typeEnum = outboundOrder.OrderType switch
                //    {
                //        (int)OutOrderTypeEnum.Issue => TaskTypeEnum.Outbound,
                //        (int)OutOrderTypeEnum.Allocate => TaskTypeEnum.OutAllocate,
                //        (int)OutOrderTypeEnum.Quality => TaskTypeEnum.OutQuality,
                //        _ => new TaskTypeEnum()
                //    };
                //    tasks = GetTasks(result.Item1, typeEnum);
                //    result.Item2.ForEach(x =>
                //    {
                //        x.OrderDetailStatus = OrderDetailStatusEnum.Outbound.ObjToInt();
                //    });
                //    result.Item3.ForEach(x =>
                //    {
                //        x.Status = OutLockStockStatusEnum.出库中.ObjToInt();
                //    });
                (List<Dt_StockInfo>, Dt_MesPPCutOutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) result = _outboundService.MesPPCutOutboundOrderDetailService.AssignStockOutbound(outboundOrderDetail, stockSelectViews);
                if (result.Item1 != null && result.Item1.Count > 0)
                {
                    Dt_MesPPCutOutboundOrder outboundOrder = _outboundService.MesPPCutOutboundOrderService.Repository.QueryFirst(x => x.Id == outboundOrderDetail.OrderId);
                    TaskTypeEnum typeEnum = outboundOrder.OrderType switch
                    {
                        (int)OutOrderTypeEnum.Issue => TaskTypeEnum.Outbound,
                        (int)OutOrderTypeEnum.Allocate => TaskTypeEnum.OutAllocate,
                        (int)OutOrderTypeEnum.Quality => TaskTypeEnum.OutQuality,
                        _ => new TaskTypeEnum()
                    };
                    tasks = GetTasks(result.Item1, TaskTypeEnum.Outbound);
                    result.Item2.OrderDetailStatus = OrderDetailStatusEnum.Outbound.ObjToInt();
                    result.Item3.ForEach(x =>
                    {
                        x.Status = OutLockStockStatusEnum.出库中.ObjToInt();
                    });

                //    stockInfos = result.Item1;
                //    orderDetails = result.Item2;
                //    outStockLockInfos = result.Item3;
                //    locationInfos = result.Item4;
                //}
                //else
                //{
                //    throw new Exception("无库存");
                //}
                    stockInfos = result.Item1;
                    orderDetail = result.Item2;
                    outStockLockInfos = result.Item3;
                    locationInfos = result.Item4;
                }
                else
                {
                    throw new Exception("无库存");
                }
            }
            //else
            //{
            //    List<Dt_OutStockLockInfo> stockLockInfos = _outboundService.OutboundStockLockInfoService.GetByOrderDetailId(outboundOrderDetail.OrderId, OutLockStockStatusEnum.已分配);
            //    if (stockLockInfos != null && stockLockInfos.Count > 0)
            //    {
            //        List<Dt_StockInfo> stocks = _stockService.StockInfoService.Repository.GetStockInfosByPalletCodes(stockLockInfos.Select(x => x.PalletCode).Distinct().ToList());
            //        tasks = GetTasks(stocks);
            //    }
            //}
            else
            {
                List<Dt_OutStockLockInfo> stockLockInfos = _outboundService.OutboundStockLockInfoService.GetByOrderDetailId(outboundOrderDetail.OrderId, OutLockStockStatusEnum.已分配);
                if (stockLockInfos != null && stockLockInfos.Count > 0)
                {
                    List<Dt_StockInfo> stocks = _stockService.StockInfoService.Repository.GetStockInfosByPalletCodes(stockLockInfos.Select(x => x.PalletCode).Distinct().ToList());
                    tasks = GetTasks(stocks, TaskTypeEnum.Outbound);
                }
            }

            return (tasks, stockInfos, orderDetails, outStockLockInfos, locationInfos);
            return (tasks, stockInfos, orderDetail == null ? null : new List<Dt_MesPPCutOutboundOrderDetail> { orderDetail }, outStockLockInfos, locationInfos);
        }

        /// <summary>
        /// ç”Ÿæˆå‡ºåº“任务后数据更新到数据库
        /// </summary>
        /// <param name="tasks"></param>
        /// <param name="stockInfos"></param>
        /// <param name="outboundOrderDetails"></param>
        /// <param name="outStockLockInfos"></param>
        /// <param name="locationInfos"></param>
        /// <returns></returns>
        public WebResponseContent MESPPGenerateOutboundTaskDataUpdate(List<Dt_Task> tasks, List<Dt_StockInfo>? stockInfos = null, List<Dt_MesPPOutboundOrderDetail>? outboundOrderDetails = null, List<Dt_OutStockLockInfo>? outStockLockInfos = null, List<Dt_LocationInfo>? locationInfos = null)
        public WebResponseContent PPGenerateOutboundTaskDataUpdate(List<Dt_Task> tasks, List<Dt_StockInfo>? stockInfos = null, List<Dt_MesPPCutOutboundOrderDetail>? outboundOrderDetails = null, List<Dt_OutStockLockInfo>? outStockLockInfos = null, List<Dt_LocationInfo>? locationInfos = null)
        {
            try
            {
@@ -1126,7 +1240,224 @@
                    {
                        x.StockStatus = StockStatusEmun.出库锁定.ObjToInt();
                    });
                    WebResponseContent content = _outboundService.MesPPOutboundOrderDetailService.LockOutboundStockDataUpdate(stockInfos, outboundOrderDetails, outStockLockInfos, locationInfos, tasks: tasks);
                    WebResponseContent content = _outboundService.MesPPCutOutboundOrderDetailService.LockOutboundStockDataUpdate(stockInfos, outboundOrderDetails, outStockLockInfos, locationInfos, tasks: tasks);
                    if (!content.Status)
                    {
                        _unitOfWorkManage.RollbackTran();
                        return content;
                    }
                }
                else if (outboundOrderDetails != null && outboundOrderDetails.Count > 0)
                {
                    outboundOrderDetails.ForEach(x =>
                    {
                        x.OrderDetailStatus = OrderDetailStatusEnum.Outbound.ObjToInt();
                    });

                    _outboundService.MesPPCutOutboundOrderDetailService.Repository.UpdateData(outboundOrderDetails);
                }
                _unitOfWorkManage.CommitTran();
                PushTasksToWCS(tasks);
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error(ex.Message);
            }

        }
        #region
        /// <summary>
        /// ç”ŸæˆPP小卷出库任务
        /// </summary>
        /// <param name="keys">出库单明细主键</param>
        /// <returns></returns>
        //public WebResponseContent PPCutOutGenerateOutboundTasks(int[] keys)
        //{
        //    try
        //    {
        //        List<Dt_Task> tasks = new List<Dt_Task>();
        //        List<StockSelectViewDTO> stockSelectViews = new List<StockSelectViewDTO>();
        //        List<Dt_StockInfo> stockInfos = new List<Dt_StockInfo>();
        //        List<Dt_MesPPCutOutboundOrderDetail> outboundOrderDetails = new List<Dt_MesPPCutOutboundOrderDetail>();
        //        List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();
        //        List<Dt_LocationInfo> locationInfos = new List<Dt_LocationInfo>();

        //        (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_MesPPCutOutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?) result = PPCutOutboundTaskDataHandle(keys);
        //        if (result.Item2 != null && result.Item2.Count > 0)
        //        {
        //            stockInfos.AddRange(result.Item2);
        //        }
        //        if (result.Item3 != null && result.Item3.Count > 0)
        //        {
        //            outboundOrderDetails.AddRange(result.Item3);
        //        }
        //        if (result.Item4 != null && result.Item4.Count > 0)
        //        {
        //            outStockLockInfos.AddRange(result.Item4);
        //        }
        //        if (result.Item5 != null && result.Item5.Count > 0)
        //        {
        //            locationInfos.AddRange(result.Item5);
        //        }
        //        if (result.Item1 != null && result.Item1.Count > 0)
        //        {
        //            tasks.AddRange(result.Item1);
        //        }

        //        WebResponseContent content = PPCutOutGenerateOutboundTaskDataUpdate(tasks, stockInfos, outboundOrderDetails, outStockLockInfos, locationInfos);
        //        return content;
        //    }
        //    catch (Exception ex)
        //    {
        //        _unitOfWorkManage.RollbackTran();
        //        return WebResponseContent.Instance.Error(ex.Message);
        //    }
        //}

        ///// <summary>
        ///// PP小卷出库任务数据处理
        ///// </summary>
        ///// <param name="orderDetailId"></param>
        ///// <param name="stockSelectViews"></param>
        ///// <returns></returns>
        ///// <exception cref="Exception"></exception>
        //public (List<Dt_Task>, List<Dt_StockInfo>?, List<Dt_MesPPCutOutboundOrderDetail>?, List<Dt_OutStockLockInfo>?, List<Dt_LocationInfo>?) PPCutOutboundTaskDataHandle(int[] keys)
        //{
        //    List<Dt_Task> tasks = new List<Dt_Task>();
        //    List<Dt_MesPPCutOutboundOrderDetail> outboundOrderDetails = BaseDal.Db.Queryable<Dt_MesPPCutOutboundOrderDetail>().Where(x => keys.Contains(x.Id)).ToList();
        //    if (outboundOrderDetails == null || outboundOrderDetails.Count == 0)
        //    {
        //        throw new Exception("未找到出库单明细信息");
        //    }
        //    if (outboundOrderDetails.FirstOrDefault(x => x.OrderDetailStatus > OrderDetailStatusEnum.New.ObjToInt() && x.OrderDetailStatus != OrderDetailStatusEnum.AssignOverPartial.ObjToInt()) != null)
        //    {
        //        throw new Exception("所选出库单明细存在出库中或已完成");
        //    }
        //    List<Dt_StockInfo>? stockInfos = null;
        //    List<Dt_MesPPCutOutboundOrderDetail>? orderDetails = null;
        //    List<Dt_OutStockLockInfo>? outStockLockInfos = null;
        //    List<Dt_LocationInfo>? locationInfos = null;
        //    if (outboundOrderDetails.FirstOrDefault().OrderDetailStatus == OrderDetailStatusEnum.New.ObjToInt())
        //    {
        //        (List<Dt_StockInfo>, List<Dt_MesPPCutOutboundOrderDetail>, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) result = _outboundService.MesPPCutOutboundOrderDetailService.AssignStockOutbound(outboundOrderDetails);
        //        if (result.Item1 != null && result.Item1.Count > 0)
        //        {
        //            Dt_MesPPCutOutboundOrder outboundOrder = _outboundService.MesPPCutOutboundOrderService.Repository.QueryFirst(x => x.Id == outboundOrderDetails.FirstOrDefault().OrderId);
        //            //TaskTypeEnum typeEnum = outboundOrder.OrderType switch
        //            //{
        //            //    (int)OutOrderTypeEnum.Issue => TaskTypeEnum.Outbound,
        //            //    (int)OutOrderTypeEnum.Allocate => TaskTypeEnum.OutAllocate,
        //            //    (int)OutOrderTypeEnum.Quality => TaskTypeEnum.OutQuality,
        //            //    _ => new TaskTypeEnum()
        //            //};
        //            tasks = GetTasks(result.Item1, TaskTypeEnum.MesOutbound);
        //            result.Item2.ForEach(x =>
        //            {
        //                x.OrderDetailStatus = OrderDetailStatusEnum.Outbound.ObjToInt();
        //            });
        //            result.Item3.ForEach(x =>
        //            {
        //                x.Status = OutLockStockStatusEnum.出库中.ObjToInt();
        //            });

        //            stockInfos = result.Item1;
        //            orderDetails = result.Item2;
        //            outStockLockInfos = result.Item3;
        //            locationInfos = result.Item4;
        //        }
        //        else
        //        {
        //            throw new Exception("无库存");
        //        }
        //    }
        //    //else
        //    //{
        //    //    List<Dt_OutStockLockInfo> stockLockInfos = _outboundService.OutboundStockLockInfoService.GetByOrderDetailId(outboundOrderDetails.OrderId, OutLockStockStatusEnum.已分配);
        //    //    if (stockLockInfos != null && stockLockInfos.Count > 0)
        //    //    {
        //    //        List<Dt_StockInfo> stocks = _stockService.StockInfoService.Repository.GetStockInfosByPalletCodes(stockLockInfos.Select(x => x.PalletCode).Distinct().ToList());
        //    //        tasks = GetTasks(stocks);
        //    //    }
        //    //}

        //    return (tasks, stockInfos, orderDetails, outStockLockInfos, locationInfos);
        //}

        ///// <summary>
        ///// ç”ŸæˆPP小卷出库任务后数据更新到数据库
        ///// </summary>
        ///// <param name="tasks"></param>
        ///// <param name="stockInfos"></param>
        ///// <param name="outboundOrderDetails"></param>
        ///// <param name="outStockLockInfos"></param>
        ///// <param name="locationInfos"></param>
        ///// <returns></returns>
        //public WebResponseContent PPCutOutGenerateOutboundTaskDataUpdate(List<Dt_Task> tasks, List<Dt_StockInfo>? stockInfos = null, List<Dt_MesPPCutOutboundOrderDetail>? outboundOrderDetails = null, List<Dt_OutStockLockInfo>? outStockLockInfos = null, List<Dt_LocationInfo>? locationInfos = null)
        //{
        //    try
        //    {
        //        _unitOfWorkManage.BeginTran();

        //        BaseDal.AddData(tasks);
        //        if (stockInfos != null && stockInfos.Count > 0 && outboundOrderDetails != null && outboundOrderDetails.Count > 0 && outStockLockInfos != null && outStockLockInfos.Count > 0 && locationInfos != null && locationInfos.Count > 0)
        //        {
        //            stockInfos.ForEach(x =>
        //            {
        //                x.StockStatus = StockStatusEmun.出库锁定.ObjToInt();
        //            });
        //            WebResponseContent content = _outboundService.MesPPCutOutboundOrderDetailService.LockOutboundStockDataUpdate(stockInfos, outboundOrderDetails, outStockLockInfos, locationInfos, tasks: tasks);

        //            if (!content.Status)
        //            {
        //                _unitOfWorkManage.RollbackTran();
        //                return content;
        //            }
        //        }
        //        else if (outboundOrderDetails != null && outboundOrderDetails.Count > 0)
        //        {
        //            outboundOrderDetails.ForEach(x =>
        //            {
        //                x.OrderDetailStatus = OrderDetailStatusEnum.Outbound.ObjToInt();
        //            });

        //            _outboundService.MesPPCutOutboundOrderDetailService.Repository.UpdateData(outboundOrderDetails);
        //        }
        //        _unitOfWorkManage.CommitTran();
        //        PushTasksToWCS(tasks,"AGV_PP");
        //        return WebResponseContent.Instance.OK();
        //    }
        //    catch (Exception ex)
        //    {
        //        _unitOfWorkManage.RollbackTran();
        //        return WebResponseContent.Instance.Error(ex.Message);
        //    }
        //}
        #endregion
        /// <summary>
        /// ç”ŸæˆPP大卷出库任务后数据更新到数据库
        /// </summary>
        /// <param name="tasks"></param>
        /// <param name="stockInfos"></param>
        /// <param name="outboundOrderDetails"></param>
        /// <param name="outStockLockInfos"></param>
        /// <param name="locationInfos"></param>
        /// <returns></returns>
        public WebResponseContent MESPPGenerateOutboundTaskDataUpdate(List<Dt_Task> tasks, List<Dt_StockInfo>? stockInfos = null, List<Dt_MesPPOutboundOrderDetail>? outboundOrderDetails = null, List<Dt_OutStockLockInfo>? outStockLockInfos = null, List<Dt_LocationInfo>? locationInfos = null, Dt_MesPPOutboundOrder? mesPPOutboundOrder = null)
        {
            try
            {
                _unitOfWorkManage.BeginTran();

                BaseDal.AddData(tasks);
                if (stockInfos != null && stockInfos.Count > 0 && outboundOrderDetails != null && outboundOrderDetails.Count > 0 && outStockLockInfos != null && outStockLockInfos.Count > 0 && locationInfos != null && locationInfos.Count > 0)
                {
                    stockInfos.ForEach(x =>
                    {
                        x.StockStatus = StockStatusEmun.出库锁定.ObjToInt();
                    });
                    WebResponseContent content = _outboundService.MesPPOutboundOrderDetailService.LockOutboundStockDataUpdate(mesPPOutboundOrder, stockInfos, outboundOrderDetails, outStockLockInfos, locationInfos, tasks: tasks);

                    if (!content.Status)
                    {
@@ -1152,8 +1483,10 @@
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error(ex.Message);
            }

        }




    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService.cs

@@ -189,7 +189,7 @@
                {
                    CurrentAddress = stationCode,
                    Grade = 0,
                    NextAddress ="",
                    NextAddress = "",
                    PalletCode = palletCode,
                    Roadway = warehouse.Remark,//查询对应线边仓地址巷道号
                    SourceAddress = stationCode,
@@ -201,7 +201,7 @@
                };
                _unitOfWorkManage.BeginTran();
                BaseDal.AddData(newTask);
                PushTasksToWCS(new List<Dt_Task> { newTask});
                PushTasksToWCS(new List<Dt_Task> { newTask });
                _unitOfWorkManage.CommitTran();
                return WebResponseContent.Instance.OK();
            }
@@ -431,7 +431,7 @@
                List<Dt_OutStockLockInfo> outStockLockInfos = _outboundService.OutboundStockLockInfoService.Repository.QueryData(x => x.TaskNum == taskNum);
                List<Dt_OutboundOrderDetail> outboundOrderDetails = new List<Dt_OutboundOrderDetail>();
                List<Dt_MesOutboundOrder> mesOutboundOrders = new List<Dt_MesOutboundOrder>();

                List<Dt_MesPPOutboundOrder> mesPPOutboundOrders = new List<Dt_MesPPOutboundOrder>();
                if ((outStockLockInfos == null || outStockLockInfos.Count == 0) && warehouse.WarehouseCode != WarehouseEnum.HA64.ToString() && (task.TaskType != TaskTypeEnum.OutEmpty.ObjToInt()))
                {
                    return WebResponseContent.Instance.Error($"未找到出库详情信息");
@@ -451,6 +451,20 @@
                                    mesOutboundOrder.OrderStatus = OrderDetailStatusEnum.Over.ObjToInt();
                                }
                                mesOutboundOrders.Add(mesOutboundOrder);
                            }
                        }
                        //PP出库任务完成判断。。。。。。。。。。。。。。。。。
                        else if (task.TaskType == TaskTypeEnum.Outbound.ObjToInt() && warehouse.WarehouseCode == WarehouseEnum.HA58.ToString())
                        {
                            Dt_MesPPOutboundOrder mesPPOutboundOrder = _outboundService.MesPPOutboundOrderService.Repository.QueryFirst(x => x.OrderNo == item.OrderNo);
                            if (mesPPOutboundOrder != null)
                            {
                                mesPPOutboundOrder.OverOutQuantity = item.AssignQuantity;
                                if (mesPPOutboundOrder.OverOutQuantity == mesPPOutboundOrder.OrderQuantity)
                                {
                                    mesPPOutboundOrder.OrderStatus = OrderDetailStatusEnum.Over.ObjToInt();
                                }
                                mesPPOutboundOrders.Add(mesPPOutboundOrder);
                            }
                        }
                        else
@@ -506,6 +520,15 @@
                _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfo, (LocationStatusEnum)beforeStatus, LocationStatusEnum.Free, LocationChangeType.OutboundCompleted, stockInfo.Details.FirstOrDefault()?.OrderNo ?? "", task.TaskNum);
                _unitOfWorkManage.CommitTran();

                //PP出库任务完成判断。。。。。。。。。。。。。。。。。
                if (warehouse.WarehouseCode == WarehouseEnum.HA58.ToString() && task.TaskType == TaskTypeEnum.Outbound.ObjToInt())
                {
                    _outboundService.MesPPOutboundOrderService.Repository.UpdateData(mesPPOutboundOrders);
                    MesMaterialLotaAceptModel model = GetMesMaterialLotaAceptModel(stockInfo, stockInfo.Details.FirstOrDefault(), mesPPOutboundOrders.FirstOrDefault().TaskNo, warehouse.WarehouseCode, stockInfo.Details.Where(x => x.MaterielCode == mesPPOutboundOrders.FirstOrDefault().MaterialCode).Sum(x => x.StockQuantity));
                    UploadMesMaterialLotaAcept(model);
                    _stockService.StockInfoService.Repository.DeleteAndMoveIntoHty(stockInfo, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                    _stockService.StockInfoDetailService.Repository.DeleteAndMoveIntoHty(stockInfo.Details, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                }
                if (warehouse.WarehouseCode != WarehouseEnum.HA64.ToString() && task.TaskType == TaskTypeEnum.Outbound.ObjToInt())
                {
                    _outboundService.OutboundOrderService.TestOutUpload(outboundOrderDetails.FirstOrDefault().OrderId, outStockLockInfos);

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/MES/MesController.cs

@@ -12,6 +12,8 @@
using WIDESEA_DTO.ERP;
using WIDESEA_DTO.MES;
using WIDESEA_Core.Helper;
using Autofac.Core;
using WIDESEA_DTO.Stock;

namespace WIDESEA_WMSServer.Controllers.MES
{
@@ -169,5 +171,51 @@
        {
            return _taskService.BagInfoSync(model.Content);
        }
        /// <summary>
        /// ç”ŸæˆMESPP仓大卷出库任务
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("MESPPGenerateOutboundTasks"), AllowAnonymous]
        public WebResponseContent MESPPGenerateOutboundTasks([FromBody] int[] keys)
        {
            return _taskService.MESPPGenerateOutboundTasks(keys);
        }

        /// <summary>
        /// ç”ŸæˆMESPP仓小卷出库任务
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        //[HttpPost, HttpGet, Route("PPCutOutGenerateOutboundTasks"), AllowAnonymous]
        //public WebResponseContent PPCutOutGenerateOutboundTasks([FromBody] int[] keys)
        //{
        //    return _taskService.PPCutOutGenerateOutboundTasks(keys);
        //}

        /// <summary>
        /// ç”Ÿæˆå‡ºåº“任务
        /// </summary>
        /// <param name="orderDetailId"></param>
        /// <param name="stockSelectViews"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("PPCutOutGenerateOutboundTasks"), AllowAnonymous]
        public WebResponseContent PPCutOutGenerateOutboundTasks(int orderDetailId, [FromBody] List<PPStockSelectViewDTO> stockSelectViews)
        {
            return _taskService.PPCutOutGenerateOutboundTasks(orderDetailId, stockSelectViews);
        }

        /// <summary>
        /// PP平库直接出库
        /// </summary>
        /// <param name="orderDetailId"></param>
        /// <param name="stockSelectViews"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("PPGeneratePKOutboundTask"), AllowAnonymous]
        public WebResponseContent PPGeneratePKOutboundTask(int orderDetailId, [FromBody] List<PPStockSelectViewDTO> stockSelectViews)
        {
            return _taskService.PPGeneratePKOutboundTask(orderDetailId, stockSelectViews);
        }

    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/Outbound/MesPPOutboundOrderDetailController.cs

@@ -1,12 +1,19 @@
using Microsoft.AspNetCore.Mvc;
using Autofac.Core;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using WIDESEA_Core;
using WIDESEA_Core.BaseController;
using WIDESEA_DTO.Inbound;
using WIDESEA_DTO.MES;
using WIDESEA_DTO.Outbound;
using WIDESEA_IOutboundService;
using WIDESEA_Model.Models;

namespace WIDESEA_WMSServer.Controllers.Outbound
{
    /// <summary>
    /// MES出库单
    /// PP仓大卷MES出库单
    /// </summary>
    [Route("api/mesPPOutboundOrderDetail")]
    [ApiController]

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/Stock/StockInfoController.cs

@@ -47,6 +47,29 @@
        }

        /// <summary>
        /// æŸ¥è¯¢PP立库库存视图
        /// </summary>
        /// <param name="orderId"></param>
        /// <param name="materlCode"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("PPGetStockSelectViews")]
        public List<PPStockSelectViewDTO> PPGetStockSelectViews(int orderId, string materielCode)
        {
            return Service.PPGetStockSelectViews(orderId, materielCode);
        }

        /// <summary>
        /// æŸ¥è¯¢è®¢å•PP平库库存视图
        /// </summary>
        /// <param name="orderId"></param>
        /// <param name="materielCode"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("PPGetPKStockSelectViews")]
        public List<PPStockSelectViewDTO> PPGetPKStockSelectViews(int orderId, string materielCode)
        {
            return Service.PPGetPKStockSelectViews(orderId, materielCode);
        }
        /// <summary>
        /// æ ¹æ®æ‰˜ç›˜å’Œåº“区查询库存信息
        /// </summary>
        /// <param name="saveModel"></param>

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/TaskInfo/TaskController.cs

@@ -176,16 +176,16 @@
        {
            return Service.GenerateOutboundTasks(keys);
        }
        /// <summary>
        /// ç”ŸæˆMESPP仓大卷出库任务
        /// </summary>
        /// <param name="keys"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("MESPPGenerateOutboundTasks"), AllowAnonymous]
        public WebResponseContent MESPPGenerateOutboundTasks([FromBody] int[] keys)
        {
            return Service.MESPPGenerateOutboundTasks(keys);
        }
        ///// <summary>
        ///// ç”ŸæˆMESPP仓大卷出库任务
        ///// </summary>
        ///// <param name="keys"></param>
        ///// <returns></returns>
        //[HttpPost, HttpGet, Route("MESPPGenerateOutboundTasks"), AllowAnonymous]
        //public WebResponseContent MESPPGenerateOutboundTasks([FromBody] int[] keys)
        //{
        //    return Service.MESPPGenerateOutboundTasks(keys);
        //}
        /// <summary>
        /// å‡ºåº“任务完成
        /// </summary>

 ÏîÄ¿×ÊÁÏ/É豸ЭÒé/¸ÉĤ²Ö¶Ñ¶â»úͨÐÅЭÒé.xlsx

Binary files differ