1

hutongqing

2024-12-28 eee43c4cb7f9018688cd6da6a3611512f3e5c5c3

1

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/.vs/WIDESEAWCS_Server/FileContentIndex/e75f7da2-6ce6-4dbf-9778-711f44383902.vsidx

Binary files differ

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

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Common/TaskEnum/TaskEnumHelper.cs

@@ -20,11 +20,11 @@
        {
            if (taskType >= 500 && taskType < 900)
            {
                return TaskTypeGroup.OutbondGroup;
                return TaskTypeGroup.InboundGroup;
            }
            else if (taskType >= 100 && taskType < 500)
            {
                return TaskTypeGroup.InboundGroup;
                return TaskTypeGroup.OutbondGroup;
            }
            else if (taskType >= 900 && taskType < 1000)
            {

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_ITaskInfoService/ITaskService.cs

@@ -72,6 +72,8 @@
        /// <returns></returns>
        string? RequestAssignLocation(int taskNum, string roadwayNo);

        WebResponseContent TaskCompleted(int taskNum);

        /// <summary>
        /// æ ¹æ®è®¾å¤‡ç¼–号、任务类型分组(可选)按照优先级以及创建时间排序查询任务池新增的任务
        /// </summary>

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

@@ -27,6 +27,7 @@
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Common.APIEnum;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseServices;
@@ -38,6 +39,7 @@
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.Models;
using WIDESEAWCS_QuartzJob.Repository;
using WIDESEAWCS_QuartzJob.Service;
@@ -54,6 +56,7 @@
        private readonly ITaskExecuteDetailRepository _taskExecuteDetailRepository;
        private readonly IStationMangerRepository _stationMangerRepository;
        private readonly IRouterRepository _routerRepository;
        private List<Dt_ApiInfo> apiInfos;

        private Dictionary<string, OrderByType> _taskOrderBy = new()
            {
@@ -65,9 +68,9 @@

        public Dictionary<string, OrderByType> TaskOrderBy { get { return _taskOrderBy; } set { _taskOrderBy = value; } }

        public List<int> TaskInboundTypes => typeof(TaskTypeEnum).GetEnumIndexList().Where(x => x >= 100 && x < 500).ToList();
        public List<int> TaskInboundTypes => typeof(TaskTypeEnum).GetEnumIndexList().Where(x => x >= 500 && x < 900).ToList();

        public List<int> TaskOutboundTypes => typeof(TaskTypeEnum).GetEnumIndexList().Where(x => x >= 500 && x < 900).ToList();
        public List<int> TaskOutboundTypes => typeof(TaskTypeEnum).GetEnumIndexList().Where(x => x >= 100 && x < 500).ToList();

        public TaskService(ITaskRepository BaseDal, IMapper mapper, ICacheService cacheService, IRouterService routerService, ITaskExecuteDetailService taskExecuteDetailService, ITaskExecuteDetailRepository taskExecuteDetailRepository, IStationMangerRepository stationMangerRepository, IRouterRepository routerRepository) : base(BaseDal)
        {
@@ -85,6 +88,21 @@
                Warehouses = JsonConvert.DeserializeObject<List<Dt_Warehouse>>(cacheStr);
            }


            string? apiInfoStr = _cacheService.Get("apiInfos");
            if (!string.IsNullOrEmpty(apiInfoStr))
            {
                List<Dt_ApiInfo>? infos = JsonConvert.DeserializeObject<List<Dt_ApiInfo>>(apiInfoStr);
                if (infos == null || infos.Count == 0)
                {
                    apiInfos = new List<Dt_ApiInfo>();
                }
                else
                {
                    apiInfos = infos;
                }
            }

        }

        public WebResponseContent TaskCompleted(int taskNum)
@@ -94,10 +112,18 @@
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task != null)
                {

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

                return WebResponseContent.Instance.OK();
                string? url = apiInfos.FirstOrDefault(x => x.ApiCode == APIEnum.FeedBackWMSTaskCompleted.ToString())?.ApiAddress;
                if (string.IsNullOrEmpty(url))
                {
                    _taskExecuteDetailService.AddTaskExecuteDetail(taskNum, $"未找到WMS任务完成接口,请检查接口配置");
                    UpdateTaskExceptionMessage(taskNum, $"未找到WMS任务完成接口,请检查接口配置");
                    return WebResponseContent.Instance.Error($"{taskNum},未找到WMS任务完成接口,请检查接口配置");
                }
                string responseStr = HttpHelper.Get(url + "?taskNum=" + taskNum);
                WebResponseContent content = JsonConvert.DeserializeObject<WebResponseContent>(responseStr) ?? WebResponseContent.Instance.Error($"{taskNum},未接收到任务完成返回值");
                return content;
            }
            catch (Exception ex)
            {
@@ -141,7 +167,7 @@
                            return WebResponseContent.Instance.Error($"未找到站台配置信息");
                        }

                        List<Dt_Router> routers = _routerRepository.QueryData(x => x.InOutType == item.TaskType && (stationManger.StationDeviceCode == x.StartPosi || stationManger.StackerCraneCode == x.StartPosi));
                        List<Dt_Router> routers = _routerRepository.QueryData(x => x.InOutType == item.TaskType && (stationManger.StationCode == x.StartPosi || stationManger.StackerCraneCode == x.StartPosi));
                        if (routers.FirstOrDefault() == null)
                        {
                            return WebResponseContent.Instance.Error($"未找到路由配置信息");
@@ -150,6 +176,10 @@
                        if (routers.Count == 1)
                        {
                            task.NextAddress = router?.NextPosi ?? "";
                        }
                        else
                        {
                            task.NextAddress = "";
                        }
                    }
                    else
@@ -254,7 +284,7 @@
        public Dt_Task QueryStackerCraneTask(string deviceNo, string currentAddress = "")
        {
            if (string.IsNullOrEmpty(currentAddress))
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && x.TaskState == (int)TaskStatusEnum.New, TaskOrderBy);
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && x.TaskState == (int)TaskStatusEnum.SC_Execute, TaskOrderBy);
            else
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && x.CurrentAddress == currentAddress && x.TaskState == (int)TaskStatusEnum.SC_Execute, TaskOrderBy);
        }

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/ÓÍÄ«²Ö/CommonHoisterJob.cs

