Merge branch 'master' of http://115.159.85.185:8098/r/MeiRuiAn/HuaiAn

wangxinhui

2025-01-09 1c3c6a93bf2bb3af1aa13258640be333eef1e1c7

Merge branch 'master' of http://115.159.85.185:8098/r/MeiRuiAn/HuaiAn

# Conflicts:
#	代码管理/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MES/TestToolModel.cs

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/.vs/WIDESEAWCS_Server/FileContentIndex/bb8909d9-102a-4651-8147-b631fc4f6ca7.vsidx

Binary files differ

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

@@ -28,6 +28,7 @@
using System.Text;
using System.Threading.Tasks;
using WIDESEA_DTO.Agv;
using WIDESEAWCS_Common;
using WIDESEAWCS_Common.APIEnum;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
@@ -149,10 +150,14 @@
                List<Dt_WarehouseDevice> warehouseDevices = Db.Queryable<Dt_WarehouseDevice>().ToList();

                List<Dt_Task> tasks = new List<Dt_Task>();

                bool flag = false;

                foreach (var item in taskDTOs)
                {
                    if (BaseDal.QueryFirst(x => x.TaskNum == item.TaskNum || x.PalletCode == item.PalletCode) != null)
                    {
                        flag = true;
                        continue;
                    }
                    Dt_Task task = _mapper.Map<Dt_Task>(item);
@@ -259,7 +264,7 @@

                _taskExecuteDetailService.AddTaskExecuteDetail(tasks.Select(x => x.TaskNum).ToList(), "接收WMS任务");

                content = tasks.Count > 0 ? WebResponseContent.Instance.OK("成功") : WebResponseContent.Instance.Error("失败");
                content = (tasks.Count > 0 || flag) ? WebResponseContent.Instance.OK("成功") : WebResponseContent.Instance.Error("失败");
            }
            catch (Exception ex)
            {
@@ -312,7 +317,7 @@
        /// <returns></returns>
        public string? RequestAssignLocation(int taskNum, string roadwayNo)
        {
            string responseStr = HttpHelper.Get($"http://127.0.0.1:9283/api/Task/AssignInboundTaskLocation?taskNum={taskNum}&roadwayNo={roadwayNo}");
            string responseStr = HttpHelper.Get($"http://127.0.0.1:9293/api/Task/AssignInboundTaskLocation?taskNum={taskNum}&roadwayNo={roadwayNo}");

            WebResponseContent? responseContent = JsonConvert.DeserializeObject<WebResponseContent>(responseStr);
            if (responseContent != null && responseContent.Status && responseContent.Data != null)

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/¸ÉĤ²Ö/ConveyorLineJob_GM.cs

@@ -74,21 +74,46 @@
                                    WebResponseContent content = _taskService.RequestWMSTask(conveyorLineInfoRead.Barcode, item.StationCode);
                                    if (content.Status)
                                    {
                                        device.SetValue(W_ConveyorLineDB.ACK, true);
                                        device.SetValue(W_ConveyorLineDB.ACK, true, item.StationCode);
                                    }
                                }
                            }
                            else if (!conveyorLineSignalRead.STB && conveyorLineStatus.Online && conveyorLineStatus.Goods && !conveyorLineStatus.Alarm && conveyorLineSignalWrite.ACK)
                            {
                                device.SetValue(W_ConveyorLineDB.ACK, false);
                                Dt_Task task = _taskRepository.QueryFirst(x => x.CurrentAddress == item.StationCode && x.PalletCode == conveyorLineInfoRead.Barcode && x.DeviceCode == item.StationDeviceCode);
                                if (task != null)
                                {
                                    task.CurrentAddress = item.StackerCraneStationCode;
                                    task.TaskState = TaskStatusEnum.SC_Execute.ObjToInt();
                                    task.DeviceCode = item.StackerCraneCode;
                                    _taskRepository.UpdateData(task);
                                }

                                device.SetValue(W_ConveyorLineDB.ACK, false, item.StationCode);
                            }

                        }
                        else if (item.StationType == StationTypeEnum.StationType_InboundAndOutbound.ObjToInt())
                        {
                            if(!conveyorLineSignalRead.STB && !conveyorLineSignalRead.ACK && conveyorLineStatus.Online && !conveyorLineStatus.Goods && !conveyorLineStatus.Alarm && !conveyorLineSignalWrite.STB && !conveyorLineSignalWrite.ACK)
                            {
                                Dt_Task task = _taskRepository.QueryFirst(x => _taskService.TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == TaskStatusEnum.New.ObjToInt() && string.IsNullOrEmpty(x.TargetAddress) && string.IsNullOrEmpty(x.NextAddress));
                                if(task != null)
                                {
                                    string oldAddress = task.NextAddress;
                                    int oldStatus = task.TaskState;
                                    task.NextAddress = item.StationCode;
                                    task.DeviceCode = item.StackerCraneCode;
                                    task.TaskState = TaskStatusEnum.SC_Execute.ObjToInt();
                                    task.TargetAddress = item.StationCode;
                                    _taskRepository.UpdateData(task);
                                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskNum, $"系统自动流程,目标地址由{oldAddress}变更为{task.NextAddress},任务状态由{oldStatus}变更为{task.TaskState}");
                                }
                            }

                            if (conveyorLineSignalRead.STB && conveyorLineStatus.Online && conveyorLineStatus.Goods && !conveyorLineStatus.Alarm && !conveyorLineSignalWrite.ACK)//入库
                            {
                                Dt_Task task = _taskRepository.QueryFirst(x => x.NextAddress == item.StackerCraneCode);
                                Dt_Task task = _taskRepository.QueryFirst(x => x.TaskNum == conveyorLineInfoRead.TaskNum && x.NextAddress == item.StationCode);
                                if (task != null && task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)
                                {
                                    Dt_StationManger? stationManger = stationMangers.FirstOrDefault(x => x.StationCode == item.StationCode);
@@ -114,19 +139,19 @@

                                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskNum, $"系统自动流程,目标地址由{oldAddress}变更为{task.NextAddress},任务状态由{oldStatus}变更为{task.TaskState}");

                                    device.SetValue(W_ConveyorLineDB.Spare1, ConveyorWorkTypeEnum.Inbound.ObjToInt());
                                    device.SetValue(W_ConveyorLineDB.ACK, true);
                                    device.SetValue(W_ConveyorLineDB.Spare1, ConveyorWorkTypeEnum.Inbound.ObjToInt(), item.StationCode);
                                    device.SetValue(W_ConveyorLineDB.ACK, true, item.StationCode);
                                }
                            }
                            else if (!conveyorLineSignalRead.STB && conveyorLineStatus.Online && conveyorLineStatus.Goods && !conveyorLineStatus.Alarm && conveyorLineSignalWrite.ACK)
                            {
                                device.SetValue(W_ConveyorLineDB.ACK, false);
                                device.SetValue(W_ConveyorLineDB.ACK, false, item.StationCode);
                            }
                            else
                            {
                                if (!conveyorLineSignalWrite.STB && !conveyorLineSignalRead.ACK && conveyorLineStatus.Goods)
                                {
                                    Dt_Task task = _taskRepository.QueryFirst(x => x.CurrentAddress == item.StationCode && x.TaskState == TaskStatusEnum.Line_Execute.ObjToInt());
                                    Dt_Task task = _taskRepository.QueryFirst(x => x.CurrentAddress == item.StationCode && x.TaskState == TaskStatusEnum.Line_Execute.ObjToInt() && x.DeviceCode == item.StationDeviceCode);
                                    if (task != null && task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                                    {
                                        Dt_StationManger? stationManger = stationMangers.FirstOrDefault(x => x.StationCode == item.StationCode);
@@ -152,17 +177,17 @@

                                        _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskNum, $"系统自动流程,目标地址由{oldAddress}变更为{task.NextAddress},任务状态由{oldStatus}变更为{task.TaskState}");

                                        device.SetValue(W_ConveyorLineDB.TaskNum, task.TaskNum);
                                        device.SetValue(W_ConveyorLineDB.EndPos, task.NextAddress);
                                        device.SetValue(W_ConveyorLineDB.StartPos, task.CurrentAddress);
                                        device.SetValue(W_ConveyorLineDB.Spare1, ConveyorWorkTypeEnum.Outbound.ObjToInt());
                                        device.SetValue(W_ConveyorLineDB.STB, true);
                                        device.SetValue(W_ConveyorLineDB.TaskNum, task.TaskNum, item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.EndPos, task.NextAddress, item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.StartPos, task.CurrentAddress, item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.Spare1, ConveyorWorkTypeEnum.Outbound.ObjToInt(), item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.STB, true, item.StationCode);
                                    }
                                }
                                else if (conveyorLineSignalWrite.STB && conveyorLineSignalRead.ACK && conveyorLineStatus.Goods)
                                {
                                    _taskService.TaskCompleted(conveyorLineInfoRead.TaskNum);
                                    device.SetValue(W_ConveyorLineDB.STB, false);
                                    device.SetValue(W_ConveyorLineDB.STB, false, item.StationCode);
                                }
                            }
                        }
@@ -185,19 +210,20 @@

                                        _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskNum, $"系统自动流程,目标地址由{oldAddress}变更为{task.NextAddress},任务状态由{oldStatus}变更为{task.TaskState}");

                                        device.SetValue(W_ConveyorLineDB.TaskNum, task.TaskNum);
                                        device.SetValue(W_ConveyorLineDB.Spare1, ConveyorWorkTypeEnum.Inbound.ObjToInt());
                                        device.SetValue(W_ConveyorLineDB.STB, true);
                                        device.SetValue(W_ConveyorLineDB.TaskNum, task.TaskNum, item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.EndPos, task.NextAddress, item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.Spare1, ConveyorWorkTypeEnum.Inbound.ObjToInt(), item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.STB, true, item.StationCode);
                                    }
                                }
                            }
                            else if (conveyorLineSignalWrite.STB && conveyorLineSignalRead.ACK && !conveyorLineStatus.Alarm)
                            {
                                device.SetValue(W_ConveyorLineDB.STB, false);
                                device.SetValue(W_ConveyorLineDB.STB, false, item.StationCode);
                            }
                            else if (!conveyorLineSignalRead.STB && conveyorLineSignalWrite.ACK && !conveyorLineStatus.Alarm)
                            {
                                device.SetValue(W_ConveyorLineDB.ACK, false);
                                device.SetValue(W_ConveyorLineDB.ACK, false, item.StationCode);
                            }
                        }
                    }

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/¸ÉĤ²Ö/StackerCraneJob_GM.cs

@@ -24,6 +24,8 @@
using WIDESEAWCS_Tasks.HoisterJob;
using WIDESEAWCS_Tasks.StackerCraneJob;
using WIDESEAWCS_Core.Caches;
using WIDESEAWCS_Tasks.ConveyorLineJob;
using WIDESEAWCS_QuartzJob.Repository;

namespace WIDESEAWCS_Tasks
{
@@ -36,9 +38,10 @@
        private readonly ITaskRepository _taskRepository;
        private readonly IRouterService _routerService;
        private readonly IStationMangerRepository _stationMangerRepository;
        private readonly IRouterRepository _routerRepository;
        private List<Dt_ApiInfo> apiInfos;

        public StackerCraneJob_GM(ITaskService taskService, ICacheService cacheService, ITaskExecuteDetailService taskExecuteDetailService, ITaskRepository taskRepository, IRouterService routerService, IStationMangerRepository stationMangerRepository)
        public StackerCraneJob_GM(ITaskService taskService, ICacheService cacheService, ITaskExecuteDetailService taskExecuteDetailService, ITaskRepository taskRepository, IRouterService routerService, IStationMangerRepository stationMangerRepository, IRouterRepository routerRepository)
        {
            _taskService = taskService;
            _taskExecuteDetailService = taskExecuteDetailService;
@@ -46,6 +49,7 @@
            _routerService = routerService;
            _stationMangerRepository = stationMangerRepository;
            _cacheService = cacheService;
            _routerRepository = routerRepository;

            string? apiInfoStr = _cacheService.Get("apiInfos");
            if (!string.IsNullOrEmpty(apiInfoStr))
@@ -92,6 +96,8 @@
                                    task.ExceptionMessage = "";
                                    _taskRepository.UpdateData(task);
                                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"系统自动流程，任务状态从【{oldState}】转到【{task.TaskState}】");

                                    commonStackerCrane.Communicator.Write("DB105.54", (short)1);
                                }
                            }
                        }
