添加日志信息

xby-y

7 天以前 b3ff80e45d24a821ca0731983b1546b48570cdf1

 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoService/TaskService.cs

@@ -1,4 +1,4 @@
#region << ç‰ˆ æœ¬ æ³¨ é‡Š >>
#region << ç‰ˆ æœ¬ æ³¨ é‡Š >>
/*----------------------------------------------------------------
 * å‘½åç©ºé—´ï¼šWIDESEAWCS_TaskInfoService
 * åˆ›å»ºè€…：胡童庆
@@ -16,10 +16,13 @@
#endregion << ç‰ˆ æœ¬ æ³¨ é‡Š >>

using AutoMapper;
using HslCommunication.Enthernet;
using Newtonsoft.Json;
using OfficeOpenXml.FormulaParsing.Excel.Functions.RefAndLookup;
using SqlSugar;
using System.Diagnostics.CodeAnalysis;
using System.Threading.Tasks;
using WIDESEA_Comm.Http;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseRepository;
@@ -44,6 +47,8 @@
        private readonly IRepository<Dt_Router> _routerRepository;
        private readonly IRepository<Dt_StationManger> _stationMangerRepository;
        private readonly IMapper _mapper;
        private readonly ITaskHtyService _taskHtyService;


        private Dictionary<string, OrderByType> _taskOrderBy = new()
            {
@@ -57,12 +62,15 @@

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

        public string urlWMSMovelibraryTask = WIDESEAWCS_Core.Helper.AppSettings.Configuration["urlWMSMovelibraryTask"];
        public string urlTaskCompleted = WIDESEAWCS_Core.Helper.AppSettings.Configuration["urlTaskCompleted"];

        /// <summary>
        /// ä»“储层(数据库访问)
        /// </summary>
        public IRepository<Dt_Task> Repository => BaseDal;

        public TaskService(IRepository<Dt_Task> BaseDal, IRouterService routerService, IUnitOfWorkManage unitOfWorkManage, ITaskExecuteDetailService taskExecuteDetailService, IRepository<Dt_TaskExecuteDetail> taskExecuteDetailRepository, IMapper mapper, IRepository<Dt_Router> routerRepository, IRepository<Dt_StationManger> stationMangerRepository) : base(BaseDal)
        public TaskService(IRepository<Dt_Task> BaseDal, IRouterService routerService, IUnitOfWorkManage unitOfWorkManage, ITaskExecuteDetailService taskExecuteDetailService, IRepository<Dt_TaskExecuteDetail> taskExecuteDetailRepository, IMapper mapper, IRepository<Dt_Router> routerRepository, IRepository<Dt_StationManger> stationMangerRepository, ITaskHtyService taskHtyService) : base(BaseDal)
        {
            _routerService = routerService;
            _taskExecuteDetailService = taskExecuteDetailService;
@@ -71,6 +79,7 @@
            _mapper = mapper;
            _routerRepository = routerRepository;
            _stationMangerRepository = stationMangerRepository;
            _taskHtyService = taskHtyService;
        }

        /// <summary>
@@ -96,33 +105,8 @@
                        continue;
                    }
                    Dt_Task task = _mapper.Map<Dt_Task>(item);
                    task.TaskState = item.TaskStatus;


                    Dt_Router? router;

                    TaskTypeGroup taskTypeGroup = item.TaskType.GetTaskTypeGroup();
                    Dt_StationManger? stationManger;
                    if (taskTypeGroup == TaskTypeGroup.InboundGroup)
                    {
                        task.Creater = "WMS";
                        task.TaskState = (int)TaskStatusEnum.New.ObjToInt();
                        stationManger = stationMangers.FirstOrDefault(x => x.StationCode == item.CurrentAddress || x.StationDeviceCode == item.SourceAddress);
                        task.DeviceCode = stationManger.StationDeviceCode;
                    }
                    else
                    {
                        stationManger = stationMangers.FirstOrDefault(x => x.StationCode == item.NextAddress || x.StationDeviceCode == item.NextAddress);
                        task.DeviceCode = stationManger.StationDeviceCode;
                        List<Dt_Router> routers = routersAll.Where(x => x.InOutType == RouterInOutType.Out && (item.NextAddress == x.StartPosi || item.RoadWay == x.StartPosi /*|| item.RoadWay == x.ChildPosiDeviceCode || item.RoadWay == x.ChildPosi*/)).ToList();
                        router = routers.FirstOrDefault();
                        if (router == null)
                        {
                            return WebResponseContent.Instance.Error($"未找到路由配置信息");
                        }
                        //task.NextAddress = stationManger.StackerCraneStationCode;
                        task.TargetAddress = router.NextPosi;
                        //出库
                    }
                    tasks.Add(task);
                }
                BaseDal.AddData(tasks);