@@ -76,7 +76,7 @@
                            Dt_Task task = _taskRepository.QueryFirst(x => x.TaskState == TaskStatusEnum.New.ObjToInt() && string.IsNullOrEmpty(x.TargetAddress) && x.SourceAddress == deviceChildCode && _taskService.TaskInboundTypes.Contains(x.TaskType));
                            if (task != null)
                            {
                                Dt_StationManger? stationManger = stationMangers.FirstOrDefault(x => x.StationDeviceCode == deviceChildCode);
                                Dt_StationManger? stationManger = stationMangers.FirstOrDefault(x => x.StationCode == deviceChildCode);
                                if (stationManger == null)
                                {
                                    WriteInfo(hoister.DeviceName, $"未找到对应站台信息,设备编号:{deviceChildCode},任务号:{task.TaskNum}");
@@ -88,7 +88,7 @@
                                    WriteInfo(hoister.DeviceName, $"请求分配货位返回信息错误,设备编号:{deviceChildCode},任务号:{task.TaskNum}");
                                    break;
                                }

                                task.CurrentAddress = stationManger.StackerCraneStationCode;
                                task.TargetAddress = locationCode;
                                task.NextAddress = locationCode;
                                task.DeviceCode = stationManger.StackerCraneCode;
@@ -99,7 +99,7 @@
                            }
                            else
                            {
                                WriteInfo(hoister.DeviceName, $"未找到对应站台信息,{deviceChildCode}");
                                WriteInfo(hoister.DeviceName, $"未找到对应任务信息,{deviceChildCode}");
                            }
                        }
                        else if (leisure && !tray && !requestIn && !inbounding && !requestOut && !outbounding)
@@ -116,7 +116,7 @@
                            Dt_Task task = _taskRepository.QueryFirst(x => x.TaskState == TaskStatusEnum.New.ObjToInt() && string.IsNullOrEmpty(x.TargetAddress) && _taskService.TaskOutboundTypes.Contains(x.TaskType));
                            if (task != null)
                            {
                                Dt_StationManger? stationManger = stationMangers.FirstOrDefault(x => x.StationDeviceCode == deviceChildCode);
                                Dt_StationManger? stationManger = stationMangers.FirstOrDefault(x => x.StationCode == deviceChildCode);
                                if (stationManger == null)
                                {
                                    WriteInfo(hoister.DeviceName, $"未找到对应站台信息,设备编号:{deviceChildCode},任务号:{task.TaskNum}");
@@ -124,7 +124,7 @@
                                }

                                task.TargetAddress = deviceChildCode;
                                task.NextAddress = deviceChildCode;
                                task.NextAddress = stationManger.StackerCraneStationCode; ;
                                task.DeviceCode = stationManger.StackerCraneCode;
                                task.TaskState = TaskStatusEnum.SC_Execute.ObjToInt();
                                _taskRepository.UpdateData(task);

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/ÓÍÄ«²Ö/StackerCraneJob_YM.cs

@@ -87,6 +87,7 @@
                                    commonStackerCrane.LastTaskType = task.TaskType;
                                    int oldState = task.TaskState;
                                    task.TaskState = TaskStatusEnum.SC_Executing.ObjToInt();
                                    task.ExceptionMessage = "";
                                    _taskRepository.UpdateData(task);
                                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"系统自动流程，任务状态从【{oldState}】转到【{task.TaskState}】");
                                }