@@ -135,17 +141,18 @@
                        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}");
                            _taskExecuteDetailService.AddTaskExecuteDetail(taskNum, $"输送线出库站点未配置,{task.NextAddress}");
                            _taskService.UpdateTaskExceptionMessage(taskNum, $"输送线出库站点未配置,{task.NextAddress}");
                            return WebResponseContent.Instance.Error($"输送线出库站点未配置,{task.NextAddress}");
                        }

                        int oldStatus = task.TaskState;
                        task.DeviceCode = "AGV_CSJ";
                        task.TaskState = TaskStatusEnum.AGV_Execute.ObjToInt();
                        task.CurrentAddress = stationManger.AGVStationCode;
                        task.NextAddress = task.TargetAddress;
                        task.DeviceCode = "CL01_GM";
                        task.TaskState = TaskStatusEnum.Line_Execute.ObjToInt();
                        task.CurrentAddress = stationManger.StationCode;
                        _taskRepository.UpdateData(task);
                        _taskExecuteDetailService.AddTaskExecuteDetail(taskNum, $"系统自动流程,，任务状态从【{oldStatus}】转到【{task.TaskState}】");
                        //todo å®Œæˆ
                    }
                    else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup || task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)
                    {
@@ -257,11 +264,10 @@
                if (device != null)
                {
                    OtherDevice client = (OtherDevice)device;
                    if (client.GetValue<GroundStationDBName, bool>(GroundStationDBName.R_IsCanPut, stationManger.StationCode))//出库站台未被占用
                    if (!client.GetValue<R_ConveyorLineDB, bool>(R_ConveyorLineDB.Goods, stationManger.StationCode))//出库站台未被占用
                    {
                        task.NextAddress = stationManger.StackerCraneStationCode;
                        _taskRepository.UpdateData(task);
                        client.SetValue(GroundStationDBName.R_IsCanPut, true, stationManger.StationCode);
                        return task;
                    }
                }

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/°å²Ä²Ö/ConveyorLineJob_BC.cs

@@ -74,20 +74,46 @@
                                    WebResponseContent content = _taskService.RequestWMSTask(conveyorLineInfoRead.Barcode, item.StationCode);
                                    if (content.Status)
                                    {
                                        device.SetValue(W_ConveyorLineDB.ACK, true);
                                        device.SetValue(W_ConveyorLineDB.ACK, true, item.StationCode);
                                    }
                                }
                            }
                            else if (!conveyorLineSignalRead.STB && conveyorLineStatus.Online && conveyorLineStatus.Goods && !conveyorLineStatus.Alarm && conveyorLineSignalWrite.ACK)
                            {
                                device.SetValue(W_ConveyorLineDB.ACK, false);
                                Dt_Task task = _taskRepository.QueryFirst(x => x.CurrentAddress == item.StationCode && x.PalletCode == conveyorLineInfoRead.Barcode && x.DeviceCode == item.StationDeviceCode);
                                if (task != null)
                                {
                                    task.CurrentAddress = item.StackerCraneStationCode;
                                    task.TaskState = TaskStatusEnum.SC_Execute.ObjToInt();
                                    task.DeviceCode = item.StackerCraneCode;
                                    _taskRepository.UpdateData(task);
                                }

                                device.SetValue(W_ConveyorLineDB.ACK, false, item.StationCode);
                            }

                        }
                        else if (item.StationType == StationTypeEnum.StationType_InboundAndOutbound.ObjToInt())
                        {
                            if (!conveyorLineSignalRead.STB && !conveyorLineSignalRead.ACK && conveyorLineStatus.Online && !conveyorLineStatus.Goods && !conveyorLineStatus.Alarm && !conveyorLineSignalWrite.STB && !conveyorLineSignalWrite.ACK)
                            {
                                Dt_Task task = _taskRepository.QueryFirst(x => _taskService.TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == TaskStatusEnum.New.ObjToInt() && string.IsNullOrEmpty(x.TargetAddress) && string.IsNullOrEmpty(x.NextAddress));
                                if (task != null)
                                {
                                    string oldAddress = task.NextAddress;
                                    int oldStatus = task.TaskState;
                                    task.NextAddress = item.StationCode;
                                    task.DeviceCode = item.StackerCraneCode;
                                    task.TaskState = TaskStatusEnum.SC_Execute.ObjToInt();
                                    task.TargetAddress = item.StationCode;
                                    _taskRepository.UpdateData(task);
                                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskNum, $"系统自动流程,目标地址由{oldAddress}变更为{task.NextAddress},任务状态由{oldStatus}变更为{task.TaskState}");
                                }
                            }

                            if (conveyorLineSignalRead.STB && conveyorLineStatus.Online && conveyorLineStatus.Goods && !conveyorLineStatus.Alarm && !conveyorLineSignalWrite.ACK)//入库
                            {
                                Dt_Task task = _taskRepository.QueryFirst(x => x.NextAddress == item.StackerCraneCode);
                                Dt_Task task = _taskRepository.QueryFirst(x => x.TaskNum == conveyorLineInfoRead.TaskNum && x.NextAddress == item.StationCode);
                                if (task != null && task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)
                                {
                                    Dt_StationManger? stationManger = stationMangers.FirstOrDefault(x => x.StationCode == item.StationCode);
@@ -113,19 +139,19 @@

                                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskNum, $"系统自动流程,目标地址由{oldAddress}变更为{task.NextAddress},任务状态由{oldStatus}变更为{task.TaskState}");

                                    device.SetValue(W_ConveyorLineDB.Spare1, ConveyorWorkTypeEnum.Inbound.ObjToInt());
                                    device.SetValue(W_ConveyorLineDB.ACK, true);
                                    device.SetValue(W_ConveyorLineDB.Spare1, ConveyorWorkTypeEnum.Inbound.ObjToInt(), item.StationCode);
                                    device.SetValue(W_ConveyorLineDB.ACK, true, item.StationCode);
                                }
                            }
                            else if (!conveyorLineSignalRead.STB && conveyorLineStatus.Online && conveyorLineStatus.Goods && !conveyorLineStatus.Alarm && conveyorLineSignalWrite.ACK)
                            {
                                device.SetValue(W_ConveyorLineDB.ACK, false);
                                device.SetValue(W_ConveyorLineDB.ACK, false, item.StationCode);
                            }
                            else
                            {
                                if (!conveyorLineSignalWrite.STB && !conveyorLineSignalRead.ACK && conveyorLineStatus.Goods)
                                {
                                    Dt_Task task = _taskRepository.QueryFirst(x => x.CurrentAddress == item.StationCode && x.TaskState == TaskStatusEnum.Line_Execute.ObjToInt());
                                    Dt_Task task = _taskRepository.QueryFirst(x => x.CurrentAddress == item.StationCode && x.TaskState == TaskStatusEnum.Line_Execute.ObjToInt() && x.DeviceCode == item.StationDeviceCode);
                                    if (task != null && task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                                    {
                                        Dt_StationManger? stationManger = stationMangers.FirstOrDefault(x => x.StationCode == item.StationCode);
@@ -151,17 +177,17 @@

                                        _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskNum, $"系统自动流程,目标地址由{oldAddress}变更为{task.NextAddress},任务状态由{oldStatus}变更为{task.TaskState}");

                                        device.SetValue(W_ConveyorLineDB.TaskNum, task.TaskNum);
                                        device.SetValue(W_ConveyorLineDB.EndPos, task.NextAddress);
                                        device.SetValue(W_ConveyorLineDB.StartPos, task.CurrentAddress);
                                        device.SetValue(W_ConveyorLineDB.Spare1, ConveyorWorkTypeEnum.Outbound.ObjToInt());
                                        device.SetValue(W_ConveyorLineDB.STB, true);
                                        device.SetValue(W_ConveyorLineDB.TaskNum, task.TaskNum, item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.EndPos, task.NextAddress, item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.StartPos, task.CurrentAddress, item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.Spare1, ConveyorWorkTypeEnum.Outbound.ObjToInt(), item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.STB, true, item.StationCode);
                                    }
                                }
                                else if (conveyorLineSignalWrite.STB && conveyorLineSignalRead.ACK && conveyorLineStatus.Goods)
                                {
                                    _taskService.TaskCompleted(conveyorLineInfoRead.TaskNum);
                                    device.SetValue(W_ConveyorLineDB.STB, false);
                                    device.SetValue(W_ConveyorLineDB.STB, false, item.StationCode);
                                }
                            }
                        }
@@ -169,21 +195,35 @@
                        {
                            if (!conveyorLineSignalWrite.STB && !conveyorLineSignalWrite.ACK && !conveyorLineSignalRead.STB && !conveyorLineSignalRead.ACK && conveyorLineStatus.Goods && !conveyorLineStatus.Alarm)
                            {
                                Dt_Task task = _taskRepository.QueryFirst(x => x.TaskState == TaskStatusEnum.New.ObjToInt() && string.IsNullOrEmpty(x.TargetAddress) && x.SourceAddress == item.StationCode && _taskService.TaskInboundTypes.Contains(x.TaskType));
                                if (task != null)
                                Dt_Task outTask = _taskRepository.QueryFirst(x => _taskService.TaskOutboundTypes.Contains(x.TaskType) && x.TaskState != TaskStatusEnum.New.ObjToInt() && x.TaskState != TaskStatusEnum.SC_Execute.ObjToInt() && x.TargetAddress == item.StationCode);
                                if (outTask == null)
                                {
                                    //todo è¾“送线工作模式需要判断
                                    device.SetValue(W_ConveyorLineDB.Spare1, ConveyorWorkTypeEnum.Inbound.ObjToInt());
                                    device.SetValue(W_ConveyorLineDB.STB, true);
                                    Dt_Task task = _taskRepository.QueryFirst(x => x.TaskState == TaskStatusEnum.New.ObjToInt() && string.IsNullOrEmpty(x.TargetAddress) && x.SourceAddress == item.StationCode && _taskService.TaskInboundTypes.Contains(x.TaskType));
                                    if (task != null)
                                    {
                                        //todo è¾“送线工作模式需要判断

                                        string oldAddress = task.NextAddress;
                                        int oldStatus = task.TaskState;
                                        task.TaskState = TaskStatusEnum.Line_Execute.ObjToInt();
                                        _taskRepository.UpdateData(task);

                                        _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskNum, $"系统自动流程,目标地址由{oldAddress}变更为{task.NextAddress},任务状态由{oldStatus}变更为{task.TaskState}");

                                        device.SetValue(W_ConveyorLineDB.TaskNum, task.TaskNum, item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.EndPos, task.NextAddress, item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.Spare1, ConveyorWorkTypeEnum.Inbound.ObjToInt(), item.StationCode);
                                        device.SetValue(W_ConveyorLineDB.STB, true, item.StationCode);
                                    }
                                }
                            }
                            else if (conveyorLineSignalWrite.STB && conveyorLineSignalRead.ACK && !conveyorLineStatus.Alarm)
                            {
                                device.SetValue(W_ConveyorLineDB.STB, false);
                                device.SetValue(W_ConveyorLineDB.STB, false, item.StationCode);
                            }
                            else if (!conveyorLineSignalRead.STB && conveyorLineSignalWrite.ACK && !conveyorLineStatus.Alarm)
                            {
                                device.SetValue(W_ConveyorLineDB.ACK, false);
                                device.SetValue(W_ConveyorLineDB.ACK, false, item.StationCode);
                            }
                        }
                    }
@@ -195,11 +235,6 @@
            }

            return Task.CompletedTask;
        }

        public void OnlyInboundStationFunc()
        {

        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/8ec93a91-d59a-425d-8fc0-681c90b68b09.vsidx

Binary files differ

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

@@ -25,11 +25,14 @@
        /// </summary>
        public IWarehouseRepository WarehouseRepository { get; }

        public BasicRepository(ILocationInfoRepository locationInfoRepository, IMaterielInfoRepository materielInfoRepository, IWarehouseRepository warehouseRepository)
        public IPalletTypeInfoRepository PalletTypeInfoRepository { get; }

        public BasicRepository(ILocationInfoRepository locationInfoRepository, IMaterielInfoRepository materielInfoRepository, IWarehouseRepository warehouseRepository, IPalletTypeInfoRepository palletTypeInfoRepository)
        {
            LocationInfoRepository = locationInfoRepository;
            MaterielInfoRepository = materielInfoRepository;
            WarehouseRepository = warehouseRepository;
            PalletTypeInfoRepository = palletTypeInfoRepository;
        }
    }
}

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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,18 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.BaseRepository;
using WIDESEA_IBasicRepository;
using WIDESEA_Model.Models;

namespace WIDESEA_BasicRepository
{
    public class PalletTypeInfoRepository : RepositoryBase<Dt_PalletTypeInfo>, IPalletTypeInfoRepository
    {
        public PalletTypeInfoRepository(IUnitOfWorkManage unitOfWorkManage) : base(unitOfWorkManage)
        {
        }
    }
}

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