@@ -215,7 +199,7 @@
        /// <returns></returns>
        public Dt_Task QueryConveyorLineTask(string deviceNo, string currentAddress)
        {
            return BaseDal.QueryFirst(x => (TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.InNew || TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish) && x.CurrentAddress == currentAddress, TaskOrderBy);
            return BaseDal.QueryFirst(x => (TaskInboundTypes.Contains(x.TaskType) && TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish) && x.CurrentAddress == currentAddress, TaskOrderBy);
        }

        /// <summary>
@@ -248,12 +232,10 @@
        /// <returns></returns>
        public Dt_Task? QuertStackerCraneTask(string deviceNo, TaskTypeGroup? taskTypeGroup = null)
        {
            if (taskTypeGroup == null)
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && x.TaskState == (int)TaskInStatusEnum.InNew, TaskOrderBy);
            if (taskTypeGroup.Value == TaskTypeGroup.InboundGroup)
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.SC_Execute, TaskOrderBy);
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && TaskInboundTypes.Contains(x.TaskType), TaskOrderBy);
            if (taskTypeGroup.Value == TaskTypeGroup.OutbondGroup)
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskInStatusEnum.SC_Execute, TaskOrderBy);
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && TaskOutboundTypes.Contains(x.TaskType), TaskOrderBy);
            return null;
        }
        /// <summary>
@@ -313,10 +295,7 @@
        /// <returns>返回任务实体对象，可能为null</returns>
        public Dt_Task QueryStackerCraneInTask(string deviceNo, string currentAddress = "")
        {
            if (string.IsNullOrEmpty(currentAddress))
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && x.TaskState == (int)TaskStatusEnum.SC_Execute, TaskOrderBy);
            else
                return BaseDal.QueryFirst(x => x.DeviceCode == deviceNo && TaskInboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskStatusEnum.SC_Execute && x.CurrentAddress == currentAddress, TaskOrderBy);
            return BaseDal.QueryFirst(x => x.Roadway == deviceNo && x.TaskType == (int)TaskInboundTypeEnum.Inbound && x.TaskState == (int)TaskInStatusEnum.Line_InFinish, TaskOrderBy);
        }

        /// <summary>
@@ -327,10 +306,7 @@
        /// <returns>返回任务实体对象，可能为null</returns>
        public Dt_Task QueryStackerCraneOutTask(string deviceNo, string currentAddress = "")
        {
            if (string.IsNullOrEmpty(currentAddress))
                return BaseDal.QueryFirst(x => x.Roadway == deviceNo && TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.OutNew, TaskOrderBy);
            else
                return BaseDal.QueryFirst(x => x.Roadway == deviceNo && TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.OutNew && x.CurrentAddress == currentAddress, TaskOrderBy);
            return BaseDal.QueryFirst(x => x.Roadway == deviceNo && x.TaskType == (int)TaskOutboundTypeEnum.Outbound && x.TaskState == (int)TaskOutStatusEnum.OutNew, TaskOrderBy);
        }

        /// <summary>