@@ -110,6 +111,8 @@
        private void CommonStackerCrane_StackerCraneTaskCompletedEventHandler(object? sender, WIDESEAWCS_QuartzJob.StackerCrane.StackerCraneTaskCompletedEventArgs e)
        {
            CommonStackerCrane? commonStackerCrane = sender as CommonStackerCrane;
            try
            {
            if (commonStackerCrane != null)
            {
                WriteInfo(commonStackerCrane.DeviceName, $"读取到任务完成信号,{e.TaskNum}");
@@ -118,17 +121,7 @@
                    Dt_Task task = _taskRepository.QueryFirst(x => x.TaskNum == e.TaskNum);
                    if (task != null)
                    {
                        string? url = apiInfos.FirstOrDefault(x => x.ApiCode == APIEnum.FeedBackWMSTaskCompleted.ToString())?.ApiAddress;
                        if (string.IsNullOrEmpty(url))
                        {
                            _taskExecuteDetailService.AddTaskExecuteDetail(e.TaskNum, $"未找到回调WMS任务完成接口");
                            WriteInfo(commonStackerCrane.DeviceName, $"未找到回调WMS任务完成接口");
                            return;
                        }

                        HttpHelper.Post($"{url}?taskNum={e.TaskNum}", "");//todo è°ƒç”¨WMS任务完成方法
                        _taskExecuteDetailService.AddTaskExecuteDetail(e.TaskNum, $"系统自动流程,任务完成");
                        _taskRepository.DeleteAndMoveIntoHty(task, OperateTypeEnum.自动完成);
                            _taskService.TaskCompleted(e.TaskNum);
                    }
                    else
                    {
@@ -136,6 +129,12 @@
                    }
                    commonStackerCrane.SetValue(StackerCraneDBName.WorkType, 5);
                }
                }
            }
            catch (Exception ex)
            {
                WriteError(commonStackerCrane?.DeviceCode ?? nameof(StackerCraneJob_YM), ex.Message, ex);

            }
        }

@@ -245,22 +244,31 @@
            if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)//判断是否是入库任务
            {
                string[] startCodes = task.CurrentAddress.Split("-");

                if (startCodes.Length == 3)
                {
                stackerCraneTaskCommand.StartRow = Convert.ToInt16(startCodes[0]);
                stackerCraneTaskCommand.StartColumn = Convert.ToInt16(startCodes[1]);
                stackerCraneTaskCommand.StartLayer = Convert.ToInt16(startCodes[2]);
                }
                else
                {
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"入库任务起点错误，起点：【{task.CurrentAddress}】");
                    WriteInfo(task.DeviceCode, $"入库任务起点错误，起点：【{task.CurrentAddress}】");
                    return null;
                }

                string[] targetCodes = task.NextAddress.Split("-");
                if (targetCodes.Length == 3)
                if (targetCodes.Length == 5)
                {
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[0]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[1]);
                    stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[2]);
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[1]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[2]);
                    stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[3]);
                }
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"入库任务终点错误，起点：【{task.NextAddress}】");
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"入库任务终点错误，终点：【{task.NextAddress}】");
                    WriteInfo(task.DeviceCode, $"入库任务终点错误，终点：【{task.NextAddress}】");
                    return null;
                }
            }