@@ -29,7 +29,7 @@
        /// æ‰˜ç›˜ç±»åž‹
        /// </param>
        /// <returns></returns>
        public Dt_LocationInfo? AssignLocation_BC(string roadwayNo, PalletTypeEnum palletType, string beRelocationCode = "")
        public Dt_LocationInfo? AssignLocation_BC(string roadwayNo, int palletType, Dt_PalletTypeInfo palletTypeInfo, string beRelocationCode = "")
        {
            lock (_locker_BC)
            {
@@ -77,14 +77,17 @@

                if ((locationInfos.Count * weightValue_BC >= definedTypeLocations.Count && undefinedTypeEmptyLocations.Any()) || !definedTypeEmptyLocations.Any())//如果已定义类型货位未超过比例，且有未定义类型的货位
                {
                    if (palletType == PalletTypeEnum.LargePallet || palletType == PalletTypeEnum.LargestPallet)
                    if (palletTypeInfo.LocaitonCount == 2)
                    {
                        undefinedTypeEmptyLocations = undefinedTypeEmptyLocations.Where(x => x.Column % 2 == 1).ToList();
                        if (palletTypeInfo.IsOdd)
                            undefinedTypeEmptyLocations = undefinedTypeEmptyLocations.Where(x => x.Column % 2 == 1).ToList();
                        else
                            undefinedTypeEmptyLocations = undefinedTypeEmptyLocations.Where(x => x.Column % 2 == 0).ToList();
                    }
                    for (int i = 0; i < undefinedTypeEmptyLocations.Count; i++)
                    {
                        Dt_LocationInfo undefinedTypeEmptyLocation = undefinedTypeEmptyLocations[i];
                        Dt_LocationInfo? locationInfo = GetUsableLocation_BC(locationInfos, undefinedTypeEmptyLocation, palletType);
                        Dt_LocationInfo? locationInfo = GetUsableLocation_BC(locationInfos, undefinedTypeEmptyLocation, palletType, palletTypeInfo);
                        if (locationInfo != null)
                        {
                            locationCaches_BC.Add(new LocationCache { LocationCode = locationInfo.LocationCode, DateTime = DateTime.Now });
@@ -97,7 +100,7 @@
                    for (int i = 0; i < definedTypeEmptyLocations.Count; i++)
                    {
                        Dt_LocationInfo definedTypeEmptyLocation = definedTypeEmptyLocations[i];
                        Dt_LocationInfo? locationInfo = GetUsableLocation_BC(locationInfos, definedTypeEmptyLocation, palletType);
                        Dt_LocationInfo? locationInfo = GetUsableLocation_BC(locationInfos, definedTypeEmptyLocation, palletType, palletTypeInfo);
                        if (locationInfo != null)
                        {
                            locationCaches_BC.Add(new LocationCache { LocationCode = locationInfo.LocationCode, DateTime = DateTime.Now });
@@ -116,22 +119,32 @@
        /// <param name="emptyLocation"></param>
        /// <param name="palletType"></param>
        /// <returns></returns>
        private Dt_LocationInfo? GetUsableLocation_BC(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, PalletTypeEnum palletType)
        private Dt_LocationInfo? GetUsableLocation_BC(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, int palletType, Dt_PalletTypeInfo palletTypeInfo)
        {
            switch (palletType)

            if (palletTypeInfo.LocaitonCount == 2)
            {
                case PalletTypeEnum.LargestPallet:
                case PalletTypeEnum.LargePallet:
                    if (emptyLocation.Column % 2 == 0)
                if (palletTypeInfo.IsOdd && emptyLocation.Column % 2 != 1 || !palletTypeInfo.IsOdd && emptyLocation.Column % 2 != 0)
                    return null;

                Dt_LocationInfo? nearLocation = locationInfos.FirstOrDefault(x => x.Row == emptyLocation.Row && x.Layer == emptyLocation.Layer && x.Depth == emptyLocation.Depth && x.Column == emptyLocation.Column + 1);
                if (nearLocation != null && DepthLocationIsEmpty_BC(locationInfos, nearLocation) != null)
                {
                    Dt_LocationInfo? locationInfo = DepthLocationIsEmpty_BC(locationInfos, emptyLocation);
                    if (locationInfo != null)
                    {
                        return null;
                        return locationInfo;
                    }
                    break;
                }
            }
            Dt_LocationInfo? locationInfo = DepthLocationIsEmpty_BC(locationInfos, emptyLocation, palletType);
            if (locationInfo != null)

            else
            {
                return locationInfo;
                Dt_LocationInfo? locationInfo = DepthLocationIsEmpty_BC(locationInfos, emptyLocation);
                if (locationInfo != null)
                {
                    return locationInfo;
                }
            }
            return null;
        }
@@ -142,24 +155,18 @@
        /// <param name="locationInfos"></param>
        /// <param name="emptyLocation"></param>
        /// <returns></returns>
        private Dt_LocationInfo? DepthLocationIsEmpty_BC(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, PalletTypeEnum palletType)
        private Dt_LocationInfo? DepthLocationIsEmpty_BC(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation)
        {
            List<Dt_LocationInfo> locations = GetGroupLocations(locationInfos, emptyLocation);

            bool moreDepthFlag = false;
            bool littleDepthFlag = false;

            switch (palletType)
            {
                case PalletTypeEnum.LargestPallet:
                case PalletTypeEnum.LargePallet:
                    List<Dt_LocationInfo> moreDepth = locations.Where(x => x.Depth > emptyLocation.Depth).ToList();
                    moreDepthFlag = moreDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.InStock.ObjToInt() && x.LocationStatus != LocationStatusEnum.PalletLock.ObjToInt()) == null;//查询大于当前货位深度的集合里是否有状态不为有货的货位，如果是true，则表示深货位有未被使用的情况
            List<Dt_LocationInfo> moreDepth = locations.Where(x => x.Depth > emptyLocation.Depth).ToList();
            moreDepthFlag = moreDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.InStock.ObjToInt() && (x.EnableStatus == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatus == EnableStatusEnum.Normal.ObjToInt())) == null;//查询大于当前货位深度的集合里是否有状态不为有货的货位，如果是true，则表示深货位有未被使用的情况

                    List<Dt_LocationInfo> littleDepth = locations.Where(x => x.Depth <= emptyLocation.Depth).ToList();
                    littleDepthFlag = littleDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.Free.ObjToInt() && x.EnableStatus != EnableStatusEnum.OnlyIn.ObjToInt() && x.EnableStatus != EnableStatusEnum.Normal.ObjToInt()) == null; //查询小于当前货位深度的集合里是否有状态不为空，且禁用状态不为禁用以及只入的货位，如果是true，则表示浅货位被使用或者被禁用的情况
                    break;
            }
            List<Dt_LocationInfo> littleDepth = locations.Where(x => x.Depth <= emptyLocation.Depth).ToList();
            littleDepthFlag = littleDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.Free.ObjToInt() && (x.EnableStatus == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatus == EnableStatusEnum.Normal.ObjToInt())) == null; //查询小于当前货位深度的集合里是否有状态不为空，且禁用状态不为禁用以及只入的货位，如果是true，则表示浅货位被使用或者被禁用的情况

            if (moreDepthFlag && littleDepthFlag)
            {

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

@@ -43,7 +43,7 @@
        /// 4：特长 
        /// </param>
        /// <returns></returns>
        public Dt_LocationInfo? AssignLocation_CSJ(string roadwayNo, PalletTypeEnum palletType, string beRelocationCode = "")
        public Dt_LocationInfo? AssignLocation_CSJ(string roadwayNo, int palletType, Dt_PalletTypeInfo palletTypeInfo, string beRelocationCode = "")
        {
            lock (_locker_CSJ)
            {
@@ -91,7 +91,7 @@

                if ((locationInfos.Count * weightValue_CSJ >= definedTypeLocations.Count && undefinedTypeEmptyLocations.Any()) || !definedTypeEmptyLocations.Any())//如果已定义类型货位未超过比例，且有未定义类型的货位
                {
                    if (palletType == PalletTypeEnum.LargePallet || palletType == PalletTypeEnum.LargestPallet)
                    if (palletType == 3 || palletType == 4)
                    {
                        undefinedTypeEmptyLocations = undefinedTypeEmptyLocations.Where(x => x.Depth % 2 == 1).ToList();
                    }
@@ -130,12 +130,12 @@
        /// <param name="emptyLocation"></param>
        /// <param name="palletType"></param>
        /// <returns></returns>
        private Dt_LocationInfo? GetUsableLocation_CSJ(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, PalletTypeEnum palletType)
        private Dt_LocationInfo? GetUsableLocation_CSJ(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, int palletType)
        {
            switch (palletType)
            {
                case PalletTypeEnum.LargestPallet:
                case PalletTypeEnum.LargePallet:
                case 3:
                case 4:
                    if (emptyLocation.Depth % 2 == 0)
                    {
                        return null;
@@ -150,20 +150,20 @@
            return null;
        }

        private bool LittleDepthLocationIsEmpty_CSJ(Dt_LocationInfo locationInfo, PalletTypeEnum palletType)
        private bool LittleDepthLocationIsEmpty_CSJ(Dt_LocationInfo locationInfo, int palletType)
        {
            List<Dt_LocationInfo> locations = GetGroupLocations(locationInfo);

            switch (palletType)
            {
                case PalletTypeEnum.LargestPallet:
                case PalletTypeEnum.LargePallet:
                case 4:
                case 3:
                    {
                        List<Dt_LocationInfo> littleDepth = locations.Where(x => x.Depth <= locationInfo.Depth).ToList();
                        return littleDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.Free.ObjToInt() && x.EnableStatus != EnableStatusEnum.OnlyIn.ObjToInt() && x.EnableStatus != EnableStatusEnum.Normal.ObjToInt()) == null; //查询小于当前货位深度的集合里是否有状态不为空，且禁用状态不为禁用以及只入的货位，如果是true，则表示浅货位被使用或者被禁用的情况
                    }
                case PalletTypeEnum.MediumPallet:
                case PalletTypeEnum.SmallPallet:
                case 1:
                case 2:
                    {
                        List<Dt_LocationInfo> littleDepth = locations.Where(x => x.Depth <= locationInfo.Depth).ToList();
                        return littleDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.Free.ObjToInt() && x.EnableStatus != EnableStatusEnum.OnlyIn.ObjToInt() && x.EnableStatus != EnableStatusEnum.Normal.ObjToInt()) == null; //查询小于当前货位深度的集合里是否有状态不为空，且禁用状态不为禁用以及只入的货位，如果是true，则表示浅货位被使用或者被禁用的情况
@@ -178,7 +178,7 @@
        /// <param name="locationInfos"></param>
        /// <param name="emptyLocation"></param>
        /// <returns></returns>
        private Dt_LocationInfo? DepthLocationIsEmpty_CSJ(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, PalletTypeEnum palletType)
        private Dt_LocationInfo? DepthLocationIsEmpty_CSJ(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, int palletType)
        {
            List<Dt_LocationInfo> locations = GetGroupLocations(locationInfos, emptyLocation);

@@ -187,8 +187,8 @@

            switch (palletType)
            {
                case PalletTypeEnum.LargestPallet:
                case PalletTypeEnum.LargePallet:
                case 3:
                case 4:
                    {
                        List<Dt_LocationInfo> moreDepth = locations.Where(x => x.Depth > emptyLocation.Depth).ToList();
                        moreDepthFlag = moreDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.InStock.ObjToInt() && x.LocationStatus != LocationStatusEnum.PalletLock.ObjToInt() && (x.EnableStatus == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatus == EnableStatusEnum.Normal.ObjToInt())) == null;//查询大于当前货位深度的集合里是否有状态不为有货的货位，如果是true，则表示深货位有未被使用的情况
@@ -197,8 +197,8 @@
                        littleDepthFlag = littleDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.Free.ObjToInt() && (x.EnableStatus == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatus == EnableStatusEnum.Normal.ObjToInt())) == null; //查询小于当前货位深度的集合里是否有状态不为空，且禁用状态不为禁用以及只入的货位，如果是true，则表示浅货位被使用或者被禁用的情况
                    }
                    break;
                case PalletTypeEnum.MediumPallet:
                case PalletTypeEnum.SmallPallet:
                case 1:
                case 2:
                    {
                        List<Dt_LocationInfo> moreDepth = locations.Where(x => x.Depth > emptyLocation.Depth).ToList();
                        moreDepthFlag = moreDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.InStock.ObjToInt() && (x.EnableStatus == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatus == EnableStatusEnum.Normal.ObjToInt())) == null;//查询大于当前货位深度的集合里是否有状态不为有货的货位，如果是true，则表示深货位有未被使用的情况

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

@@ -29,7 +29,7 @@
        /// æ‰˜ç›˜ç±»åž‹ 
        /// </param>
        /// <returns></returns>
        public Dt_LocationInfo? AssignLocation_GM(string roadwayNo, PalletTypeEnum palletType, string beRelocationCode = "")
        public Dt_LocationInfo? AssignLocation_GM(string roadwayNo, int palletType, Dt_PalletTypeInfo palletTypeInfo, string beRelocationCode = "")
        {
            lock (_locker_GM)
            {
@@ -77,14 +77,17 @@

                if ((locationInfos.Count * weightValue_GM >= definedTypeLocations.Count && undefinedTypeEmptyLocations.Any()) || !definedTypeEmptyLocations.Any())//如果已定义类型货位未超过比例，且有未定义类型的货位
                {
                    if (palletType == PalletTypeEnum.LargePallet || palletType == PalletTypeEnum.LargestPallet)
                    if (palletTypeInfo.LocaitonCount == 2)
                    {
                        undefinedTypeEmptyLocations = undefinedTypeEmptyLocations.Where(x => x.Column % 2 == 1).ToList();
                        if (palletTypeInfo.IsOdd)
                            undefinedTypeEmptyLocations = undefinedTypeEmptyLocations.Where(x => x.Column % 2 == 1).ToList();
                        else
                            undefinedTypeEmptyLocations = undefinedTypeEmptyLocations.Where(x => x.Column % 2 == 0).ToList();
                    }
                    for (int i = 0; i < undefinedTypeEmptyLocations.Count; i++)
                    {
                        Dt_LocationInfo undefinedTypeEmptyLocation = undefinedTypeEmptyLocations[i];
                        Dt_LocationInfo? locationInfo = GetUsableLocation_GM(locationInfos, undefinedTypeEmptyLocation, palletType);
                        Dt_LocationInfo? locationInfo = GetUsableLocation_GM(locationInfos, undefinedTypeEmptyLocation, palletType, palletTypeInfo);
                        if (locationInfo != null)
                        {
                            locationCaches_GM.Add(new LocationCache { LocationCode = locationInfo.LocationCode, DateTime = DateTime.Now });
@@ -97,7 +100,7 @@
                    for (int i = 0; i < definedTypeEmptyLocations.Count; i++)
                    {
                        Dt_LocationInfo definedTypeEmptyLocation = definedTypeEmptyLocations[i];
                        Dt_LocationInfo? locationInfo = GetUsableLocation_GM(locationInfos, definedTypeEmptyLocation, palletType);
                        Dt_LocationInfo? locationInfo = GetUsableLocation_GM(locationInfos, definedTypeEmptyLocation, palletType, palletTypeInfo);
                        if (locationInfo != null)
                        {
                            locationCaches_GM.Add(new LocationCache { LocationCode = locationInfo.LocationCode, DateTime = DateTime.Now });
@@ -116,25 +119,34 @@
        /// <param name="emptyLocation"></param>
        /// <param name="palletType"></param>
        /// <returns></returns>
        private Dt_LocationInfo? GetUsableLocation_GM(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, PalletTypeEnum palletType)
        private Dt_LocationInfo? GetUsableLocation_GM(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, int palletType, Dt_PalletTypeInfo palletTypeInfo)
        {
            switch (palletType)
            if (palletTypeInfo.LocaitonCount == 2)
            {
                case PalletTypeEnum.LargestPallet:
                case PalletTypeEnum.LargePallet:
                    if (emptyLocation.Column % 2 == 0)
                if (palletTypeInfo.IsOdd && emptyLocation.Column % 2 != 1 || !palletTypeInfo.IsOdd && emptyLocation.Column % 2 != 0)
                    return null;

                Dt_LocationInfo? nearLocation = locationInfos.FirstOrDefault(x => x.Row == emptyLocation.Row && x.Layer == emptyLocation.Layer && x.Depth == emptyLocation.Depth && x.Column == emptyLocation.Column + 1);
                if (nearLocation != null && DepthLocationIsEmpty_BC(locationInfos, nearLocation) != null)
                {
                    Dt_LocationInfo? locationInfo = DepthLocationIsEmpty_BC(locationInfos, emptyLocation);
                    if (locationInfo != null)
                    {
                        return null;
                        return locationInfo;
                    }
                    break;
                }
            }
            Dt_LocationInfo? locationInfo = DepthLocationIsEmpty_GM(locationInfos, emptyLocation, palletType);
            if (locationInfo != null)
            else
            {
                return locationInfo;
                Dt_LocationInfo? locationInfo = DepthLocationIsEmpty_BC(locationInfos, emptyLocation);
                if (locationInfo != null)
                {
                    return locationInfo;
                }
            }
            return null;
        }


        /// <summary>
        /// åˆ¤æ–­ä¸åŒæ·±åº¦çš„同组货位状态是否为空闲空位(测试架仓)
@@ -142,24 +154,18 @@
        /// <param name="locationInfos"></param>
        /// <param name="emptyLocation"></param>
        /// <returns></returns>
        private Dt_LocationInfo? DepthLocationIsEmpty_GM(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, PalletTypeEnum palletType)
        private Dt_LocationInfo? DepthLocationIsEmpty_GM(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation)
        {
            List<Dt_LocationInfo> locations = GetGroupLocations(locationInfos, emptyLocation);

            bool moreDepthFlag = false;
            bool littleDepthFlag = false;

            switch (palletType)
            {
                case PalletTypeEnum.LargestPallet:
                case PalletTypeEnum.LargePallet:
                    List<Dt_LocationInfo> moreDepth = locations.Where(x => x.Depth > emptyLocation.Depth).ToList();
                    moreDepthFlag = moreDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.InStock.ObjToInt() && x.LocationStatus != LocationStatusEnum.PalletLock.ObjToInt()) == null;//查询大于当前货位深度的集合里是否有状态不为有货的货位，如果是true，则表示深货位有未被使用的情况
            List<Dt_LocationInfo> moreDepth = locations.Where(x => x.Depth > emptyLocation.Depth).ToList();
            moreDepthFlag = moreDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.InStock.ObjToInt() && (x.EnableStatus == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatus == EnableStatusEnum.Normal.ObjToInt())) == null;//查询大于当前货位深度的集合里是否有状态不为有货的货位，如果是true，则表示深货位有未被使用的情况

                    List<Dt_LocationInfo> littleDepth = locations.Where(x => x.Depth <= emptyLocation.Depth).ToList();
                    littleDepthFlag = littleDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.Free.ObjToInt() && x.EnableStatus != EnableStatusEnum.OnlyIn.ObjToInt() && x.EnableStatus != EnableStatusEnum.Normal.ObjToInt()) == null; //查询小于当前货位深度的集合里是否有状态不为空，且禁用状态不为禁用以及只入的货位，如果是true，则表示浅货位被使用或者被禁用的情况
                    break;
            }
            List<Dt_LocationInfo> littleDepth = locations.Where(x => x.Depth <= emptyLocation.Depth).ToList();
            littleDepthFlag = littleDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.Free.ObjToInt() && (x.EnableStatus == EnableStatusEnum.OnlyIn.ObjToInt() || x.EnableStatus == EnableStatusEnum.Normal.ObjToInt())) == null; //查询小于当前货位深度的集合里是否有状态不为空，且禁用状态不为禁用以及只入的货位，如果是true，则表示浅货位被使用或者被禁用的情况

            if (moreDepthFlag && littleDepthFlag)
            {

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

@@ -29,7 +29,7 @@
        /// æ‰˜ç›˜ç±»åž‹ 
        /// </param>
        /// <returns></returns>
        public Dt_LocationInfo? AssignLocation_PP(string roadwayNo, PalletTypeEnum palletType, string beRelocationCode = "")
        public Dt_LocationInfo? AssignLocation_PP(string roadwayNo, int palletType, Dt_PalletTypeInfo palletTypeInfo, string beRelocationCode = "")
        {
            lock (_locker_PP)
            {
@@ -77,10 +77,6 @@

                if ((locationInfos.Count * weightValue_PP >= definedTypeLocations.Count && undefinedTypeEmptyLocations.Any()) || !definedTypeEmptyLocations.Any())//如果已定义类型货位未超过比例，且有未定义类型的货位
                {
                    if (palletType == PalletTypeEnum.LargePallet || palletType == PalletTypeEnum.LargestPallet)
                    {
                        undefinedTypeEmptyLocations = undefinedTypeEmptyLocations.Where(x => x.Column % 2 == 1).ToList();
                    }
                    for (int i = 0; i < undefinedTypeEmptyLocations.Count; i++)
                    {
                        Dt_LocationInfo undefinedTypeEmptyLocation = undefinedTypeEmptyLocations[i];
@@ -116,18 +112,8 @@
        /// <param name="emptyLocation"></param>
        /// <param name="palletType"></param>
        /// <returns></returns>
        private Dt_LocationInfo? GetUsableLocation_PP(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, PalletTypeEnum palletType)
        private Dt_LocationInfo? GetUsableLocation_PP(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, int palletType)
        {
            switch (palletType)
            {
                case PalletTypeEnum.LargestPallet:
                case PalletTypeEnum.LargePallet:
                    if (emptyLocation.Column % 2 == 0)
                    {
                        return null;
                    }
                    break;
            }
            Dt_LocationInfo? locationInfo = DepthLocationIsEmpty_PP(locationInfos, emptyLocation, palletType);
            if (locationInfo != null)
            {
@@ -142,25 +128,17 @@
        /// <param name="locationInfos"></param>
        /// <param name="emptyLocation"></param>
        /// <returns></returns>
        private Dt_LocationInfo? DepthLocationIsEmpty_PP(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, PalletTypeEnum palletType)
        private Dt_LocationInfo? DepthLocationIsEmpty_PP(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, int palletType)
        {
            List<Dt_LocationInfo> locations = GetGroupLocations(locationInfos, emptyLocation);

            bool moreDepthFlag = false;
            bool littleDepthFlag = false;
            List<Dt_LocationInfo> moreDepth = locations.Where(x => x.Depth > emptyLocation.Depth).ToList();
            moreDepthFlag = moreDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.InStock.ObjToInt() && x.LocationStatus != LocationStatusEnum.PalletLock.ObjToInt()) == null;//查询大于当前货位深度的集合里是否有状态不为有货的货位，如果是true，则表示深货位有未被使用的情况

            switch (palletType)
            {
                case PalletTypeEnum.LargestPallet:
                case PalletTypeEnum.LargePallet:
                    List<Dt_LocationInfo> moreDepth = locations.Where(x => x.Depth > emptyLocation.Depth).ToList();
                    moreDepthFlag = moreDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.InStock.ObjToInt() && x.LocationStatus != LocationStatusEnum.PalletLock.ObjToInt()) == null;//查询大于当前货位深度的集合里是否有状态不为有货的货位，如果是true，则表示深货位有未被使用的情况

                    List<Dt_LocationInfo> littleDepth = locations.Where(x => x.Depth <= emptyLocation.Depth).ToList();
                    littleDepthFlag = littleDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.Free.ObjToInt() && x.EnableStatus != EnableStatusEnum.OnlyIn.ObjToInt() && x.EnableStatus != EnableStatusEnum.Normal.ObjToInt()) == null; //查询小于当前货位深度的集合里是否有状态不为空，且禁用状态不为禁用以及只入的货位，如果是true，则表示浅货位被使用或者被禁用的情况
                    break;
            }

            List<Dt_LocationInfo> littleDepth = locations.Where(x => x.Depth <= emptyLocation.Depth).ToList();
            littleDepthFlag = littleDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.Free.ObjToInt() && x.EnableStatus != EnableStatusEnum.OnlyIn.ObjToInt() && x.EnableStatus != EnableStatusEnum.Normal.ObjToInt()) == null; //查询小于当前货位深度的集合里是否有状态不为空，且禁用状态不为禁用以及只入的货位，如果是true，则表示浅货位被使用或者被禁用的情况
            if (moreDepthFlag && littleDepthFlag)
            {
                return emptyLocation;

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

@@ -29,7 +29,7 @@
        /// æ‰˜ç›˜ç±»åž‹
        /// </param>
        /// <returns></returns>
        public Dt_LocationInfo? AssignLocation_ZH(string roadwayNo, PalletTypeEnum palletType, string beRelocationCode = "")
        public Dt_LocationInfo? AssignLocation_ZH(string roadwayNo, int palletType, Dt_PalletTypeInfo palletTypeInfo, string beRelocationCode = "")
        {
            lock (_locker_ZH)
            {
@@ -77,7 +77,7 @@

                if ((locationInfos.Count * weightValue_ZH >= definedTypeLocations.Count && undefinedTypeEmptyLocations.Any()) || !definedTypeEmptyLocations.Any())//如果已定义类型货位未超过比例，且有未定义类型的货位
                {
                    if (palletType == PalletTypeEnum.LargePallet || palletType == PalletTypeEnum.LargestPallet)
                    if (palletType == 3 || palletType == 4)
                    {
                        undefinedTypeEmptyLocations = undefinedTypeEmptyLocations.Where(x => x.Column % 2 == 0).ToList();
                    }
@@ -116,12 +116,12 @@
        /// <param name="emptyLocation"></param>
        /// <param name="palletType"></param>
        /// <returns></returns>
        private Dt_LocationInfo? GetUsableLocation_ZH(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, PalletTypeEnum palletType)
        private Dt_LocationInfo? GetUsableLocation_ZH(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, int palletType)
        {
            switch (palletType)
            {
                case PalletTypeEnum.LargestPallet:
                case PalletTypeEnum.LargePallet:
                case 4:
                case 3:
                    if (emptyLocation.Column % 2 != 0)
                    {
                        return null;
@@ -142,24 +142,18 @@
        /// <param name="locationInfos"></param>
        /// <param name="emptyLocation"></param>
        /// <returns></returns>
        private Dt_LocationInfo? DepthLocationIsEmpty_ZH(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, PalletTypeEnum palletType)
        private Dt_LocationInfo? DepthLocationIsEmpty_ZH(List<Dt_LocationInfo> locationInfos, Dt_LocationInfo emptyLocation, int palletType)
        {
            List<Dt_LocationInfo> locations = GetGroupLocations(locationInfos, emptyLocation);

            bool moreDepthFlag = false;
            bool littleDepthFlag = false;

            switch (palletType)
            {
                case PalletTypeEnum.LargestPallet:
                case PalletTypeEnum.LargePallet:
                    List<Dt_LocationInfo> moreDepth = locations.Where(x => x.Depth > emptyLocation.Depth).ToList();
                    moreDepthFlag = moreDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.InStock.ObjToInt() && x.LocationStatus != LocationStatusEnum.PalletLock.ObjToInt()) == null;//查询大于当前货位深度的集合里是否有状态不为有货的货位，如果是true，则表示深货位有未被使用的情况
            List<Dt_LocationInfo> moreDepth = locations.Where(x => x.Depth > emptyLocation.Depth).ToList();
            moreDepthFlag = moreDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.InStock.ObjToInt() && x.LocationStatus != LocationStatusEnum.PalletLock.ObjToInt()) == null;//查询大于当前货位深度的集合里是否有状态不为有货的货位，如果是true，则表示深货位有未被使用的情况

                    List<Dt_LocationInfo> littleDepth = locations.Where(x => x.Depth <= emptyLocation.Depth).ToList();
                    littleDepthFlag = littleDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.Free.ObjToInt() && x.EnableStatus != EnableStatusEnum.OnlyIn.ObjToInt() && x.EnableStatus != EnableStatusEnum.Normal.ObjToInt()) == null; //查询小于当前货位深度的集合里是否有状态不为空，且禁用状态不为禁用以及只入的货位，如果是true，则表示浅货位被使用或者被禁用的情况
                    break;
            }
            List<Dt_LocationInfo> littleDepth = locations.Where(x => x.Depth <= emptyLocation.Depth).ToList();
            littleDepthFlag = littleDepth.FirstOrDefault(x => x.LocationStatus != LocationStatusEnum.Free.ObjToInt() && x.EnableStatus != EnableStatusEnum.OnlyIn.ObjToInt() && x.EnableStatus != EnableStatusEnum.Normal.ObjToInt()) == null; //查询小于当前货位深度的集合里是否有状态不为空，且禁用状态不为禁用以及只入的货位，如果是true，则表示浅货位被使用或者被禁用的情况

            if (moreDepthFlag && littleDepthFlag)
            {

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

@@ -18,12 +18,14 @@
using WIDESEA_Model.Models;
using WIDESEA_Common.CommonEnum;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.TaskEnum;

namespace WIDESEA_BasicService
{
    public partial class LocationInfoService
    {
        public Dt_LocationInfo? AssignLocation(string roadwayNo, PalletTypeEnum palletType, int warehouseId)

        public Dt_LocationInfo? AssignLocation(string roadwayNo, int palletType, int warehouseId)
        {
            Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseId == warehouseId);
            if (warehouse == null)
@@ -31,16 +33,22 @@
                throw new Exception($"未找到仓库信息");
            }

            return warehouse.WarehouseName switch
            Dt_PalletTypeInfo palletTypeInfo = _basicRepository.PalletTypeInfoRepository.QueryFirst(x => x.PalletType == palletType && x.WarehouseId == warehouse.WarehouseId);
            if (palletTypeInfo == null)
            {
                "板材仓" => AssignLocation_BC(roadwayNo, palletType),
                "PP仓" => AssignLocation_PP(roadwayNo, palletType),
                "干膜仓" => AssignLocation_GM(roadwayNo, palletType),
                "测试架仓" => AssignLocation_CSJ(roadwayNo, palletType),
                "阻焊仓" => AssignLocation_ZH(roadwayNo, palletType),
                "油墨仓" => AssignLocation(roadwayNo),
                "成品仓" => AssignLocation(roadwayNo),
                "辅料仓" => AssignLocation(roadwayNo),
                throw new Exception($"请配置托盘类型信息");
            }

            return warehouse.WarehouseCode switch
            {
                "HA57" => AssignLocation_BC(roadwayNo, palletType, palletTypeInfo),
                "HA58" => AssignLocation_PP(roadwayNo, palletType, palletTypeInfo),
                "HA152" => AssignLocation_GM(roadwayNo, palletType, palletTypeInfo),
                "HA64" => AssignLocation_CSJ(roadwayNo, palletType, palletTypeInfo),
                "阻焊仓" => AssignLocation_ZH(roadwayNo, palletType, palletTypeInfo),
                "HA153" => AssignLocation(roadwayNo),
                "HA71" => AssignLocation(roadwayNo),
                "HA60" => AssignLocation(roadwayNo),
                _ => throw new Exception($"未找到仓库货位分配方法")
            };
        }
@@ -85,7 +93,7 @@
        /// <param name="locationCode">货位编号</param>
        /// <param name="palletType">托盘类型</param>
        /// <param name="locationStatus">货位状态</param>
        public void UpdateLocationStatus(string locationCode, PalletTypeEnum palletType, LocationStatusEnum locationStatus, int warehousId)
        public void UpdateLocationStatus(string locationCode, int palletType, LocationStatusEnum locationStatus, int warehousId)
        {
            Dt_LocationInfo location = Repository.QueryFirst(x => x.LocationCode == locationCode);
            if (location == null)
@@ -101,7 +109,7 @@
        /// <param name="location">货位对象</param>
        /// <param name="palletType">托盘类型</param>
        /// <param name="locationStatus">货位状态</param>
        public void UpdateLocationStatus(Dt_LocationInfo location, PalletTypeEnum palletType, LocationStatusEnum locationStatus, int warehousId)
        public void UpdateLocationStatus2(Dt_LocationInfo location, int palletType, LocationStatusEnum locationStatus, int warehousId)
        {
            List<Dt_LocationInfo> locationInfos = Repository.QueryData(x => x.RoadwayNo == location.RoadwayNo);

@@ -176,7 +184,7 @@
                                        nearLocations[i].LocationStatus = LocationStatusEnum.FreeLock.ObjToInt();
                                    }
                                }
                                else if (locationStatus == LocationStatusEnum.Free || locationStatus == LocationStatusEnum.InStock)
                                else if (locationStatus == LocationStatusEnum.InStock)
                                {
                                    if (nearLocations[i].LocationStatus == LocationStatusEnum.InStockLock.ObjToInt())
                                    {
@@ -233,10 +241,164 @@
                    }
                }
            }

            if (locations.Where(x => x.LocationStatus == LocationStatusEnum.Free.ObjToInt()).Count() == locations.Count && locationStatus == LocationStatusEnum.Free)
            {
                locations.ForEach(x =>
                {
                    x.LocationType = 0;
                });
            }

            Repository.UpdateData(locations);
        }

        public void UpdateLocationStatus(Dt_LocationInfo location, int palletType, LocationStatusEnum locationStatus, int warehousId)
        {
            List<Dt_LocationInfo> locationInfos = Repository.QueryData(x => x.RoadwayNo == location.RoadwayNo);

            List<Dt_PalletTypeInfo> palletTypeInfos = _basicRepository.PalletTypeInfoRepository.QueryData(x => x.WarehouseId == warehousId);

            Dt_PalletTypeInfo? palletTypeInfo = palletTypeInfos.FirstOrDefault(x => x.PalletType == palletType && x.WarehouseId == warehousId);
            if (palletTypeInfo == null)
            {
                throw new Exception($"请配置托盘类型信息");
            }
            List<Dt_LocationInfo> locations = GetGroupLocations(locationInfos, location);
            if (locationInfos.Max(x => x.Depth) < 3)
            {
                for (int i = 0; i < locations.Count; i++)
                {
                    if (locations[i].LocationType != palletType)
                    {
                        locations[i].LocationType = palletType;
                    }

                    if (locations[i].LocationCode == location.LocationCode)
                    {
                        locations[i].LocationStatus = locationStatus.ObjToInt();
                    }
                    else
                    {
                        if (locationStatus == LocationStatusEnum.Lock)
                        {
                            if (locations[i].LocationStatus == LocationStatusEnum.InStock.ObjToInt())
                            {
                                locations[i].LocationStatus = LocationStatusEnum.InStockLock.ObjToInt();
                            }
                            else if (locations[i].LocationStatus == LocationStatusEnum.Free.ObjToInt())
                            {
                                locations[i].LocationStatus = LocationStatusEnum.FreeLock.ObjToInt();
                            }
                        }
                        else if (locationStatus == LocationStatusEnum.Free || locationStatus == LocationStatusEnum.InStock)
                        {
                            if (locations[i].LocationStatus == LocationStatusEnum.InStockLock.ObjToInt())
                            {
                                locations[i].LocationStatus = LocationStatusEnum.InStock.ObjToInt();
                            }
                            else if (locations[i].LocationStatus == LocationStatusEnum.FreeLock.ObjToInt())
                            {
                                locations[i].LocationStatus = LocationStatusEnum.Free.ObjToInt();
                            }
                        }
                    }
                }

                if (palletTypeInfos.FirstOrDefault(x => x.LocaitonCount == 2) != null)
                {
                    Dt_LocationInfo? nearLocation;
                    if (palletTypeInfo.IsOdd)
                    {
                        nearLocation = locationInfos.FirstOrDefault(x => x.Row == location.Row && x.Layer == location.Layer && x.Depth == location.Depth && x.Column == location.Column + 1);
                    }
                    else
                    {
                        nearLocation = locationInfos.FirstOrDefault(x => x.Row == location.Row && x.Layer == location.Layer && x.Depth == location.Depth && x.Column == location.Column - 1);
                    }

                    if (nearLocation != null)
                    {
                        List<Dt_LocationInfo> nearLocations = GetGroupLocations(locationInfos, nearLocation);
                        for (int i = 0; i < nearLocations.Count; i++)
                        {
                            if (nearLocations[i].LocationType != palletType)
                            {
                                nearLocations[i].LocationType = palletType;
                            }

                            if (locationStatus == LocationStatusEnum.Lock)
                            {
                                if (nearLocations[i].LocationStatus == LocationStatusEnum.InStock.ObjToInt())
                                {
                                    nearLocations[i].LocationStatus = LocationStatusEnum.InStockLock.ObjToInt();
                                }
                                else if (nearLocations[i].LocationStatus == LocationStatusEnum.Free.ObjToInt())
                                {
                                    nearLocations[i].LocationStatus = LocationStatusEnum.FreeLock.ObjToInt();
                                }
                            }
                            else if (locationStatus == LocationStatusEnum.Free || locationStatus == LocationStatusEnum.InStock)
                            {
                                if (nearLocations[i].LocationStatus == LocationStatusEnum.InStockLock.ObjToInt())
                                {
                                    nearLocations[i].LocationStatus = LocationStatusEnum.InStock.ObjToInt();
                                }
                                else if (nearLocations[i].LocationStatus == LocationStatusEnum.FreeLock.ObjToInt())
                                {
                                    nearLocations[i].LocationStatus = LocationStatusEnum.Free.ObjToInt();
                                }
                            }

                        }
                        locations.AddRange(nearLocations);
                    }
                }



            }
            else
            {
                for (int i = 0; i < locations.Count; i++)
                {
                    if (locations[i].LocationCode == location.LocationCode)
                    {
                        locations[i].LocationStatus = locationStatus.ObjToInt();
                    }
                    else
                    {
                        if (locationStatus == LocationStatusEnum.Lock)
                        {
                            if (locations[i].LocationStatus == LocationStatusEnum.InStock.ObjToInt())
                            {
                                locations[i].LocationStatus = LocationStatusEnum.InStockLock.ObjToInt();
                            }
                            else if (locations[i].LocationStatus == LocationStatusEnum.Free.ObjToInt())
                            {
                                locations[i].LocationStatus = LocationStatusEnum.FreeLock.ObjToInt();
                            }
                        }
                        else if (locationStatus == LocationStatusEnum.Free || locationStatus == LocationStatusEnum.InStock)
                        {
                            if (locations[i].LocationStatus == LocationStatusEnum.InStockLock.ObjToInt())
                            {
                                locations[i].LocationStatus = LocationStatusEnum.InStock.ObjToInt();
                            }
                            else if (locations[i].LocationStatus == LocationStatusEnum.FreeLock.ObjToInt())
                            {
                                locations[i].LocationStatus = LocationStatusEnum.Free.ObjToInt();
                            }
                        }
                    }
                    if (locations[i].LocationType != palletType.ObjToInt())
                    {
                        locations[i].LocationType = palletType.ObjToInt();
                    }
                }
            }
            Repository.UpdateData(locations);
        }

        /// <summary>
        /// èŽ·å–不同深度的同组货位信息

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Common/TaskEnum/TaskTypeEnum.cs

@@ -29,6 +29,12 @@
        /// </summary>
        [Description("质检出库")]
        OutQuality = 130,

        /// <summary>
        /// MES出库
        /// </summary>
        [Description("MES出库")]
        MesOutbound = 200,
        /// <summary>
        /// é‡‡è´­å…¥åº“
        /// </summary>
@@ -49,11 +55,19 @@
        /// </summary>
        [Description("质检入库")]
        InQuality = 540,

        /// <summary>
        /// ç”Ÿäº§é€€æ–™
        /// </summary>
        [Description("生产退料")]
        ProductionReturn = 550,

        /// <summary>
        /// MES退料
        /// </summary>
        [Description("MES退料")]
        MesMatReturn = 560,

        /// <summary>
        /// å··é“内移库
        /// </summary>

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/AOP/SqlSugarAop.cs

@@ -30,18 +30,21 @@
                CodeRuleAttribute? codeRuleAttribute = propertyInfo.GetCustomAttribute<CodeRuleAttribute>();
                if (codeRuleAttribute != null)
                {
                    SqlSugarClient sugarClient = new SqlSugarClient(new ConnectionConfig
                    if (propertyInfo.GetValue(entityInfo.EntityValue) == null)
                    {
                        ConfigId = MainDb.CurrentDbConnId,
                        ConnectionString = DBContext.GetMainConnectionDb().Connection,
                        IsAutoCloseConnection = true,
                        DbType = MainDb.DbType,
                    });
                    dynamic ruleConfig = sugarClient.Queryable(MainDb.CodeRuleConfig, "x").Where(nameof(CodeRuleAttribute.RuleCode), "=", codeRuleAttribute.RuleCode.ToString()).First();
                    if (ruleConfig != null)
                    {
                        string code = CreateCodeByRule(ruleConfig, sugarClient);
                        propertyInfo.SetValue(entityInfo.EntityValue, code, null);
                        SqlSugarClient sugarClient = new SqlSugarClient(new ConnectionConfig
                        {
                            ConfigId = MainDb.CurrentDbConnId,
                            ConnectionString = DBContext.GetMainConnectionDb().Connection,
                            IsAutoCloseConnection = true,
                            DbType = MainDb.DbType,
                        });
                        dynamic ruleConfig = sugarClient.Queryable(MainDb.CodeRuleConfig, "x").Where(nameof(CodeRuleAttribute.RuleCode), "=", codeRuleAttribute.RuleCode.ToString()).First();
                        if (ruleConfig != null)
                        {
                            string code = CreateCodeByRule(ruleConfig, sugarClient);
                            propertyInfo.SetValue(entityInfo.EntityValue, code, null);
                        }
                    }
                }


 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_DTO/Basic/MatSerNumAnalysisModel.cs

@@ -8,6 +8,9 @@

namespace WIDESEA_DTO.Basic
{
    /// <summary>
    /// 
    /// </summary>
    [AnalysisRule, ModelValidate]
    public class MatSerNumAnalysisModel
    {

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MES/MESRoot.cs

@@ -20,23 +20,5 @@
        
        public T Content { get; set; }
    }
    /// <summary>
    ///测试架同步
    /// </summary>
    public class TestToolSynInfo
    {
        /// <summary>
        /// æµ‹è¯•æž¶æ‰¹æ¬¡å·
        /// </summary>
        public string ToolCode { get; set; }
        /// <summary>
        /// æµ‹è¯•æž¶ç‰©æ–™åç§°
        /// </summary>
        public string MaterialName { get; set; }
        /// <summary>
        /// åˆå§‹å¯¿å‘½
        /// </summary>
        public int Life { get; set; }

    }
    
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MES/MesMaterialLotaAceptModel.cs

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

namespace WIDESEA_DTO.MES
{
    /// <summary>
    /// ç‰©æ–™å‡ºåº“，WMS同步出库物料批次至MES
    /// </summary>
    public class MesMaterialLotaAceptModel
    {
        /// <summary>
        /// ç‰©æ–™ç¼–码
        /// </summary>
        public string MaterialCode {  get; set; }

        /// <summary>
        /// ç‰©æ–™åç§°
        /// </summary>
        public string MaterialName {  get; set; }

        /// <summary>
        /// åŽŸå§‹ç‰©æ–™æ‰¹æ¬¡ ä¾›åº”商批次(MES按物料编码+“,”+物料批次拼接)
        /// </summary>
        public string MaterialLot {  get; set; }

        /// <summary>
        /// æ•°é‡
        /// </summary>
        public float Quantity {  get; set; }

        /// <summary>
        /// çº¿è¾¹åº“区
        /// </summary>
        public string WarehouseArea {  get; set; }

        /// <summary>
        /// çº¿è¾¹åº“位
        /// </summary>
        public string WarehouseLocation {  get; set; }

        /// <summary>
        /// ä¾›åº”商
        /// </summary>
        public string Supplier {  get; set; }

        /// <summary>
        /// è½½å…·ç¼–码
        /// </summary>
        public string CarrierCode {  get; set; }

        /// <summary>
        /// ä»»åŠ¡å•å·
        /// </summary>
        public string TaskNo {  get; set; }

        /// <summary>
        /// å‡ºåº“类型
        /// </summary>
        public int Type {  get; set; }

        /// <summary>
        /// æœ‰æ•ˆæœŸ
        /// </summary>
        public string ExpirationDate {  get; set; }

        /// <summary>
        /// ç”Ÿäº§æ—¥æœŸ
        /// </summary>
        public string ProductionDate {  get; set; }

        /// <summary>
        /// ç‰©æ–™æ ‡ç­¾
        /// </summary>
        public string MaterialBarCode {  get; set; }

        /// <summary>
        /// è£åˆ‡åž‹å·
        /// </summary>
        public string CutedType {  get; set; }

        /// <summary>
        /// PP宽度
        /// </summary>
        public float PPWidth {  get; set; }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_DTO/MES/TestToolModel.cs

@@ -56,4 +56,24 @@
        [PropertyValidate("测试架批次号", NotNullAndEmpty = true)]
        public string TestToolCode { get; set; }
    }

    /// <summary>
    ///测试架同步
    /// </summary>
    public class TestToolSynInfo
    {
        /// <summary>
        /// æµ‹è¯•æž¶æ‰¹æ¬¡å·
        /// </summary>
        public string ToolCode { get; set; }
        /// <summary>
        /// æµ‹è¯•æž¶ç‰©æ–™åç§°
        /// </summary>
        public string MaterialName { get; set; }
        /// <summary>
        /// åˆå§‹å¯¿å‘½
        /// </summary>
        public int Life { get; set; }

    }
}

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

@@ -16,5 +16,7 @@

        IWarehouseRepository WarehouseRepository { get; }

        IPalletTypeInfoRepository PalletTypeInfoRepository { get; }

    }
}

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

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

namespace WIDESEA_IBasicRepository
{
    public interface IPalletTypeInfoRepository : IRepository<Dt_PalletTypeInfo>
    {
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IBasicService/ILocationInfoService.cs

@@ -58,7 +58,7 @@
        /// <param name="roadwayNo">巷道号</param>
        /// <param name="palletType">托盘类型</param>
        /// <returns></returns>
        Dt_LocationInfo? AssignLocation(string roadwayNo, PalletTypeEnum palletType, int warehouseId);
        Dt_LocationInfo? AssignLocation(string roadwayNo, int palletType, int warehouseId);

        /// <summary>
        /// ä¿®æ”¹è´§ä½çŠ¶æ€åŠç±»åž‹
@@ -66,7 +66,7 @@
        /// <param name="locationCode">货位编号</param>
        /// <param name="palletType">托盘类型</param>
        /// <param name="locationStatus">货位状态</param>
        void UpdateLocationStatus(string locationCode, PalletTypeEnum palletType, LocationStatusEnum locationStatus, int warehousId);
        void UpdateLocationStatus(string locationCode, int palletType, LocationStatusEnum locationStatus, int warehousId);

        /// <summary>
        /// ä¿®æ”¹è´§ä½çŠ¶æ€åŠç±»åž‹
@@ -74,7 +74,7 @@
        /// <param name="location">货位对象</param>
        /// <param name="palletType">托盘类型</param>
        /// <param name="locationStatus">货位状态</param>
        void UpdateLocationStatus(Dt_LocationInfo location, PalletTypeEnum palletType, LocationStatusEnum locationStatus, int warehousId);
        void UpdateLocationStatus(Dt_LocationInfo location, int palletType, LocationStatusEnum locationStatus, int warehousId);

        /// <summary>
        /// èŽ·å–不同深度的同组货位信息

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

@@ -7,11 +7,35 @@
using WIDESEA_DTO.MES;
using WIDESEA_DTO;
using WIDESEA_Model.Models;
using WIDESEA_IOutboundRepository;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Core;

namespace WIDESEA_IOutboundService
{
    public interface IMesOutboundOrderService : IService<Dt_MesOutboundOrder>
    {
        MesResponseContent SubstrateOut(SubstrateOutModel model);
        /// <summary>
        /// 
        /// </summary>
        IMesOutboundOrderRepository Repository { get; }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="mesOutboundOrder"></param>
        /// <returns></returns>
        (List<Dt_StockInfo>, Dt_MesOutboundOrder, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesOutboundOrder mesOutboundOrder);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="stockInfos"></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_OutStockLockInfo> outStockLockInfos, List<Dt_LocationInfo> locationInfos, LocationStatusEnum locationStatus = LocationStatusEnum.Lock, List<Dt_Task>? tasks = null);
    }
}

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

@@ -14,13 +14,55 @@
{
    public interface IOutStockLockInfoService : IService<Dt_OutStockLockInfo>
    {
        /// <summary>
        /// 
        /// </summary>
        IOutStockLockInfoRepository Repository { get; }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="outboundOrder"></param>
        /// <param name="outboundOrderDetail"></param>
        /// <param name="outStocks"></param>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        List<Dt_OutStockLockInfo> GetOutStockLockInfos(Dt_OutboundOrder outboundOrder, Dt_OutboundOrderDetail outboundOrderDetail, List<Dt_StockInfo> outStocks, int? taskNum = null);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="outboundOrder"></param>
        /// <param name="outboundOrderDetail"></param>
        /// <param name="outStock"></param>
        /// <param name="assignQuantity"></param>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        Dt_OutStockLockInfo GetOutStockLockInfo(Dt_OutboundOrder outboundOrder, Dt_OutboundOrderDetail outboundOrderDetail, Dt_StockInfo outStock, float assignQuantity, int? taskNum = null);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="mesOutboundOrder"></param>
        /// <param name="outStock"></param>
        /// <param name="assignQuantity"></param>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        Dt_OutStockLockInfo GetOutStockLockInfo(Dt_MesOutboundOrder mesOutboundOrder, Dt_StockInfo outStock, float assignQuantity, int? taskNum = null);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="orderDetailId"></param>
        /// <param name="outStockStatus"></param>
        /// <returns></returns>
        List<Dt_OutStockLockInfo> GetByOrderDetailId(int orderDetailId, OutLockStockStatusEnum outStockStatus);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="saveModel"></param>
        /// <returns></returns>
        List<Dt_OutStockLockInfo> GetStockOutboundOrder(SaveModel saveModel);

        /// <summary>

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_IStockRepository/IStockRepository.cs

@@ -12,5 +12,9 @@
        IStockInfoDetailRepository StockInfoDetailRepository { get; }

        IStockInfoRepository StockInfoRepository { get; }

        IStockInfoDetail_HtyRepository StockInfoDetail_HtyRepository { get; }

        IStockInfo_HtyRepository StockInfo_HtyRepository { get; }
    }
}

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

@@ -39,8 +39,20 @@
    {
        ITaskRepository Repository { get; }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="tasks"></param>
        /// <param name="agvDescription"></param>
        /// <returns></returns>
        WebResponseContent PushTasksToWCS(List<Dt_Task> tasks, string agvDescription = "");

        /// <summary>
        /// 
        /// </summary>
        /// <param name="taskNum"></param>
        /// <param name="agvDescription"></param>
        /// <returns></returns>
        WebResponseContent PushTasksToWCSSingle(int taskNum, string agvDescription = "");

        /// <summary>
@@ -70,6 +82,11 @@
        /// <returns></returns>
        WebResponseContent AssignInboundTaskLocation(int taskNum, string roadwayNo);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        WebResponseContent TaskCompleted(int taskNum);

        /// <summary>
@@ -114,19 +131,55 @@
        /// <param name="locationCode">入库或出库的货位号</param>
        /// <returns></returns>
        MesResponseContent TestToolBack(TestToolBackModel backModel);

        /// <summary>
        /// æµ‹è¯•æž¶æŠ¥åºŸ
        /// </summary>
        /// <param name="toolScrap"></param>
        /// <returns></returns>
        MesResponseContent TestScrap(TestToolScrap toolScraps);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="taskNum"></param>
        /// <param name="locationCode"></param>
        /// <returns></returns>
        WebResponseContent IsRelocation(int taskNum, string locationCode);

        /// <summary>
        /// 
        /// </summary>
        /// <param name="toolSynInfo"></param>
        /// <returns></returns>
        WebResponseContent TestSynStock(TestToolSynInfo toolSynInfo);

        /// <summary>
        /// é€‰æ‹©åº“存生成出库任务
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        WebResponseContent Outbound(int id);

        /// <summary>
        /// ç‰©æ–™å‡ºåº“，WMS同步出库物料批次至MES
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        WebResponseContent UploadMesMaterialLotaAcept(MesMaterialLotaAceptModel model);

        /// <summary>
        /// åŸºæ¿å‡ºåº“
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        MesResponseContent SubstrateOut(SubstrateOutModel model);

        /// <summary>
        /// åŸºæ¿ä½™æ–™é€€åº“
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        MesResponseContent SubstrateBack(SubstrateBackModel model);
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_InboundService/InboundOrderService.cs

@@ -52,10 +52,11 @@
        private readonly IRecordService _recordService;
        private readonly IInvokeERPService _invokeERPService;
        private readonly IWarehouseService _warehouseService;
        private readonly IPalletTypeInfoRepository _palletTypeInfoRepository;

        public IInboundOrderRepository Repository => BaseDal;

        public InboundOrderService(IInboundOrderRepository BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IInboundRepository inboundRepository, IBasicRepository basicRepository, IStockRepository stockRepository, IRecordService recordService, IInvokeERPService invokeERPService, IWarehouseService warehouseService) : base(BaseDal)
        public InboundOrderService(IInboundOrderRepository BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IInboundRepository inboundRepository, IBasicRepository basicRepository, IStockRepository stockRepository, IRecordService recordService, IInvokeERPService invokeERPService, IWarehouseService warehouseService, IPalletTypeInfoRepository palletTypeInfoRepository) : base(BaseDal)
        {
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
@@ -65,6 +66,7 @@
            _recordService = recordService;
            _invokeERPService = invokeERPService;
            _warehouseService = warehouseService;
            _palletTypeInfoRepository = palletTypeInfoRepository;
        }
        /// <summary>
        /// å…¶ä»–入库单创建
@@ -273,7 +275,7 @@
                {
                    return WebResponseContent.Instance.Error($"未找到该仓库信息");
                }
                

                Dt_InboundOrder inboundOrder = BaseDal.Db.Queryable<Dt_InboundOrder>().Where(x => x.InboundOrderNo == orderNo && x.WarehouseId == warehouse.WarehouseId).Includes(x => x.Details).First();
                if (inboundOrder == null)
                {
@@ -331,7 +333,7 @@
                        PalletCode = palletCode,
                        StockStatus = StockStatusEmun.组盘暂存.ObjToInt(),
                        WarehouseId = inboundOrder.WarehouseId,
                        PalletType = PalletTypeEnum.SmallPallet.ObjToInt(),
                        PalletType = GetPalletType(warehouse, palletCode, materielInfo),
                        Details = new List<Dt_StockInfoDetail>()
                    };
                }
@@ -353,7 +355,7 @@
                    {
                        return WebResponseContent.Instance.Error($"{batchNo}测试架已存在");
                    }
                    if (models.Count>=2)
                    if (models.Count >= 2)
                    {
                        return WebResponseContent.Instance.Error($"组盘明细不唯一");
                    }
@@ -466,7 +468,7 @@
                float beforeQuantity = 0;

                Dt_StockInfo stockInfo = _stockRepository.StockInfoRepository.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == palletCode).Includes(x => x.Details).First();
                

                if (stockInfo == null)
                {
                    stockInfo = new Dt_StockInfo()
@@ -474,7 +476,7 @@
                        PalletCode = palletCode,
                        StockStatus = StockStatusEmun.手动组盘暂存.ObjToInt(),
                        WarehouseId = warehouse.WarehouseId,
                        PalletType = PalletTypeEnum.SmallPallet.ObjToInt(),
                        PalletType = GetPalletType(warehouse, palletCode, materielInfo),
                        Details = new List<Dt_StockInfoDetail>()
                    };
                }
@@ -523,7 +525,7 @@
                        SerialNumber = model.SerialNumber,
                        StockQuantity = model.Quantity,
                        OutboundQuantity = 0,
                        Unit= materielInfo.MaterielUnit,
                        Unit = materielInfo.MaterielUnit,
                        Status = StockStatusEmun.组盘暂存.ObjToInt(),
                        ProductionDate = model.ProductionDate,
                        EffectiveDate = model.EffectiveDate,
@@ -615,82 +617,107 @@
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        //public WebResponseContent FeedbackInboundOrder(int id)
        //{
        //    try
        //    {
        //        Dt_InboundOrder inboundOrder = Db.Queryable<Dt_InboundOrder>().Where(x => x.Id == id).Includes(x => x.Details).First();
        //        if (inboundOrder == null)
        //        {
        //            return WebResponseContent.Instance.Error($"未找到入库单信息");
        //        }
        //        if (inboundOrder.Details == null || inboundOrder.Details.Count == 0)
        //        {
        //            return WebResponseContent.Instance.Error($"未找到入库单明细信息");
        //        }
        //        if (inboundOrder.OrderStatus == InOrderStatusEnum.入库完成.ObjToInt())
        //        {
        //            return WebResponseContent.Instance.Error($"入库单据已完成");
        //        }
        public WebResponseContent FeedbackInboundOrder(int id)
        {
            try
            {
                Dt_InboundOrder inboundOrder = Db.Queryable<Dt_InboundOrder>().Where(x => x.Id == id).Includes(x => x.Details).First();
                if (inboundOrder == null)
                {
                    return WebResponseContent.Instance.Error($"未找到入库单信息");
                }
                if (inboundOrder.Details == null || inboundOrder.Details.Count == 0)
                {
                    return WebResponseContent.Instance.Error($"未找到入库单明细信息");
                }
                if (inboundOrder.OrderStatus == InOrderStatusEnum.入库完成.ObjToInt())
                {
                    return WebResponseContent.Instance.Error($"入库单据已完成");
                }

        //        List<Dt_StockInfo> stockInfos = Db.Queryable<Dt_StockInfo>().Where(x => x.Details.Any(v => v.OrderNo == inboundOrder.InboundOrderNo)).Includes(x => x.Details).ToList();
        //        List<Dt_Warehouse> warehouses = Db.Queryable<Dt_Warehouse>().ToList();
                List<Dt_StockInfo> stockInfos = Db.Queryable<Dt_StockInfo>().Where(x => x.Details.Any(v => v.OrderNo == inboundOrder.InboundOrderNo)).Includes(x => x.Details).ToList();
                List<Dt_Warehouse> warehouses = Db.Queryable<Dt_Warehouse>().ToList();

        //        List<ERPInboundDetailModel> detailModels = new List<ERPInboundDetailModel>();
        //        foreach (var item in inboundOrder.Details)
        //        {
        //            Dt_StockInfo? stockInfo = stockInfos.FirstOrDefault(x => x.Details.Any(v => v.InboundOrderRowNo == item.RowNo && v.MaterielCode == item.MaterielCode));
        //            if (stockInfo == null)
        //            {
        //                return WebResponseContent.Instance.Error($"未找到库存信息");
        //            }
                List<ERPInboundDetailModel> detailModels = new List<ERPInboundDetailModel>();
                foreach (var item in inboundOrder.Details)
                {
                    Dt_StockInfo? stockInfo = stockInfos.FirstOrDefault(x => x.Details.Any(v => v.InboundOrderRowNo == item.RowNo && v.MaterielCode == item.MaterielCode));
                    if (stockInfo == null)
                    {
                        return WebResponseContent.Instance.Error($"未找到库存信息");
                    }

        //            Dt_Warehouse? warehouse = warehouses.FirstOrDefault(x => x.WarehouseId == stockInfo.WarehouseId);
        //            if (warehouse == null)
        //            {
        //                return WebResponseContent.Instance.Error($"未找到仓库信息");
        //            }
                    Dt_Warehouse? warehouse = warehouses.FirstOrDefault(x => x.WarehouseId == stockInfo.WarehouseId);
                    if (warehouse == null)
                    {
                        return WebResponseContent.Instance.Error($"未找到仓库信息");
                    }

        //            ERPInboundDetailModel detailModel = new ERPInboundDetailModel()
        //            {
        //                ExpiryDate = stockInfo.Details.FirstOrDefault()?.EffectiveDate ?? "",
        //                LocationCode = warehouse.WarehouseCode,
        //                MaterialsCode = item.MaterielCode,
        //                MfgDate = stockInfo.Details.FirstOrDefault()?.ProductionDate ?? "",
        //                QtyCustoms = "0",
        //                Quantity = stockInfo.Details.Sum(x => x.StockQuantity).ToString(),
        //                Rack = stockInfo.LocationCode,
        //                ReceiptCode = inboundOrder.UpperOrderNo,
        //                ReceiptSerNo = item.RowNo.ToString()
        //            };
        //            detailModels.Add(detailModel);
        //        }
        //        Dt_Warehouse? warehouse2 = warehouses.FirstOrDefault(x => x.WarehouseId == inboundOrder.WarehouseId);
        //        if (warehouse2 == null)
        //        {
        //            return WebResponseContent.Instance.Error($"未找到仓库信息");
        //        }
        //        ERPInboundModel model = new ERPInboundModel()
        //        {
        //            Code = inboundOrder.InboundOrderNo,
        //            CreatorCode = inboundOrder.Creater,//测试
        //            EntDate = inboundOrder.CreateDate.ToString("yyyy-MM-dd HH:mm:ss"),
        //            StockDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
        //            SuppliersId = inboundOrder.SupplierId,
        //            Type = "S",
        //            UniqueTag = inboundOrder.Id.ToString(),
        //            WarehouseCode = warehouse2.WarehouseCode,
        //            Way = 1,
        //            Details = detailModels
        //        };
        //        //测试注释
        //        _invokeERPService.InvokeInboundOrderApi(model);
        //        return WebResponseContent.Instance.OK();
        //    }
        //    catch (Exception ex)
        //    {
        //        return WebResponseContent.Instance.Error(ex.Message);
        //    }
        //}
                    ERPInboundDetailModel detailModel = new ERPInboundDetailModel()
                    {
                        ExpiryDate = stockInfo.Details.FirstOrDefault()?.EffectiveDate ?? "",
                        LocationCode = warehouse.WarehouseCode,
                        MaterialsCode = item.MaterielCode,
                        MfgDate = stockInfo.Details.FirstOrDefault()?.ProductionDate ?? "",
                        QtyCustoms = "0",
                        Quantity = stockInfo.Details.Sum(x => x.StockQuantity).ToString(),
                        Rack = stockInfo.LocationCode,
                        ReceiptCode = inboundOrder.UpperOrderNo,
                        ReceiptSerNo = item.RowNo.ToString()
                    };
                    detailModels.Add(detailModel);
                }
                Dt_Warehouse? warehouse2 = warehouses.FirstOrDefault(x => x.WarehouseId == inboundOrder.WarehouseId);
                if (warehouse2 == null)
                {
                    return WebResponseContent.Instance.Error($"未找到仓库信息");
                }
                ERPInboundModel model = new ERPInboundModel()
                {
                    Code = inboundOrder.InboundOrderNo,
                    CreatorCode = inboundOrder.Creater,//测试
                    EntDate = inboundOrder.CreateDate.ToString("yyyy-MM-dd HH:mm:ss"),
                    StockDate = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                    SuppliersId = inboundOrder.SupplierId,
                    Type = "S",
                    UniqueTag = inboundOrder.Id.ToString(),
                    WarehouseCode = warehouse2.WarehouseCode,
                    Way = 1,
                    Details = detailModels
                };
                //测试注释
                _invokeERPService.InvokeInboundOrderApi(model);
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }

        public int GetPalletType(Dt_Warehouse warehouse, string palletCode, Dt_MaterielInfo materielInfo)
        {
            if (warehouse.WarehouseCode == WarehouseEnum.HA64.ToString())
            {
                if (palletCode.Substring(0, 1) == "6")
                {
                    return PalletTypeEnum.MediumPallet.ObjToInt();
                }
                else
                {
                    return PalletTypeEnum.LargestPallet.ObjToInt();
                }
            }
            else if (warehouse.WarehouseCode == WarehouseEnum.HA152.ObjToString())
            {
                Dt_PalletTypeInfo palletTypeInfo = _palletTypeInfoRepository.QueryFirst(x => x.CodeStartStr == palletCode.Substring(0, 2));
                if (palletTypeInfo == null)
                {
                    throw new Exception($"托盘号错误");
                }
                return palletTypeInfo.PalletType;
            }
            return -1;
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Model/Models/Basic/Dt_PalletTypeInfo.cs

@@ -27,6 +27,12 @@
        public int PalletType { get; set; }

        /// <summary>
        /// æ‰˜ç›˜å·èµ·å§‹å­—符串
        /// </summary>
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "托盘号起始字符串")]
        public string CodeStartStr { get; set; }

        /// <summary>
        /// æ‰˜ç›˜ç±»åž‹åç§°
        /// </summary>
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "托盘类型名称")]
@@ -67,5 +73,17 @@
        /// </summary>
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "所属层")]
        public string SortNum { get; set; }

        /// <summary>
        /// å ç”¨è´§ä½æ•°
        /// </summary>
        [SugarColumn(IsNullable = false, ColumnDescription = "占用货位数")]
        public int LocaitonCount { get; set; }

        /// <summary>
        /// å¤§æ‰˜ç›˜æ˜¯å¦æ”¾å¥‡æ•°åˆ—
        /// </summary>
        [SugarColumn(IsNullable = false, ColumnDescription = "大托盘是否放奇数列")]
        public bool IsOdd {  get; set; }
    }
}

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

@@ -13,6 +13,7 @@
    /// <summary>
    /// 
    /// </summary>
    [SugarTable(nameof(Dt_MesOutboundOrder))]
    public class Dt_MesOutboundOrder : BaseEntity
    {
        /// <summary>
@@ -83,6 +84,12 @@
        public float OrderQuantity { get; set; }

        /// <summary>
        /// é”å®šæ•°é‡
        /// </summary>
        [SugarColumn(IsNullable = false, ColumnDescription = "锁定数量", DefaultValue = "0")]
        public float LockQuantity { get; set; }

        /// <summary>
        /// å·²å‡ºæ•°é‡
        /// </summary>
        [SugarColumn(IsNullable = false, ColumnDescription = "已出数量", DefaultValue = "0")]

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

@@ -16,55 +16,128 @@
using WIDESEA_IBasicRepository;
using WIDESEA_Common.WareHouseEnum;
using WIDESEA_Core;
using WIDESEA_IStockService;
using WIDESEA_IBasicService;
using WIDESEA_Common.LocationEnum;
using WIDESEA_IRecordService;

namespace WIDESEA_OutboundService
{
    public class MesOutboundOrderService : ServiceBase<Dt_MesOutboundOrder, IMesOutboundOrderRepository>, IMesOutboundOrderService
    {
        private readonly IBasicRepository _basicRepository;
        private readonly IStockService _stockService;
        private readonly IOutStockLockInfoService _outStockLockInfoService;
        private readonly IBasicService _basicService;
        private readonly IRecordService _recordService;

        public MesOutboundOrderService(IMesOutboundOrderRepository BaseDal, IBasicRepository basicRepository) : base(BaseDal)
        public IMesOutboundOrderRepository Repository => BaseDal;

        public MesOutboundOrderService(IMesOutboundOrderRepository BaseDal, IBasicRepository basicRepository, IStockService stockService, IOutStockLockInfoService outStockLockInfoService, IBasicService basicService, IRecordService recordService) : base(BaseDal)
        {
            _basicRepository = basicRepository;
            _stockService = stockService;
            _outStockLockInfoService = outStockLockInfoService;
            _basicService = basicService;
            _recordService = recordService;
        }

        public MesResponseContent SubstrateOut(SubstrateOutModel model)
        /// <summary>
        /// 
        /// </summary>
        /// <param name="mesOutboundOrder"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public (List<Dt_StockInfo>, Dt_MesOutboundOrder, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_MesOutboundOrder mesOutboundOrder)
        {
            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 = mesOutboundOrder.OrderQuantity;

            float needQuantity = originalNeedQuantity;

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

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

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

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

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

        public WebResponseContent LockOutboundStockDataUpdate(List<Dt_StockInfo> stockInfos, List<Dt_OutStockLockInfo> outStockLockInfos, List<Dt_LocationInfo> locationInfos, LocationStatusEnum locationStatus = LocationStatusEnum.Lock, List<Dt_Task>? tasks = null)
        {
            try
            {
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseCode == WarehouseEnum.HA57.ToString());
                if (warehouse == null)
                _stockService.StockInfoService.Repository.UpdateData(stockInfos);
                List<Dt_StockInfoDetail> stockInfoDetails = new List<Dt_StockInfoDetail>();
                foreach (var item in stockInfos)
                {
                    return MesResponseContent.Instance.Error($"仓库基础信息未配置");
                    stockInfoDetails.AddRange(item.Details);
                }
                _stockService.StockInfoDetailService.Repository.UpdateData(stockInfoDetails);

                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);
                }

                Dt_MaterielInfo materielInfo = _basicRepository.MaterielInfoRepository.QueryFirst(x => x.MaterielCode == model.MaterialCode);
                if (materielInfo == null)
                {
                    return MesResponseContent.Instance.Error($"未找到该物料信息");
                }

                Dt_MesOutboundOrder mesOutboundOrder = new Dt_MesOutboundOrder()
                {
                    CreateType = OrderCreateTypeEnum.UpperSystemPush.ObjToInt(),
                    Line = model.Line,
                    MaterialCode = model.MaterialCode,
                    MaterialName = model.MaterialName,
                    OrderQuantity = model.RequiredQuantity,
                    TaskNo = model.TaskNo,
                    Unit = model.Unit,
                    OrderType = MesOutboundOrderTypeEnum.SubstrateOut.ObjToInt(),
                    OrderStatus = OutOrderStatusEnum.未开始.ObjToInt(),
                    WarehouseId = warehouse.WarehouseId
                };

                BaseDal.AddData(mesOutboundOrder);

                return MesResponseContent.Instance.OK();
                _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 MesResponseContent.Instance.Error(ex.Message);
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
    }

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

@@ -83,6 +83,30 @@
            return outStockLockInfo;
        }

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

            Dt_OutStockLockInfo outStockLockInfo = new Dt_OutStockLockInfo()
            {
                PalletCode = outStock.PalletCode,
                AssignQuantity = assignQuantity,
                MaterielCode = mesOutboundOrder.MaterialCode,
                BatchNo = outStock.Details.FirstOrDefault()?.BatchNo ?? "",
                LocationCode = outStock.LocationCode,
                MaterielName = mesOutboundOrder.MaterialName,
                OrderDetailId = mesOutboundOrder.Id,
                OrderNo = mesOutboundOrder.OrderNo,
                OrderType = mesOutboundOrder.OrderType,
                OriginalQuantity = outStock.Details.Where(x => x.MaterielCode == mesOutboundOrder.MaterialCode).Sum(x => x.StockQuantity),
                Status = taskNum == null ? OutLockStockStatusEnum.已分配.ObjToInt() : OutLockStockStatusEnum.出库中.ObjToInt(),
                StockId = outStock.Id,
                TaskNum = taskNum,
                OrderQuantity = mesOutboundOrder.OrderQuantity
            };

            return outStockLockInfo;
        }

        public List<Dt_OutStockLockInfo> GetByOrderDetailId(int orderDetailId, OutLockStockStatusEnum outStockStatus)
        {
            return BaseDal.QueryData(x => x.OrderDetailId == orderDetailId && x.Status == outStockStatus.ObjToInt());
@@ -104,7 +128,7 @@
                {
                    throw new Exception($"未找到库存详情");
                }
                List<Dt_OutStockLockInfo> stockLockInfos = BaseDal.QueryData(x => x.StockId == stockInfo.Id&&x.Status< OutLockStockStatusEnum.出库完成.ObjToInt());
                List<Dt_OutStockLockInfo> stockLockInfos = BaseDal.QueryData(x => x.StockId == stockInfo.Id && x.Status < OutLockStockStatusEnum.出库完成.ObjToInt());
                return stockLockInfos;
            }
            catch (Exception ex)

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

@@ -283,8 +283,6 @@
                locationInfos.AddRange(_basicService.LocationInfoService.Repository.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList()));
            }



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

@@ -399,14 +397,14 @@
                List<Dt_OutStockLockInfo> addOutStockLockInfos = outStockLockInfos.Where(x => x.Id == 0).ToList();
                if (addOutStockLockInfos != null && addOutStockLockInfos.Any())
                {
                    if(tasks != null)
                    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();

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_StockRepository/StockRepository.cs

@@ -13,10 +13,16 @@

        public IStockInfoRepository StockInfoRepository { get; }

        public StockRepository(IStockInfoDetailRepository stockInfoDetailRepository, IStockInfoRepository stockInfoRepository)
        public IStockInfoDetail_HtyRepository StockInfoDetail_HtyRepository { get; }

        public IStockInfo_HtyRepository StockInfo_HtyRepository { get; }

        public StockRepository(IStockInfoDetailRepository stockInfoDetailRepository, IStockInfoRepository stockInfoRepository, IStockInfoDetail_HtyRepository stockInfoDetail_HtyRepository,IStockInfo_HtyRepository stockInfo_HtyRepository)
        {
            StockInfoDetailRepository = stockInfoDetailRepository;
            StockInfoRepository = stockInfoRepository;
            StockInfoDetail_HtyRepository = stockInfoDetail_HtyRepository;
            StockInfo_HtyRepository = stockInfo_HtyRepository;
        }
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoRepository/TaskRepository.cs

@@ -34,9 +34,13 @@
        {
        }

        static object lock_taskNum = new object();
        public int GetTaskNum(string sequenceName)
        {
            return Db.Ado.GetScalar($"SELECT NEXT VALUE FOR {sequenceName}").ObjToInt();
            lock (lock_taskNum)
            {
                return Db.Ado.GetScalar($"SELECT NEXT VALUE FOR {sequenceName}").ObjToInt();
            }
        }

        public override int AddData(Dt_Task entity)

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

@@ -23,6 +23,7 @@
using WIDESEA_ITaskInfoRepository;
using WIDESEA_ITaskInfoService;
using WIDESEA_Model.Models;
using WIDESEA_Common.OrderEnum;

namespace WIDESEA_TaskInfoService
{
@@ -43,7 +44,7 @@
                try
                {
                    Dt_Task exsit = Repository.QueryFirst(x => x.TargetAddress == model.TargetAddressCode);
                    if(exsit != null)
                    if (exsit != null)
                    {
                        return responseContent.Error($"目标地址重复");
                    }
@@ -96,7 +97,7 @@
                    //更新库存状态
                    _stockRepository.StockInfoRepository.UpdateData(stockInfo);
                    //更新货位状态
                    _basicService.LocationInfoService.UpdateLocationStatus(locationInfo, (PalletTypeEnum)stockInfo.PalletType, LocationStatusEnum.Lock, stockInfo.WarehouseId);
                    _basicService.LocationInfoService.UpdateLocationStatus(locationInfo, stockInfo.PalletType, LocationStatusEnum.Lock, stockInfo.WarehouseId);
                    //新建任务
                    BaseDal.AddData(taskOut);
                    //加入货位变动记录
@@ -195,7 +196,7 @@
                //清除库存信息
                _unitOfWorkManage.BeginTran();
                _stockRepository.StockInfoRepository.DeleteAndMoveIntoHty(stockInfoUpdates, OperateTypeEnum.自动删除);
                _stockService.StockInfoDetailService.Repository.DeleteAndMoveIntoHty(stockInfoDetails,OperateTypeEnum.自动删除);
                _stockService.StockInfoDetailService.Repository.DeleteAndMoveIntoHty(stockInfoDetails, OperateTypeEnum.自动删除);
                _unitOfWorkManage.CommitTran();
                responseContent.OK($"报废成功");
            }
@@ -247,5 +248,243 @@
            return content;
        }

        /// <summary>
        /// ç‰©æ–™å‡ºåº“，WMS同步出库物料批次至MES
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public WebResponseContent UploadMesMaterialLotaAcept(MesMaterialLotaAceptModel model)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_ApiInfo apiInfo = _apiInfoRepository.QueryFirst(x => x.ApiCode == APIEnum.WMS_MES_TestToolSync.ToString());
                MESRoot<MesMaterialLotaAceptModel> root = new MESRoot<MesMaterialLotaAceptModel>()
                {
                    From = "WMS",
                    DateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                    Content = model
                };
                JsonSerializerSettings settings = new JsonSerializerSettings
                {
                    ContractResolver = new CamelCasePropertyNamesContractResolver()
                };
                string request = JsonConvert.SerializeObject(root, settings);
                string response = HttpMesHelper.Post(apiInfo.ApiAddress, request);
                MesResponseContent mesResponseContent = response.DeserializeObject<MesResponseContent>();
                //调用接口
                if (mesResponseContent.BSucc == true)
                {
                    content.OK(mesResponseContent.StrMsg);
                }
                else
                {
                    content.Error(mesResponseContent.StrMsg);
                }
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="stockInfo"></param>
        /// <param name="stockInfoDetail"></param>
        /// <param name="taskNo"></param>
        /// <param name="warehouseCode"></param>
        /// <param name="quantity"></param>
        /// <param name="cutedType"></param>
        /// <param name="ppWidth"></param>
        /// <returns></returns>
        public MesMaterialLotaAceptModel GetMesMaterialLotaAceptModel(Dt_StockInfo stockInfo, Dt_StockInfoDetail stockInfoDetail, string taskNo, string warehouseCode, float quantity, string cutedType = "", float ppWidth = 0)
        {
            MesMaterialLotaAceptModel model = new MesMaterialLotaAceptModel()
            {
                CarrierCode = stockInfo.PalletCode,
                CutedType = cutedType,
                ExpirationDate = stockInfoDetail.EffectiveDate,
                MaterialBarCode = stockInfoDetail.SerialNumber,
                MaterialCode = stockInfoDetail.MaterielCode,
                MaterialLot = stockInfoDetail.MaterielCode + "," + stockInfoDetail.BatchNo,
                MaterialName = stockInfoDetail.MaterielName,
                PPWidth = ppWidth,
                ProductionDate = stockInfoDetail.ProductionDate,
                Quantity = quantity,
                Supplier = "",
                TaskNo = taskNo,
                Type = 1,
                WarehouseArea = warehouseCode,
                WarehouseLocation = warehouseCode
            };

            return model;
        }

        /// <summary>
        /// åŸºæ¿å‡ºåº“
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public MesResponseContent SubstrateOut(SubstrateOutModel model)
        {
            try
            {
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseCode == WarehouseEnum.HA57.ToString());
                if (warehouse == null)
                {
                    return MesResponseContent.Instance.Error($"仓库基础信息未配置");
                }

                Dt_MaterielInfo materielInfo = _basicRepository.MaterielInfoRepository.QueryFirst(x => x.MaterielCode == model.MaterialCode);
                if (materielInfo == null)
                {
                    return MesResponseContent.Instance.Error($"未找到该物料信息");
                }

                Dt_MesOutboundOrder mesOutboundOrder = new Dt_MesOutboundOrder()
                {
                    CreateType = OrderCreateTypeEnum.UpperSystemPush.ObjToInt(),
                    Line = model.Line,
                    MaterialCode = model.MaterialCode,
                    MaterialName = model.MaterialName,
                    OrderQuantity = model.RequiredQuantity,
                    TaskNo = model.TaskNo,
                    Unit = model.Unit,
                    OrderType = MesOutboundOrderTypeEnum.SubstrateOut.ObjToInt(),
                    OrderStatus = OutOrderStatusEnum.未开始.ObjToInt(),
                    WarehouseId = warehouse.WarehouseId
                };

                List<Dt_Task> tasks = new List<Dt_Task>();

                List<Dt_StockInfo>? stockInfos = null;
                List<Dt_OutStockLockInfo>? outStockLockInfos = null;
                List<Dt_LocationInfo>? locationInfos = null;
                {
                    (List<Dt_StockInfo>, Dt_MesOutboundOrder, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) result = _outboundService.MesOutboundOrderService.AssignStockOutbound(mesOutboundOrder);
                    if (result.Item1 != null && result.Item1.Count > 0)
                    {
                        tasks = GetTasks(result.Item1, TaskTypeEnum.MesOutbound);
                        result.Item2.OrderStatus = OrderDetailStatusEnum.Outbound.ObjToInt();
                        result.Item3.ForEach(x =>
                        {
                            x.Status = OutLockStockStatusEnum.出库中.ObjToInt();
                        });

                        stockInfos = result.Item1;
                        mesOutboundOrder = result.Item2;
                        outStockLockInfos = result.Item3;
                        locationInfos = result.Item4;
                    }
                    else
                    {
                        throw new Exception("无库存");
                    }
                }
                _unitOfWorkManage.BeginTran();

                int id = BaseDal.AddData(tasks);
                outStockLockInfos.ForEach(x =>
                {
                    x.OrderNo = mesOutboundOrder.TaskNo;
                    x.OrderDetailId = id;
                });
                _outboundService.MesOutboundOrderService.Repository.AddData(mesOutboundOrder);
                if (stockInfos != null && stockInfos.Count > 0 && outStockLockInfos != null && outStockLockInfos.Count > 0 && locationInfos != null && locationInfos.Count > 0)
                {
                    WebResponseContent content = _outboundService.MesOutboundOrderService.LockOutboundStockDataUpdate(stockInfos, outStockLockInfos, locationInfos, tasks: tasks);

                    if (!content.Status)
                    {
                        _unitOfWorkManage.RollbackTran();
                        return MesResponseContent.Instance.Error(content.Message);
                    }
                }
                _unitOfWorkManage.CommitTran();
                PushTasksToWCS(tasks);


                return MesResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                return MesResponseContent.Instance.Error(ex.Message);
            }
        }

        /// <summary>
        /// åŸºæ¿ä½™æ–™é€€åº“
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public MesResponseContent SubstrateBack(SubstrateBackModel model)
        {
            try
            {
                Dt_PalletTypeInfo palletTypeInfo = _palletTypeInfoRepository.QueryFirst(x => model.CarrierCode.Contains(x.CodeStartStr));
                if (palletTypeInfo == null)
                {
                    return MesResponseContent.Instance.Error($"未识别该托盘类型，请确认托盘号");
                }

                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x=>x.WarehouseCode == WarehouseEnum.HA57.ToString());

                Dt_StockInfo stockInfo = new Dt_StockInfo()
                {
                    PalletCode = model.CarrierCode,
                    PalletType = palletTypeInfo.PalletType,
                    WarehouseId = warehouse.WarehouseId,
                    StockStatus = StockStatusEmun.组盘暂存.ObjToInt()
                };

                Dt_StockInfoDetail_Hty stockInfoDetail_Hty = _stockRepository.StockInfoDetail_HtyRepository.QueryFirst(x => x.BatchNo == model.MaterialLot && x.MaterielCode == model.MaterialCode);

                Dt_StockInfoDetail stockInfoDetail = new Dt_StockInfoDetail()
                {
                    BatchNo = stockInfoDetail_Hty?.BatchNo ?? "",
                    EffectiveDate = model.ExpirationDate,
                    MaterielCode = model.MaterialCode,
                    InboundOrderRowNo = stockInfoDetail_Hty?.InboundOrderRowNo ?? 0,
                    MaterielName = model.MaterialCode,
                    ProductionDate = model.ProductionDate,
                    OrderNo = stockInfoDetail_Hty?.OrderNo ?? "",
                    OutboundQuantity = 0,
                    SerialNumber = stockInfoDetail_Hty?.SerialNumber ?? "0",
                    StockQuantity = model.Quantity,
                    Status = StockStatusEmun.组盘暂存.ObjToInt(),
                    Unit = model.Unit
                };

                Dt_Task task = new Dt_Task()
                {
                    PalletCode = stockInfo.PalletCode,
                    CurrentAddress = "",
                    NextAddress = "",
                    PalletType = stockInfo.PalletType,
                    Roadway = "",
                    SourceAddress = "",
                    TargetAddress = "",
                    TaskStatus = TaskStatusEnum.New.ObjToInt(),
                    TaskType = TaskTypeEnum.MesMatReturn.ObjToInt(),
                    WarehouseId = warehouse.WarehouseId
                };

                _unitOfWorkManage.BeginTran();
                Db.InsertNav(stockInfo).Include(x => x.Details).ExecuteCommand();
                BaseDal.AddData(task);
                _unitOfWorkManage.CommitTran();

                return MesResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return MesResponseContent.Instance.Error(ex.Message);
            }
        }
    }
}

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

@@ -67,6 +67,7 @@
        private readonly IInvokeERPService _invokeERPService;
        private readonly IInboundRepository _inboundRepository;
        private readonly IInboundOrderService _inboundOrderService;
        private readonly IPalletTypeInfoRepository _palletTypeInfoRepository;

        public ITaskRepository Repository => BaseDal;

@@ -80,7 +81,7 @@

        public List<int> TaskOutboundTypes => typeof(TaskTypeEnum).GetEnumIndexList();

        public TaskService(ITaskRepository BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IStockRepository stockRepository, IBasicService basicService, IRecordService recordService, IOutboundService outboundService, IStockService stockService, IBasicRepository basicRepository, IApiInfoRepository apiInfoRepository, IInvokeERPService invokeERPService, IInboundRepository inboundRepository, IInboundOrderService inboundOrderService) : base(BaseDal)
        public TaskService(ITaskRepository BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IStockRepository stockRepository, IBasicService basicService, IRecordService recordService, IOutboundService outboundService, IStockService stockService, IBasicRepository basicRepository, IApiInfoRepository apiInfoRepository, IInvokeERPService invokeERPService, IInboundRepository inboundRepository, IInboundOrderService inboundOrderService, IPalletTypeInfoRepository palletTypeInfoRepository) : base(BaseDal)
        {
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
@@ -94,6 +95,7 @@
            _invokeERPService = invokeERPService;
            _inboundRepository = inboundRepository;
            _inboundOrderService = inboundOrderService;
            _palletTypeInfoRepository = palletTypeInfoRepository;
        }

        /// <summary>
@@ -246,7 +248,7 @@
                task.TaskStatus = (int)TaskStatusEnum.Finish;
                _unitOfWorkManage.BeginTran();
                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId > 0 ? OperateTypeEnum.人工完成 : OperateTypeEnum.自动完成);
                _basicService.LocationInfoService.UpdateLocationStatus(locationInfo, (PalletTypeEnum)stockInfo.PalletType, LocationStatusEnum.InStock, stockInfo.WarehouseId);
                _basicService.LocationInfoService.UpdateLocationStatus(locationInfo, stockInfo.PalletType, LocationStatusEnum.InStock, stockInfo.WarehouseId);
                _stockRepository.StockInfoRepository.UpdateData(stockInfo);
                _stockRepository.StockInfoDetailRepository.UpdateData(stockInfo.Details);
                _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfo, lastStatus, LocationStatusEnum.InStock, LocationChangeType.InboundCompleted);
@@ -295,6 +297,7 @@
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseId == task.WarehouseId);
                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>();

                if ((outStockLockInfos == null || outStockLockInfos.Count == 0) && warehouse.WarehouseCode != WarehouseEnum.HA64.ToString())
                {
@@ -304,39 +307,77 @@
                {
                    foreach (var item in outStockLockInfos)
                    {
                        Dt_OutboundOrderDetail outboundOrderDetail = _outboundService.OutboundOrderDetailService.Repository.QueryFirst(x => x.Id == item.OrderDetailId);
                        if (outboundOrderDetail != null)
                        if (task.TaskType == TaskTypeEnum.MesOutbound.ObjToInt())
                        {
                            outboundOrderDetail.OverOutQuantity = item.AssignQuantity;
                            if (outboundOrderDetail.OverOutQuantity == outboundOrderDetail.OrderQuantity)
                            Dt_MesOutboundOrder mesOutboundOrder = _outboundService.MesOutboundOrderService.Repository.QueryFirst(x => x.Id == item.OrderDetailId);
                            if (mesOutboundOrder != null)
                            {
                                outboundOrderDetail.OrderDetailStatus = OrderDetailStatusEnum.Over.ObjToInt();
                                mesOutboundOrder.OverOutQuantity = item.AssignQuantity;
                                if (mesOutboundOrder.OverOutQuantity == mesOutboundOrder.OrderQuantity)
                                {
                                    mesOutboundOrder.OrderStatus = OrderDetailStatusEnum.Over.ObjToInt();
                                }
                                mesOutboundOrders.Add(mesOutboundOrder);
                            }
                            outboundOrderDetails.Add(outboundOrderDetail);
                        }
                        else
                        {
                            Dt_OutboundOrderDetail outboundOrderDetail = _outboundService.OutboundOrderDetailService.Repository.QueryFirst(x => x.Id == item.OrderDetailId);
                            if (outboundOrderDetail != null)
                            {
                                outboundOrderDetail.OverOutQuantity = item.AssignQuantity;
                                if (outboundOrderDetail.OverOutQuantity == outboundOrderDetail.OrderQuantity)
                                {
                                    outboundOrderDetail.OrderDetailStatus = OrderDetailStatusEnum.Over.ObjToInt();
                                }
                                outboundOrderDetails.Add(outboundOrderDetail);
                            }
                        }
                        item.Status = OutLockStockStatusEnum.出库完成.ObjToInt();
                    }
                }

                task.TaskStatus = TaskStatusEnum.Finish.ObjToInt();
                _unitOfWorkManage.BeginTran();
                if (outboundOrderDetails.Count > 0)

                if (task.TaskType == TaskTypeEnum.Outbound.ObjToInt())
                {
                    _outboundService.OutboundOrderDetailService.Repository.UpdateData(outboundOrderDetails);
                    if (outboundOrderDetails.Count > 0)
                    {
                        _outboundService.OutboundOrderDetailService.Repository.UpdateData(outboundOrderDetails);
                    }

                    stockInfo.LocationCode = "";
                    stockInfo.StockStatus = StockStatusEmun.出库完成.ObjToInt();
                    _stockService.StockInfoService.Repository.UpdateData(stockInfo);
                }
                stockInfo.LocationCode = "";
                stockInfo.StockStatus = StockStatusEmun.出库完成.ObjToInt();
                _stockService.StockInfoService.Repository.UpdateData(stockInfo);
                else if (task.TaskType == TaskTypeEnum.MesOutbound.ObjToInt())
                {
                    _outboundService.MesOutboundOrderService.Repository.UpdateData(mesOutboundOrders);
                    _stockService.StockInfoService.Repository.DeleteAndMoveIntoHty(stockInfo, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                    _stockService.StockInfoDetailService.Repository.DeleteAndMoveIntoHty(stockInfo.Details, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                }
                _outboundService.OutboundStockLockInfoService.Repository.UpdateData(outStockLockInfos);

                int beforeStatus = locationInfo.LocationStatus;
                locationInfo.LocationStatus = LocationStatusEnum.Free.ObjToInt();
                _basicService.LocationInfoService.UpdateLocationStatus(locationInfo, (PalletTypeEnum)stockInfo.PalletType, LocationStatusEnum.Free, stockInfo.WarehouseId);
                _basicService.LocationInfoService.UpdateLocationStatus(locationInfo, stockInfo.PalletType, LocationStatusEnum.Free, stockInfo.WarehouseId);

                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);

                _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfo, (LocationStatusEnum)beforeStatus, LocationStatusEnum.Free, LocationChangeType.OutboundCompleted, stockInfo.Details.FirstOrDefault()?.OrderNo ?? "", task.TaskNum);
                _unitOfWorkManage.CommitTran();
                if (warehouse.WarehouseCode != WarehouseEnum.HA64.ToString())

                if (warehouse.WarehouseCode != WarehouseEnum.HA64.ToString() && task.TaskType == TaskTypeEnum.Outbound.ObjToInt())
                {
                    _outboundService.OutboundOrderService.TestOutUpload(outboundOrderDetails.FirstOrDefault().Id, outStockLockInfos);
                }
                if (task.TaskType == TaskTypeEnum.MesOutbound.ObjToInt())
                {
                    MesMaterialLotaAceptModel model = GetMesMaterialLotaAceptModel(stockInfo, stockInfo.Details.FirstOrDefault(), mesOutboundOrders.FirstOrDefault().TaskNo, warehouse.WarehouseCode, mesOutboundOrders.FirstOrDefault().OrderQuantity);

                    UploadMesMaterialLotaAcept(model);
                }
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)

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

@@ -139,7 +139,7 @@
                    return WebResponseContent.Instance.Error($"该托盘已绑定货位");
                }

                Dt_LocationInfo? locationInfo = _basicService.LocationInfoService.AssignLocation(roadwayNo, (PalletTypeEnum)stockInfo.PalletType, stockInfo.WarehouseId);
                Dt_LocationInfo? locationInfo = _basicService.LocationInfoService.AssignLocation(roadwayNo, stockInfo.PalletType, stockInfo.WarehouseId);
                if (locationInfo == null)
                {
                    return WebResponseContent.Instance.Error($"货位分配失败,未找到可分配货位");
@@ -171,7 +171,7 @@
                LocationStatusEnum lastStatus = (LocationStatusEnum)locationInfo.LocationStatus;
                _unitOfWorkManage.BeginTran();
                _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfo, lastStatus, LocationStatusEnum.Lock, LocationChangeType.InboundAssignLocation);
                _basicService.LocationInfoService.UpdateLocationStatus(locationInfo, (PalletTypeEnum)newTask.PalletType, LocationStatusEnum.Lock, newTask.WarehouseId);
                _basicService.LocationInfoService.UpdateLocationStatus(locationInfo, newTask.PalletType, LocationStatusEnum.Lock, newTask.WarehouseId);
                int taskId = BaseDal.AddData(newTask);
                newTask.TaskId = taskId;
                _stockRepository.StockInfoRepository.UpdateData(stockInfo);
@@ -209,7 +209,7 @@
                    return WebResponseContent.Instance.OK(data: task.TargetAddress);
                }

                Dt_LocationInfo? locationInfo = _basicService.LocationInfoService.AssignLocation(roadwayNo, (PalletTypeEnum)task.PalletType, task.WarehouseId);
                Dt_LocationInfo? locationInfo = _basicService.LocationInfoService.AssignLocation(roadwayNo, task.PalletType, task.WarehouseId);
                if (locationInfo == null)
                {
                    return WebResponseContent.Instance.Error($"货位分配失败,未找到可分配货位");
@@ -223,7 +223,7 @@

                _unitOfWorkManage.BeginTran();
                _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(locationInfo, lastStatus, LocationStatusEnum.Lock, LocationChangeType.InboundAssignLocation);
                _basicService.LocationInfoService.UpdateLocationStatus(locationInfo, (PalletTypeEnum)task.PalletType, LocationStatusEnum.Lock, task.WarehouseId);
                _basicService.LocationInfoService.UpdateLocationStatus(locationInfo, task.PalletType, LocationStatusEnum.Lock, task.WarehouseId);
                BaseDal.UpdateData(task);
                _unitOfWorkManage.CommitTran();
                return WebResponseContent.Instance.OK(data: locationInfo.LocationCode);

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

@@ -38,7 +38,7 @@
                Dt_LocationInfo locationInfo = _basicRepository.LocationInfoRepository.QueryFirst(x => x.LocationCode == stockInfo.LocationCode);
                if (locationInfo!=null && (locationInfo.EnableStatus == EnableStatusEnum.OnlyOut.ObjToInt() || locationInfo.EnableStatus == EnableStatusEnum.Normal.ObjToInt()) && locationInfo.LocationStatus==LocationStatusEnum.InStock.ObjToInt() && stockInfo.StockStatus==StockStatusEmun.入库完成.ObjToInt())
                {
                    List<Dt_Task> tasks = GetTasks(new List<Dt_StockInfo>() { stockInfo });
                    List<Dt_Task> tasks = GetTasks(new List<Dt_StockInfo>() { stockInfo }, TaskTypeEnum.Outbound);
                    if (tasks == null || tasks.Count <= 0)
                    {
                        return content.Error($"生成任务失败");
@@ -52,7 +52,7 @@
                    //更新库存状态
                    _stockRepository.StockInfoRepository.UpdateData(stockInfo);
                    //更新货位状态
                    _basicService.LocationInfoService.UpdateLocationStatus(locationInfo, (PalletTypeEnum)stockInfo.PalletType, LocationStatusEnum.Lock, stockInfo.WarehouseId);
                    _basicService.LocationInfoService.UpdateLocationStatus(locationInfo, stockInfo.PalletType, LocationStatusEnum.Lock, stockInfo.WarehouseId);
                    //新建任务
                    BaseDal.AddData(tasks);
                    //加入货位变动记录
@@ -77,7 +77,7 @@
        /// </summary>
        /// <param name="stockInfos"></param>
        /// <returns></returns>
        public List<Dt_Task> GetTasks(List<Dt_StockInfo> stockInfos)
        public List<Dt_Task> GetTasks(List<Dt_StockInfo> stockInfos, TaskTypeEnum taskType)
        {
            List<Dt_Task> tasks = new List<Dt_Task>();
            for (int i = 0; i < stockInfos.Count; i++)
@@ -99,7 +99,7 @@
                            SourceAddress = stockInfo.LocationCode,
                            TargetAddress = "",
                            TaskStatus = TaskStatusEnum.New.ObjToInt(),
                            TaskType = TaskTypeEnum.Outbound.ObjToInt(),
                            TaskType = taskType.ObjToInt(),
                            TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
                            PalletType = stockInfo.PalletType,
                            WarehouseId = stockInfo.WarehouseId,
@@ -141,7 +141,7 @@
                (List<Dt_StockInfo>, Dt_OutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) result = _outboundService.OutboundOrderDetailService.AssignStockOutbound(outboundOrderDetail, stockSelectViews);
                if (result.Item1 != null && result.Item1.Count > 0)
                {
                    tasks = GetTasks(result.Item1);
                    tasks = GetTasks(result.Item1, TaskTypeEnum.Outbound);
                    result.Item2.OrderDetailStatus = OrderDetailStatusEnum.Outbound.ObjToInt();
                    result.Item3.ForEach(x =>
                    {
@@ -164,7 +164,7 @@
                if (stockLockInfos != null && stockLockInfos.Count > 0)
                {
                    List<Dt_StockInfo> stocks = _stockService.StockInfoService.Repository.GetStockInfosByPalletCodes(stockLockInfos.Select(x => x.PalletCode).Distinct().ToList());
                    tasks = GetTasks(stocks);
                    tasks = GetTasks(stocks, TaskTypeEnum.Outbound);
                }
            }

@@ -197,7 +197,7 @@
                (List<Dt_StockInfo>, List<Dt_OutboundOrderDetail>, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) result = _outboundService.OutboundOrderDetailService.AssignStockOutbound(outboundOrderDetails);
                if (result.Item1 != null && result.Item1.Count > 0)
                {
                    tasks = GetTasks(result.Item1);
                    tasks = GetTasks(result.Item1, TaskTypeEnum.Outbound);
                    result.Item2.ForEach(x =>
                    {
                        x.OrderDetailStatus = OrderDetailStatusEnum.Outbound.ObjToInt();

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

@@ -61,7 +61,7 @@
                        return WebResponseContent.Instance.OK(data: _mapper.Map<WMSTaskDTO>(taskTemp));
                    }

                    Dt_LocationInfo? newLocation = _basicService.LocationInfoService.AssignLocation(needRelocationItem.RoadwayNo, (PalletTypeEnum)task.PalletType, task.WarehouseId);
                    Dt_LocationInfo? newLocation = _basicService.LocationInfoService.AssignLocation(needRelocationItem.RoadwayNo, task.PalletType, task.WarehouseId);
                    if (newLocation != null)
                    {
                        Dt_Task newTask = new Dt_Task()
@@ -85,12 +85,12 @@
                        Repository.AddData(newTask);
                        {
                            LocationStatusEnum lastStatus = (LocationStatusEnum)newLocation.LocationStatus;
                            _basicService.LocationInfoService.UpdateLocationStatus(newLocation, (PalletTypeEnum)task.PalletType, LocationStatusEnum.Lock, stockInfo.WarehouseId);
                            _basicService.LocationInfoService.UpdateLocationStatus(newLocation, task.PalletType, LocationStatusEnum.Lock, stockInfo.WarehouseId);
                            _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(newLocation, lastStatus, LocationStatusEnum.Lock, LocationChangeType.RelocationAssignLocation, taskNum: newTask.TaskNum);
                        }
                        {
                            LocationStatusEnum lastStatus = (LocationStatusEnum)needRelocationItem.LocationStatus;
                            _basicService.LocationInfoService.UpdateLocationStatus(needRelocationItem, (PalletTypeEnum)task.PalletType, LocationStatusEnum.Lock, stockInfo.WarehouseId);
                            _basicService.LocationInfoService.UpdateLocationStatus(needRelocationItem, task.PalletType, LocationStatusEnum.Lock, stockInfo.WarehouseId);
                            _recordService.LocationStatusChangeRecordSetvice.AddLocationStatusChangeRecord(needRelocationItem, lastStatus, LocationStatusEnum.Lock, LocationChangeType.RelocationAssignLocation, taskNum: newTask.TaskNum);
                        }
                        stockInfo.StockStatus = StockStatusEmun.移库锁定.ObjToInt();
@@ -138,8 +138,8 @@
                _unitOfWorkManage.BeginTran();
                stockInfo.LocationCode = locationInfoEnd.LocationCode;
                _stockService.StockInfoService.Repository.UpdateData(stockInfo);
                _basicService.LocationInfoService.UpdateLocationStatus(locationInfoStart, (PalletTypeEnum)stockInfo.PalletType, LocationStatusEnum.Free, stockInfo.WarehouseId);
                _basicService.LocationInfoService.UpdateLocationStatus(locationInfoEnd, (PalletTypeEnum)stockInfo.PalletType, LocationStatusEnum.InStock, stockInfo.WarehouseId);
                _basicService.LocationInfoService.UpdateLocationStatus(locationInfoStart, stockInfo.PalletType, LocationStatusEnum.Free, stockInfo.WarehouseId);
                _basicService.LocationInfoService.UpdateLocationStatus(locationInfoEnd, stockInfo.PalletType, LocationStatusEnum.InStock, stockInfo.WarehouseId);
                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId > 0 ? WIDESEA_Core.Enums.OperateTypeEnum.人工完成 : WIDESEA_Core.Enums.OperateTypeEnum.自动完成);
                _unitOfWorkManage.CommitTran();
                return WebResponseContent.Instance.OK();

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Controllers/Basic/LocationInfoController.cs

@@ -46,7 +46,7 @@
        /// <param name="palletType"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("AssignLocation"), AllowAnonymous]
        public Dt_LocationInfo? AssignLocation(string roadwayNo, PalletTypeEnum palletType, int warehouseId)
        public Dt_LocationInfo? AssignLocation(string roadwayNo, int palletType, int warehouseId)
        {
            return Service.AssignLocation(roadwayNo, palletType, warehouseId);
        }
@@ -74,7 +74,7 @@
        }

        [HttpPost, Route("UpdateLocationStatus"), AllowAnonymous]
        public WebResponseContent UpdateLocationStatus(string locationCode, PalletTypeEnum palletType, LocationStatusEnum locationStatus, int warehousId)
        public WebResponseContent UpdateLocationStatus(string locationCode, int palletType, LocationStatusEnum locationStatus, int warehousId)
        {
            try
            {

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

@@ -76,14 +76,35 @@
        }

        /// <summary>
        /// 
        /// åŸºæ¿å‡ºåº“
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost, Route("SubstrateOut"), AllowAnonymous]
        public MesResponseContent SubstrateOut([FromBody] Root<SubstrateOutModel> model)
        {
            return _outboundService.MesOutboundOrderService.SubstrateOut(model.Content);
            return _taskService.SubstrateOut(model.Content);
        }

        /// <summary>
        /// åŸºæ¿ä½™æ–™é€€åº“
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost, Route("SubstrateBack"), AllowAnonymous]
        public MesResponseContent SubstrateBack([FromBody] Root<SubstrateBackModel> model)
        {
            return _taskService.SubstrateBack(model.Content);
        }

        /// <summary>
        /// ç‰©æ–™å‡ºåº“，WMS同步出库物料批次至MES
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public WebResponseContent UploadMesMaterialLotaAcept([FromBody] MesMaterialLotaAceptModel model)
        {
            return _taskService.UploadMesMaterialLotaAcept(model);
        }
    }
}