@@ -339,9 +315,9 @@
        /// <param name="deviceNo">设备编号</param>
        /// <param name="currentAddress">当前地址</param>
        /// <returns>返回任务实体对象集合，可能为null</returns>
        public List<Dt_Task> QueryStackerCraneOutTasks(string deviceNo, List<string> outStationCodes)
        public List<Dt_Task> QueryStackerCraneOutTasks(string deviceNo)
        {
            return BaseDal.QueryData(x => x.Roadway == deviceNo && TaskOutboundTypes.Contains(x.TaskType) && x.TaskState == (int)TaskOutStatusEnum.OutNew && outStationCodes.Contains(x.CurrentAddress), TaskOrderBy);
            return BaseDal.QueryData(x => x.Roadway == deviceNo && x.TaskType == (int)TaskOutboundTypeEnum.Outbound && x.TaskState == (int)TaskOutStatusEnum.OutNew, TaskOrderBy);
        }

        /// <summary>
@@ -424,34 +400,43 @@
            try
            {
                int oldState = task.TaskState;
                if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
                {
                    if (task.TaskState >= (int)TaskOutStatusEnum.OutFinish)
                    {
                        return content = WebResponseContent.Instance.Error($"该任务状态不可跳转到下一步,任务号:【{task.TaskNum}】,任务状态:【{task.TaskState}】");
                    }

                    int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskOutStatusEnum>();
                    //int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskOutStatusEnum>();

                    task.TaskState = nextStatus;
                    if (task.TaskState == (int)TaskOutStatusEnum.SC_OutFinish)
                    {
                        task.TaskState = (int)TaskOutStatusEnum.Line_OutFinish;
                    }
                    else
                    {
                        task.TaskState = (int)TaskOutStatusEnum.SC_OutExecuting;
                    }
                    task.Dispatchertime = DateTime.Now;
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)
                else if (task.TaskType == (int)TaskInboundTypeEnum.Inbound)
                {
                    if (task.TaskState >= (int)TaskInStatusEnum.InFinish)
                    {
                        return content = WebResponseContent.Instance.Error($"该任务状态不可跳转到下一步,任务号:【{task.TaskNum}】,任务状态:【{task.TaskState}】");
                    }

                    int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskInStatusEnum>();
                    task.TaskState = nextStatus;

                    if (task.TaskState == (int)TaskInStatusEnum.Line_InFinish)
                    //int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskInStatusEnum>();
                    task.TaskState = (int)TaskInStatusEnum.SC_InExecuting;
                    task.Dispatchertime = DateTime.Now;
                }
                else if (task.TaskType == (int)TaskRelocationTypeEnum.Relocation)
                {
                    if (task.TaskState != (int)TaskRelocationStatusEnum.RelocationNew)
                    {
                        Random random = new Random();
                        task.CurrentAddress = task.NextAddress;
                        task.NextAddress = $"{random.Next(1, 100).ToString().PadLeft(3, '0')}-{random.Next(1, 100).ToString().PadLeft(3, '0')}-{random.Next(1, 100).ToString().PadLeft(3, '0')}";
                        task.TargetAddress = task.NextAddress;
                        return content = WebResponseContent.Instance.Error($"该任务状态不可跳转到下一步,任务号:【{task.TaskNum}】,任务状态:【{task.TaskState}】");
                    }
                    task.TaskState = (int)TaskRelocationStatusEnum.SC_RelocationExecuting;    //下发移库任务
                }
                else
                {
@@ -463,9 +448,14 @@
                    return content = WebResponseContent.Instance.Error($"该任务状态不可跳转到下一步,任务号:【{task.TaskNum}】,任务状态:【{task.TaskState}】");
                }


                task.ModifyDate = DateTime.Now;
                task.Modifier = "System";
                BaseDal.UpdateData(task);
                bool res = BaseDal.UpdateData(task);
                if (!res)
                {
                    return content = WebResponseContent.Instance.Error($"更新任务信息失败,任务号:【{task.TaskNum}】");
                }

                _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, App.User.UserId > 0 ? $"人工手动将任务状态从【{oldState}】跳转到【{task.TaskState}】" : $"系统自动流程，任务状态从【{oldState}】转到【{task.TaskState}】");