@@ -268,27 +276,6 @@
            {
                string[] targetCodes = task.NextAddress.Split("-");

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

                string[] sourceCodes = task.CurrentAddress.Split("-");
                if (sourceCodes.Length == 3)
                {
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[0]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[2]);
                }
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"出库任务起点错误，起点：【{task.CurrentAddress}】");
                    return null;
                }
            }
            else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)
            {
                string[] targetCodes = task.NextAddress.Split("-");
                if (targetCodes.Length == 3)
                {
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[0]);
@@ -298,20 +285,54 @@
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"移库任务终点错误，起点：【{task.NextAddress}】");
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"出库任务终点错误，终点：【{task.NextAddress}】");
                    WriteInfo(task.DeviceCode, $"出库任务终点错误，终点：【{task.NextAddress}】");
                    return null;
                }

                string[] sourceCodes = task.CurrentAddress.Split("-");
                if (sourceCodes.Length == 5)
                {
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[3]);
                }
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"出库任务起点错误，起点：【{task.CurrentAddress}】");
                    WriteInfo(task.DeviceCode, $"出库任务起点错误，起点：【{task.CurrentAddress}】");
                    return null;
                }
            }
            else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)
            {
                string[] targetCodes = task.NextAddress.Split("-");
                if (targetCodes.Length == 5)
                {
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[1]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[2]);
                    stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[3]);
                }
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"移库任务终点错误，终点：【{task.NextAddress}】");
                    WriteInfo(task.DeviceCode, $"移库任务终点错误，终点：【{task.NextAddress}】");
                    return null;
                }
                string[] sourceCodes = task.CurrentAddress.Split("-");
                if (sourceCodes.Length == 3)
                if (sourceCodes.Length == 5)
                {
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[0]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[3]);
                }
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"移库任务起点错误，起点：【{task.CurrentAddress}】");
                    WriteInfo(task.DeviceCode, $"移库任务起点错误，起点：【{task.CurrentAddress}】");
                    return null;
                }
            }

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/²âÊԼܲÖ/GroundStationJob_CSJ.cs

@@ -2,6 +2,7 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Common;
@@ -12,6 +13,7 @@
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_Tasks.HoisterJob;

namespace WIDESEAWCS_Tasks
{
@@ -44,9 +46,11 @@
                    WriteInfo(nameof(GroundStationJob_CSJ), "调度错误,设备对象传值为null");
                    return Task.CompletedTask;
                }

                List<string> deviceStations = device.DeviceProDTOs.Select(x => x.DeviceChildCode).ToList();
                List<Dt_StationManger> stationMangers = _stationMangerRepository.QueryData(x => x.StationDeviceCode == device.DeviceCode);
                foreach (var item in stationMangers)
                foreach (var item in stationMangers.Where(x => deviceStations.Contains(x.StationCode)))
                {
                    try
                {
                    bool isCanPut = device.GetValue<GroundStationDBName, bool>(GroundStationDBName.R_IsCanPut, item.StationCode);
                    bool isCanTake = device.GetValue<GroundStationDBName, bool>(GroundStationDBName.R_IsCanTake, item.StationCode);
@@ -68,7 +72,7 @@
                            _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskNum, $"系统自动流程,目标地址由{oldAddress}变更为{task.NextAddress},任务状态由{oldStatus}变更为{task.TaskState}");
                        }
                    }
                    else if (item.StationType == StationTypeEnum.StationType_OnlyInbound.ObjToInt())
                        if (item.StationType == StationTypeEnum.StationType_OnlyInbound.ObjToInt())
                    {
                        Dt_Task task = _taskRepository.QueryFirst(x => x.TargetAddress == item.StackerCraneCode && x.TaskState == TaskStatusEnum.New.ObjToInt() && string.IsNullOrEmpty(x.NextAddress));
                        if (task != null && isCanPut && !isCanTake && !putRequest && !putFinish && !takeRequest && !takeFinish)
@@ -82,6 +86,44 @@
                        }
                    }
                }
                    catch (Exception ex)
                    {
                        WriteError(device.DeviceCode, $"{item}交互错误", ex);
                    }
                }

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

                    }
                }
            }
            catch (Exception ex)
            {

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/²âÊԼܲÖ/StackerCraneJob_CSJ.cs

@@ -5,6 +5,7 @@
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEAWCS_Common.APIEnum;
@@ -73,12 +74,8 @@
                    {
                        commonStackerCrane.StackerCraneTaskCompletedEventHandler += CommonStackerCrane_StackerCraneTaskCompletedEventHandler;//订阅任务完成事件
                    }

                    if (commonStackerCrane.StackerCraneAutoStatusValue == StackerCraneAutoStatus.Automatic && commonStackerCrane.StackerCraneStatusValue == StackerCraneStatus.Normal)
                    {
                        commonStackerCrane.CheckStackerCraneTaskCompleted();//防止任务完成事件监测超时，再手动触发一次

                        if (commonStackerCrane.StackerCraneWorkStatusValue == StackerCraneWorkStatus.Standby)
                    if (commonStackerCrane.StackerCraneAutoStatusValue == StackerCraneAutoStatus.Automatic && commonStackerCrane.StackerCraneStatusValue == StackerCraneStatus.Normal && commonStackerCrane.StackerCraneWorkStatusValue == StackerCraneWorkStatus.Standby)
                        {
                            Dt_Task? task = GetTask(commonStackerCrane);
                            if (task != null)
@@ -94,7 +91,6 @@
                                        task.TaskState = TaskStatusEnum.SC_Executing.ObjToInt();
                                        _taskRepository.UpdateData(task);
                                        _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"系统自动流程，任务状态从【{oldState}】转到【{task.TaskState}】");
                                    }
                                }
                            }
                        }
@@ -120,7 +116,6 @@
            {
                if (commonStackerCrane.GetValue<StackerCraneDBName, short>(StackerCraneDBName.WorkType) != 5)
                {
                    Console.Out.WriteLine("TaskCompleted" + e.TaskNum);
                    StackerCraneTaskCompleted(e.TaskNum, commonStackerCrane.DeviceCode);
                    commonStackerCrane.SetValue(StackerCraneDBName.WorkType, 5);
                }
@@ -144,19 +139,9 @@
                        _taskRepository.UpdateData(task);
                        _taskExecuteDetailService.AddTaskExecuteDetail(taskNum, $"系统自动流程,，任务状态从【{oldStatus}】转到【{task.TaskState}】");
                    }
                    else if (task.TaskType.GetTaskTypeGroup() != TaskTypeGroup.InboundGroup || task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)
                    else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup || task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)
                    {
                        string? url = apiInfos.FirstOrDefault(x => x.ApiCode == APIEnum.FeedBackWMSTaskCompleted.ToString())?.ApiAddress;
                        if (string.IsNullOrEmpty(url))
                        {
                            _taskExecuteDetailService.AddTaskExecuteDetail(taskNum, $"未找到回调WMS任务完成接口");
                            WriteInfo(deviceCode, $"未找到回调WMS任务完成接口");
                            return WebResponseContent.Instance.Error();
                        }

                        HttpHelper.Post($"{url}?taskNum={taskNum}", "");//todo è°ƒç”¨WMS任务完成方法
                        _taskExecuteDetailService.AddTaskExecuteDetail(taskNum, $"系统自动流程,任务完成");
                        _taskRepository.DeleteAndMoveIntoHty(task, OperateTypeEnum.自动完成);
                        _taskService.TaskCompleted(taskNum);
                    }
                    else
                    {
@@ -302,13 +287,39 @@
            if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)//判断是否是入库任务
            {
                string[] startCodes = task.CurrentAddress.Split("-");

                if (startCodes.Length == 3)
                {
                stackerCraneTaskCommand.StartRow = Convert.ToInt16(startCodes[0]);
                stackerCraneTaskCommand.StartColumn = Convert.ToInt16(startCodes[1]);
                stackerCraneTaskCommand.StartLayer = Convert.ToInt16(startCodes[2]);
                }
                else
                {
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"入库任务起点错误，起点：【{task.CurrentAddress}】");
                    WriteInfo(task.DeviceCode, $"入库任务起点错误，起点：【{task.CurrentAddress}】");
                    return null;
                }

                string[] targetCodes = task.NextAddress.Split("-");
                if (targetCodes.Length == 5)
                {
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[1]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[2]);
                    stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[3]);
                }
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"入库任务终点错误，终点：【{task.NextAddress}】");
                    WriteInfo(task.DeviceCode, $"入库任务终点错误，终点：【{task.NextAddress}】");
                    return null;
                }
            }
            else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
            {
                string[] targetCodes = task.NextAddress.Split("-");

                if (targetCodes.Length == 3)
                {
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[0]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[1]);
@@ -317,25 +328,17 @@
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"入库任务终点错误，起点：【{task.NextAddress}】");
                    WriteInfo(task.DeviceCode, $"入库任务终点错误，起点：【{task.NextAddress}】");
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"出库任务终点错误，起点：【{task.NextAddress}】");
                    WriteInfo(task.DeviceCode, $"出库任务终点错误，起点：【{task.NextAddress}】");
                    return null;
                }
            }
            else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
            {
                string[] targetCodes = task.NextAddress.Split("-");

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

                string[] sourceCodes = task.CurrentAddress.Split("-");
                if (sourceCodes.Length == 5)
                {
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[0]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[3]);
                }
                else
                {
@@ -350,23 +353,23 @@
                string[] targetCodes = task.NextAddress.Split("-");
                if (targetCodes.Length == 5)
                {
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[0]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[1]);
                    stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[2]);
                    stackerCraneTaskCommand.EndRow = Convert.ToInt16(targetCodes[1]);
                    stackerCraneTaskCommand.EndColumn = Convert.ToInt16(targetCodes[2]);
                    stackerCraneTaskCommand.EndLayer = Convert.ToInt16(targetCodes[3]);
                }
                else
                {
                    //数据配置错误
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"移库任务终点错误，起点：【{task.NextAddress}】");
                    WriteInfo(task.DeviceCode, $"移库任务终点错误，起点：【{task.NextAddress}】");
                    _taskService.UpdateTaskExceptionMessage(task.TaskNum, $"移库任务终点错误，终点：【{task.NextAddress}】");
                    WriteInfo(task.DeviceCode, $"移库任务终点错误，终点：【{task.NextAddress}】");
                    return null;
                }
                string[] sourceCodes = task.CurrentAddress.Split("-");
                if (sourceCodes.Length == 5)
                {
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[0]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartRow = Convert.ToInt16(sourceCodes[1]);
                    stackerCraneTaskCommand.StartColumn = Convert.ToInt16(sourceCodes[2]);
                    stackerCraneTaskCommand.StartLayer = Convert.ToInt16(sourceCodes[3]);
                }
                else
                {

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/.vs/WIDESEA_WMSServer/FileContentIndex/4c556b7e-ac07-429f-bc24-3cd592323521.vsidx

Binary files differ

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

@@ -14,5 +14,25 @@
            if (!type.IsEnum) return new List<int>();
            return Enum.GetValues(type).Cast<int>().ToList();
        }

        public static TaskTypeGroup GetTaskTypeGroup(this int taskType)
        {
            if (taskType >= 500 && taskType < 900)
            {
                return TaskTypeGroup.InboundGroup;
            }
            else if (taskType >= 100 && taskType < 500)
            {
                return TaskTypeGroup.OutbondGroup;
            }
            else if (taskType >= 900 && taskType < 1000)
            {
                return TaskTypeGroup.RelocationGroup;
            }
            else
            {
                return TaskTypeGroup.OtherGroup;
            }
        }
    }
}

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