@@ -520,7 +510,7 @@
        /// </summary>
        /// <param name="taskNum">任务编号</param>
        /// <returns>返回处理结果</returns>
        public WebResponseContent StackCraneTaskCompleted(int taskNum)
        /*public WebResponseContent StackCraneTaskCompleted(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
@@ -528,55 +518,35 @@
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");

                if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup && task.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting)
                if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound && task.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting)
                {
                    List<Dt_Router> routers = _routerService.QueryNextRoutes(task.NextAddress, task.TargetAddress);
                    if (!routers.Any()) return WebResponseContent.Instance.Error($"未找到设备路由信息");
                    int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskOutStatusEnum>();
                    task.TaskState = nextStatus;
                    task.CurrentAddress = task.NextAddress;
                    task.NextAddress = routers.FirstOrDefault().ChildPosi;
                    task.TaskState = (int)TaskOutStatusEnum.SC_OutFinish;
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = "System";
                    BaseDal.UpdateData(task);
                    content = HttpHelperh.Get<WebResponseContent>($"{urlTaskCompleted}?TaskNum={task.TaskNum}");

                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"堆垛机出库完成");
                    //todo åŒæ­¥åˆ°WMS
                    WMSTaskDTO WMStask = _mapper.Map<WMSTaskDTO>(task);
                    HttpHelper.PostAsync(WMSInterfaceAddress.UpdateTaskStatus, WMStask.ToJson(), headers: new Dictionary<string, string>());
                    //暂不考虑多个出库口
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup && task.TaskState == (int)TaskInStatusEnum.SC_InExecuting)
                else if (task.TaskType == (int)TaskInboundTypeEnum.Inbound && task.TaskState == (int)TaskInStatusEnum.SC_InExecuting)
                {
                    //todo 
                    int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskInStatusEnum>();
                    task.TaskState = nextStatus;
                    task.TaskState = (int)TaskInStatusEnum.InFinish;
                    BaseDal.UpdateData(task);
                    content = HttpHelperh.Get<WebResponseContent>($"{urlTaskCompleted}?TaskNum={task.TaskNum}");
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = "System";
                    BaseDal.UpdateData(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"堆垛机入库完成");

                    WMSTaskDTO WMStask = _mapper.Map<WMSTaskDTO>(task);

                    HttpHelper.PostAsync(WMSInterfaceAddress.UpdateTaskStatus, WMStask.ToJson(), headers: new Dictionary<string, string>());
                    BaseDal.DeleteData(task);
                    // _task_HtyService.AddTaskHty(task); éœ€è¦æ·»åŠ ç§»å…¥åŽ†å²
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"入库完成");
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup && task.TaskState == (int)TaskRelocationStatusEnum.SC_RelocationFinish)
                else if (task.TaskType == (int)TaskRelocationTypeEnum.Relocation)
                {
                    int nextStatus = task.TaskState.GetNextNotCompletedStatus<TaskRelocationStatusEnum>();
                    task.CurrentAddress = task.NextAddress;
                    task.NextAddress = string.Empty;
                    task.TaskState = nextStatus;
                    task.TaskState = (int)TaskRelocationStatusEnum.SC_RelocationFinish;
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = "System";
                    BaseDal.UpdateData(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"堆垛机移库完成");
                    WMSTaskDTO WMStask = _mapper.Map<WMSTaskDTO>(task);
                    //todo è°ƒç”¨WMS移库完成
                    HttpHelper.PostAsync(WMSInterfaceAddress.UpdateTaskStatus, WMStask.ToJson(), headers: new Dictionary<string, string>());
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OtherGroup)
                {

                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"移库完成");
                    BaseDal.DeleteData(task);
                    content = HttpHelperh.Get<WebResponseContent>($"{urlTaskCompleted}?TaskNum={task.TaskNum}");
                   // _task_HtyService.AddTaskHty(task); éœ€è¦æ·»åŠ ç§»å…¥åŽ†å²
                }
                else
                {
@@ -586,9 +556,153 @@
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error($"任务完成异常,任务号:【{taskNum}】");
                content = WebResponseContent.Instance.Error($"任务完成异常,任务号:【{taskNum}】，原因：{ex.Message}");
            }
            return content;
        }*/


        public bool StackCraneTaskCompleted(int taskNum)
        {
            bool res;

            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return false;

                // éªŒè¯ä»»åŠ¡çŠ¶æ€æ˜¯å¦å…è®¸å®Œæˆ
                if (!IsTaskStateValidForCompletion(task)) return false;

                // æ ¹æ®ä»»åŠ¡ç±»åž‹å¤„理
                res = ProcessTaskCompletion(task);
            }
            catch (Exception ex)
            {
                res = false;
            }

            return res;
        }

        /// <summary>
        /// éªŒè¯ä»»åŠ¡çŠ¶æ€æ˜¯å¦å…è®¸å®Œæˆ
        /// </summary>
        private bool IsTaskStateValidForCompletion(Dt_Task task)
        {
            return task.TaskType switch
            {
                (int)TaskOutboundTypeEnum.Outbound => task.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting,
                (int)TaskInboundTypeEnum.Inbound => task.TaskState == (int)TaskInStatusEnum.SC_InExecuting,
                (int)TaskRelocationTypeEnum.Relocation => true, // ç§»åº“任务没有特定状态要求
                _ => false
            };
        }

        /// <summary>
        /// å¤„理任务完成逻辑
        /// </summary>
        private bool ProcessTaskCompletion(Dt_Task task)
        {
            // æ›´æ–°ä»»åŠ¡åŸºç¡€ä¿¡æ¯
            UpdateTaskBaseInfo(task);

            bool result = task.TaskType switch
            {
                (int)TaskOutboundTypeEnum.Outbound => ProcessOutboundTask(task),
                (int)TaskInboundTypeEnum.Inbound => ProcessInboundTask(task),
                (int)TaskRelocationTypeEnum.Relocation => ProcessRelocationTask(task),
                _ => throw new Exception($"未知的任务类型:【{task.TaskType}】")
            };

            // é€šçŸ¥ä»»åŠ¡å®Œæˆ
            if (result == true)
            {
                NotifyTaskCompleted(task.TaskNum);
            }

            return result;
        }

        /// <summary>
        /// æ›´æ–°ä»»åŠ¡åŸºç¡€ä¿¡æ¯
        /// </summary>
        private void UpdateTaskBaseInfo(Dt_Task task)
        {
            task.ModifyDate = DateTime.Now;
            task.Modifier = "System";
        }

        /// <summary>
        /// å¤„理出库任务
        /// </summary>
        private bool ProcessOutboundTask(Dt_Task task)
        {
            task.TaskState = (int)TaskOutStatusEnum.SC_OutFinish;
            bool res = BaseDal.UpdateData(task);
            //task.TaskState = (int)TaskOutStatusEnum.SC_OutFinish;
            //BaseDal.UpdateData(task);
            //// æ·»åŠ å‡ºåº“历史记录
            //_taskHtyService.AddTaskHistory(task);
            //_taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, "自动完成");
            //bool res = BaseDal.DeleteData(task);
            return res;
        }

        /// <summary>
        /// å¤„理入库任务
        /// </summary>
        private bool ProcessInboundTask(Dt_Task task)
        {
            task.TaskState = (int)TaskInStatusEnum.InFinish;
            BaseDal.UpdateData(task);

            // æ·»åŠ å…¥åº“历史记录
            _taskHtyService.AddTaskHistory(task);
            _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, "入库完成");

            // å…¥åº“完成后删除任务
            bool res = BaseDal.DeleteData(task);

            return res;
        }

        /// <summary>
        /// å¤„理移库任务
        /// </summary>
        private bool ProcessRelocationTask(Dt_Task task)
        {
            task.TaskState = (int)TaskRelocationStatusEnum.SC_RelocationFinish;
            BaseDal.UpdateData(task);

            _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, "移库完成");
            //AddTaskHistory(task);
            // ç§»åº“完成后删除任务
            bool res = BaseDal.DeleteData(task);
            // _task_HtyService.AddTaskHty(task);

            return res;
        }

        /// <summary>
        /// é€šçŸ¥ä»»åŠ¡å®Œæˆ
        /// </summary>
        private void NotifyTaskCompleted(int taskNum)
        {
            try
            {
                var response = HttpHelperh.Get<WebResponseContent>($"{urlTaskCompleted}?TaskNum={taskNum}");
                if (!response.Status)
                {
                    // è®°å½•é€šçŸ¥å¤±è´¥æ—¥å¿—，但不影响主流程
                    //_logger.Warn($"任务完成通知失败,任务号:【{taskNum}】,响应:【{response.Message}】");
                }
            }
            catch (Exception ex)
            {
                // è®°å½•å¼‚常日志，但不影响主流程
                // _logger.Error($"任务完成通知异常,任务号:【{taskNum}】", ex);
            }
        }

        /// <summary>