@@ -61,4 +61,27 @@
        Relocation = 900
        
    }

    public enum TaskTypeGroup
    {
        /// <summary>
        /// 
        /// </summary>
        InboundGroup,

        /// <summary>
        /// 
        /// </summary>
        OutbondGroup,

        /// <summary>
        /// 
        /// </summary>
        RelocationGroup,

        /// <summary>
        /// 
        /// </summary>
        OtherGroup
    }
}

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_Core/HostedService/PermissionDataHostService.cs

@@ -30,7 +30,21 @@

        public Task StartAsync(CancellationToken cancellationToken)
        {
            List<ExpandoObject> roles = _dbContext.Db.Queryable("Sys_Role", "x").Select(RoleSelectModes).ToList();
            List<UserRole> userRoles = GetUserRoles(_dbContext.Db);
            UserRoles = userRoles;
            _cacheService.AddOrUpdate("UserRoles", userRoles.Serialize());

            return Task.CompletedTask;
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            throw new NotImplementedException();
        }

        public static List<UserRole> GetUserRoles(ISqlSugarClient db)
        {
            List<ExpandoObject> roles = db.Queryable("Sys_Role", "x").Select(RoleSelectModes).ToList();
            List<dynamic> roleDynamics = new List<dynamic>();
            foreach (var item in roles)
            {
@@ -38,13 +52,13 @@
            }

            List<dynamic> roleDataDynamics = new List<dynamic>();
            List<ExpandoObject> roleDatas = _dbContext.Db.Queryable("Sys_RoleDataPermission", "x").Select(RoleDataSelectModes).ToList();
            List<ExpandoObject> roleDatas = db.Queryable("Sys_RoleDataPermission", "x").Select(RoleDataSelectModes).ToList();
            foreach (var item in roleDatas)
            {
                roleDataDynamics.Add(item);
            }

            List<ExpandoObject> users = _dbContext.Db.Queryable("Sys_User", "x").Select(UserSelectModes).ToList();
            List<ExpandoObject> users = db.Queryable("Sys_User", "x").Select(UserSelectModes).ToList();

            List<UserRole> userRoles = new List<UserRole>();
            foreach (var item in users)
@@ -70,19 +84,10 @@
                    });
                }
            }

            UserRoles = userRoles;
            _cacheService.AddOrUpdate("UserRoles", userRoles.Serialize());

            return Task.CompletedTask;
            return userRoles;
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            throw new NotImplementedException();
        }

        List<SelectModel> RoleSelectModes = new List<SelectModel>()
        static List<SelectModel> RoleSelectModes = new List<SelectModel>()
        {
            new SelectModel()
            {
@@ -98,7 +103,7 @@
            },
        };

        List<SelectModel> UserSelectModes = new List<SelectModel>()
        static List<SelectModel> UserSelectModes = new List<SelectModel>()
        {
            new SelectModel()
            {
@@ -118,7 +123,7 @@
            }
        };

        List<SelectModel> RoleDataSelectModes = new List<SelectModel>()
        static List<SelectModel> RoleDataSelectModes = new List<SelectModel>()
        {
            new SelectModel()
            {

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

@@ -37,7 +37,7 @@
        /// <summary>
        /// æ˜¯å¦å•æ·±è´§ä½
        /// </summary>
        [PropertyValidate("深度", MinValue = 1, NotNullAndEmpty = true)]
        [PropertyValidate("深度", MinValue = 1, NotNullAndEmpty = true, IsContainMinValue = true)]
        public int Depth { get; set; }
    }
}

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

@@ -41,6 +41,8 @@

        WebResponseContent PushTasksToWCS(List<Dt_Task> tasks, string agvDescription = "");

        WebResponseContent PushTasksToWCSSingle(int taskNum, string agvDescription = "");

        /// <summary>
        /// ç”³è¯·å…¥åº“任务(PDA使用，仅托盘绑定入库站台，不分配货位)
        /// </summary>
@@ -59,6 +61,8 @@
        /// <returns></returns>
        WebResponseContent AssignInboundTaskLocation(int taskNum, string roadwayNo);

        WebResponseContent TaskCompleted(int taskNum);

        /// <summary>
        /// 
        /// </summary>

 ´úÂë¹ÜÀí/WMS/WIDESEA_WMSServer/WIDESEA_SystemService/Sys_RoleService.cs

@@ -16,6 +16,7 @@
using WIDESEA_Model.Models.System;
using WIDESEA_SystemRepository;
using WIDESEA_Core.Helper;
using WIDESEA_Core.HostedService;

namespace WIDESEA_SystemService
{
@@ -38,7 +39,7 @@

        public override WebResponseContent AddData(SaveModel saveModel)
        {
            string authorityScope = saveModel.MainData["authorityScope"].ToString();
            string authorityScope = saveModel.MainData["authorityScope"].ToString() ?? "";
            Sys_Role role = saveModel.MainData.DicToModel<Sys_Role>();
            if (BaseDal.QueryFirst(x => x.RoleName == role.RoleName) != null)
            {
@@ -71,12 +72,14 @@
                BaseDal.Db.Insertable(roleDataPermissions).ExecuteCommand();
            }

            PermissionDataHostService.UserRoles = PermissionDataHostService.GetUserRoles(Db);

            return WebResponseContent.Instance.OK();
        }