@@ -618,10 +732,6 @@
                    if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                    {
                        task.TaskState = (int)TaskOutStatusEnum.OutNew;
                    }
                    else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)
                    {
                        task.TaskState = (int)TaskInStatusEnum.InNew;
                    }
                    //todo
                }
@@ -681,5 +791,352 @@
            }
            return content;
        }

        public Dt_Task GetTaskIninfo(string Pallat)
        {
            return BaseDal.QueryFirst(x => x.PalletCode == Pallat);
        }

        public WebResponseContent UpdateTaskIninfo(string Pallat, string StationCode)
        {
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.PalletCode == Pallat && x.SourceAddress == StationCode);
                if (task != null)
                {
                    task.TaskState = (int)TaskInStatusEnum.Line_InFinish;
                    BaseDal.UpdateData(task);
                    return WebResponseContent.Instance.OK();
                }

                return WebResponseContent.Instance.Error();
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error();
                throw;
            }
        }


        public Dt_Task QueryStationIsOccupiedOutTasks(string deviceNo, string LocaAddress)
        {
            return BaseDal.QueryFirst(x => x.Roadway == deviceNo && (x.SourceAddress == LocaAddress || x.TargetAddress == LocaAddress), TaskOrderBy);
        }

        /// <summary>
        /// æ ¹æ®æ·±åº“位向wms申请判断浅库位是否有货，是否需要进行移库操作
        /// </summary>
        /// <param name="palletCode">托盘号</param>
        /// <param name="sourceAddress">起始地址</param>
        /// <returns></returns>
        public Dt_Task RequestWMSTaskMovelibrary(Dt_Task _Task)
        {
            WebResponseContent content = new WebResponseContent();

            content = HttpHelperh.Get<WebResponseContent>($"{urlWMSMovelibraryTask}?TaskNum={_Task.TaskNum}");
            Dt_Task task = new Dt_Task();
            if (content.Status)
            {
                if (content.Data != null)
                {
                    task = JsonConvert.DeserializeObject<Dt_Task>(content.Data.ToString());
                    if (task.TaskNum != _Task.TaskNum)
                    {
                        task.Grade = 3;
                        task.TaskState = TaskRelocationStatusEnum.RelocationNew.ObjToInt();
                        BaseDal.AddData(task);
                        return task;
                    }
                    else
                    {
                        return _Task;
                    }
                }
            }
            return null;

        }


        public Dt_Task GetOutTaskInfo(string PLCaddress)
        {
            return BaseDal.QueryFirst(x => x.TargetAddress == PLCaddress && x.TaskState == (int)TaskOutStatusEnum.SC_OutFinish, TaskOrderBy);
        }

        public Dt_Task GetOutTaskInfo2(string PalletCode)
        {
            return BaseDal.QueryFirst(x => x.PalletCode == PalletCode && x.TaskState == (int)TaskOutStatusEnum.Line_OutFinish, TaskOrderBy);
        }

        public List<Dt_Task> QueryStackerCraneYKTasks(string deviceNo)
        {
            return BaseDal.QueryData(x => x.Roadway == deviceNo && x.TaskType == (int)TaskRelocationTypeEnum.Relocation && x.TaskState == (int)TaskRelocationStatusEnum.RelocationNew, TaskOrderBy);

        }

        public WebResponseContent WCSCancelinventory(int taskNum)
        {
            //查询任务信息
            Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum && (x.TaskState == TaskOutStatusEnum.OutNew.ObjToInt() || x.TaskState == TaskRelocationStatusEnum.RelocationNew.ObjToInt() || x.TaskState == TaskInStatusEnum.Line_InExecuting.ObjToInt()));
            if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}或状态不对】");
            bool taskmsseg = BaseDal.DeleteData(task);
            bool res = AddTaskHistory(task, "手动取消");
            return taskmsseg && res ? WebResponseContent.Instance.OK() : WebResponseContent.Instance.Error();

        }

        /// <summary>
        /// æ·»åŠ åŽ†å²ä»»åŠ¡è®°å½•ï¼ˆé™æ€æ–¹æ³•ï¼‰
        /// </summary>
        /// <param name="task">任务对象</param>
        /// <returns>是否添加成功</returns>
        public bool AddTaskHistory(Dt_Task task, string operateType)
        {
            try
            {
                if (task == null)
                {
                    return false;
                }

                // åˆ›å»ºä»»åŠ¡åŽ†å²æœåŠ¡å®žä¾‹
                //var taskHtyService = App.GetService<ITaskHtyService>();
                //if (taskHtyService == null)
                //{
                //    return false;
                //}

                // æ·»åŠ åŽ†å²è®°å½•
                bool result = _taskHtyService.AddTaskHistory(task, operateType);

                return result;
            }
            catch (Exception ex)
            {
                // è®°å½•å¼‚常日志
                Console.WriteLine($"添加历史任务记录失败: {ex.Message}");
                return false;
            }
        }


        /// <summary>
        /// æ‰‹åŠ¨å®ŒæˆæŽ¥å£
        /// </summary>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>

        public WebResponseContent WCSManualTaskCompleted(int taskNum)
        {
            //查询任务信息
            Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
            if (task == null) return WebResponseContent.Instance.OK();
            bool taskmsseg = BaseDal.DeleteData(task);
            bool res = AddTaskHistory(task, "手动完成");
            return taskmsseg && res ? WebResponseContent.Instance.OK() : WebResponseContent.Instance.Error();
        }

        public bool GetYK(string sc)
        {
            Dt_Task dt_Task = BaseDal.QueryFirst(x => x.Roadway == sc && x.TaskType == (int)TaskRelocationTypeEnum.Relocation);
            if (dt_Task != null)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// èŽ·å–巷道任务进度
        /// </summary>
        /// <param name="roadway">巷道编号</param>
        /// <returns></returns>
        public WebResponseContent GetRoadwayTaskProgress(string roadway)
        {
            try
            {
                // 1. å…¥å‚校验
                if (string.IsNullOrWhiteSpace(roadway))
                {
                    return WebResponseContent.Instance.Error("巷道编号不能为空");
                }
                // 2. ä¸€æ¬¡æŸ¥è¯¢ï¼Œé¿å…å¤šæ¬¡æ•°æ®åº“/内存遍历
               List<Dt_Task> taskList = BaseDal.QueryData(x => x.Roadway == roadway).ToList();

                int totalTasks = taskList.Count;
                int inProgressTasks = 0;
                int completedTasks = 0;
                int cancelledTasks = 0;
                int exceptionTasks = 0;

                foreach (var task in taskList)
                {
                    switch ((TaskStatusEnum)task.TaskState)
                    {
                        case TaskStatusEnum.Finish:
                            completedTasks++;
                            break;
                        case TaskStatusEnum.Cancel:
                            cancelledTasks++;
                            break;
                        case TaskStatusEnum.Exception:
                            exceptionTasks++;
                            break;
                        default:
                            inProgressTasks++;
                            break;
                    }
                }

                var taskDetails = taskList.Select(t => new
                {
                    taskNum = t.TaskNum,
                    taskType = t.TaskType,
                    taskState = t.TaskState,
                    taskStateName = GetTaskStateName(t.TaskState),
                    createDate = t.CreateDate,
                    modifyDate = t.ModifyDate,
                    sourceAddress = t.SourceAddress,
                    targetAddress = t.TargetAddress
                }).ToList();

                // 5. ç»Ÿä¸€è¿”回结果
                var progressInfo = new
                {
                    roadway = roadway,
                    totalTasks,
                    inProgressTasks,
                    completedTasks,
                    cancelledTasks,
                    exceptionTasks,
                    tasks = taskDetails
                };

                return WebResponseContent.Instance.OK(data: progressInfo);
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error($"获取巷道任务进度失败：{ex.Message}");
            }
        }

        /// <summary>
        /// èŽ·å–所有巷道任务进度
        /// </summary>
        /// <returns></returns>
        public WebResponseContent GetAllRoadwayTaskProgress()
        {
            try
            {
                // 1. ä¸€æ¬¡æ€§æŸ¥è¯¢æ‰€æœ‰æ•°æ®ï¼ˆé¿å…å¤šæ¬¡æŸ¥è¯¢ï¼‰
                List<Dt_Task> allTasks = BaseDal.QueryData().ToList();

                // 2. æŒ‰å··é“分组 + ä¸€æ¬¡éåŽ†ç»Ÿè®¡æ‰€æœ‰çŠ¶æ€ï¼ˆæ€§èƒ½æå‡å·¨å¤§ï¼‰
                var progressList = allTasks
                    .GroupBy(t => t.Roadway)
                    .Select(group =>
                    {
                        var roadway = group.Key;
                        var tasks = group.ToList();
                        var totalTasks = tasks.Count;
                        int inProgress = 0, completed = 0, cancelled = 0, exception = 0;

                        foreach (var task in tasks)
                        {
                            switch ((TaskStatusEnum)task.TaskState)
                            {
                                case TaskStatusEnum.Finish:
                                    completed++;
                                    break;
                                case TaskStatusEnum.Cancel:
                                    cancelled++;
                                    break;
                                case TaskStatusEnum.Exception:
                                    exception++;
                                    break;
                                default:
                                    inProgress++;
                                    break;
                            }
                        }
                        return new
                        {
                            roadway = roadway,
                            totalTasks = totalTasks,
                            inProgressTasks = inProgress,
                            completedTasks = completed,
                            cancelledTasks = cancelled,
                            exceptionTasks = exception
                        };
                    })
                    .ToList();
                return WebResponseContent.Instance.OK(data: progressList);
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error($"获取巷道任务进度失败：{ex.Message}");
            }
        }

        /// <summary>
        /// èŽ·å–任务状态名称
        /// </summary>
        /// <param name="taskState">任务状态值</param>
        /// <returns></returns>
        private string GetTaskStateName(int taskState)
        {
            switch (taskState)
            {
                case (int)TaskStatusEnum.New:
                    return "新建";
                case (int)TaskStatusEnum.HT_Executing:
                    return "提升机执行中";
                case (int)TaskStatusEnum.SC_Execute:
                    return "堆垛机待执行";
                case (int)TaskStatusEnum.SC_Executing:
                    return "堆垛机执行中";
                case (int)TaskStatusEnum.SC_Finish:
                    return "堆垛机完成";
                case (int)TaskStatusEnum.Line_Execute:
                    return "输送线待执行";
                case (int)TaskStatusEnum.Line_Executing:
                    return "输送线执行中";
                case (int)TaskStatusEnum.Line_Finish:
                    return "输送线完成";
                case (int)TaskStatusEnum.RGV_NEW:
                    return "RGV新建任务";
                case (int)TaskStatusEnum.RGV_Execute:
                    return "RGV待执行";
                case (int)TaskStatusEnum.RGV_Takeing:
                    return "RGV取货中";
                case (int)TaskStatusEnum.RGV_Executing:
                    return "RGV执行中";
                case (int)TaskStatusEnum.RGV_WaitToExecute:
                    return "RGV待继续执行";
                case (int)TaskStatusEnum.RGV_Puting:
                    return "RGV放货中";
                case (int)TaskStatusEnum.RGV_Finish:
                    return "RGV完成";
                case (int)TaskStatusEnum.RGV_TakeError:
                    return "RGV取货写入异常";
                case (int)TaskStatusEnum.Finish:
                    return "任务完成";
                case (int)TaskStatusEnum.Pending:
                    return "任务挂起";
                case (int)TaskStatusEnum.MesPending:
                    return "Mes出库挂起";
                case (int)TaskStatusEnum.Cancel:
                    return "任务取消";
                case (int)TaskStatusEnum.Exception:
                    return "任务异常";
                default:
                    return "未知状态";
            }
        }
    }
}