        public override WebResponseContent UpdateData(SaveModel saveModel)
        {
            string authorityScope = saveModel.MainData["authorityScope"].ToString();
            string authorityScope = saveModel.MainData["authorityScope"].ToString() ?? "";
            Sys_Role role = saveModel.MainData.DicToModel<Sys_Role>();
            if (BaseDal.QueryFirst(x => x.RoleId == role.RoleId) == null)
            {
@@ -116,6 +119,8 @@
            BaseDal.Db.Insertable(roleDataPermissions).ExecuteCommand();
            BaseDal.Db.Deleteable(oldDatas).ExecuteCommand();

            PermissionDataHostService.UserRoles = PermissionDataHostService.GetUserRoles(Db);

            return WebResponseContent.Instance.OK();
        }


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

@@ -1,4 +1,5 @@
using System;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
@@ -17,22 +18,65 @@
{
    public partial class TaskService
    {
        //public WebResponseContent TaskCompleted(int taskNum)
        //{
        //    try
        //    {
        //        Dt_Task task = Repository.QueryFirst(x => x.TaskNum == taskNum);
        //        if (task == null)
        //        {
        //            return WebResponseContent.Instance.Error($"未找到任务信息");
        //        }
        //        if(task.TaskType.get)
        public WebResponseContent TaskCompleted(int taskNum)
        {
            try
            {
                Dt_Task task = Repository.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null)
                {
                    return WebResponseContent.Instance.Error($"未找到任务信息");
                }
                if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)
                {
                    return InboundTaskCompleted(taskNum);
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                {
                    return OutboundTaskCompleted(taskNum);
                }
                else if (task.TaskType.GetTaskTypeGroup() != TaskTypeGroup.RelocationGroup)
                {
                    return RelocationTaskCompleted(task);
                }
                else
                {
                    return WebResponseContent.Instance.Error($"未找到该类型任务,任务类型:{task.TaskType}");
                }
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
               
        //    }
        //    catch (Exception ex)
        //    {
        //        return WebResponseContent.Instance.Error(ex.Message);
        //    }
        //}
        /// <summary>
        /// ä»»åŠ¡ä¿¡æ¯æŽ¨é€è‡³WCS
        /// </summary>
        /// <returns></returns>
        public WebResponseContent PushTasksToWCSSingle(int taskNum, string agvDescription = "")
        {
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null)
                {
                    return WebResponseContent.Instance.Error($"错误,未找到该任务信息");
                }

                List<WMSTaskDTO> taskDTOs = new List<WMSTaskDTO> { _mapper.Map<WMSTaskDTO>(task) };
                taskDTOs.ForEach(x =>
                {
                    x.AGVArea = agvDescription;
                });
                string response = HttpHelper.Post("http://127.0.0.1:9291/api/Task/ReceiveTask", taskDTOs.Serialize());

                return JsonConvert.DeserializeObject<WebResponseContent>(response) ?? WebResponseContent.Instance.Error("返回错误");
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error(ex.Message);
            }
        }
    }
}

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

@@ -64,6 +64,7 @@
                    TargetAddress = "",
                    TaskType = TaskTypeEnum.Inbound.ObjToInt(),
                    TaskStatus = TaskStatusEnum.New.ObjToInt(),
                    WarehouseId = warehouseId
                };

                stockInfo.StockStatus = StockStatusEmun.入库确认.ObjToInt();
@@ -73,7 +74,7 @@
                newTask.TaskId = taskId;
                _stockRepository.StockInfoRepository.UpdateData(stockInfo);
                _unitOfWorkManage.CommitTran();

                PushTasksToWCS(new List<Dt_Task> { newTask });
                return WebResponseContent.Instance.OK(data: newTask);
            }
            catch (Exception ex)

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

@@ -215,7 +215,7 @@
                _unitOfWorkManage.BeginTran();

                BaseDal.AddData(tasks);
                if (stockInfos != null && outboundOrderDetails != null && outStockLockInfos != null && locationInfos != null)
                if (stockInfos != null && stockInfos.Count > 0 && outboundOrderDetails != null && outboundOrderDetails.Count > 0 && outStockLockInfos != null && outStockLockInfos.Count > 0 && locationInfos != null && locationInfos.Count > 0)
                {
                    WebResponseContent content = _outboundService.OutboundOrderDetailService.LockOutboundStockDataUpdate(stockInfos, outboundOrderDetails, outStockLockInfos, locationInfos, tasks: tasks);

@@ -239,6 +239,7 @@
                    _outboundService.OutboundOrderDetailService.Repository.UpdateData(outboundOrderDetails);
                }
                _unitOfWorkManage.CommitTran();
                PushTasksToWCS(tasks);
                return WebResponseContent.Instance.OK();
            }
            catch (Exception ex)

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

@@ -101,10 +101,39 @@
            return Service.OutboundTaskCompleted(taskNum);
        }

        /// <summary>
        /// åˆ¤æ–­æ˜¯å¦éœ€è¦ç§»åº“
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <param name="locationCode"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("IsRelocation"), AllowAnonymous]
        public WebResponseContent IsRelocation(int taskNum, string locationCode)
        {
            return Service.IsRelocation(taskNum, locationCode);
        }

        /// <summary>
        /// ä»»åŠ¡å®Œæˆ
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("TaskCompleted"), AllowAnonymous]
        public WebResponseContent TaskCompleted(int taskNum)
        {
            return Service.TaskCompleted(taskNum);
        }

        /// <summary>
        /// å•ä¸ªä»»åŠ¡æŽ¨é€è‡³WCS
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <param name="agvDescription"></param>
        /// <returns></returns>
        [HttpPost, HttpGet, Route("PushTasksToWCSSingle"), AllowAnonymous]
        public WebResponseContent PushTasksToWCSSingle(int taskNum, string agvDescription = "")
        {
            return Service.PushTasksToWCSSingle(taskNum, agvDescription);
        }
    }
}