任务

huanghongfeng

21 小时以前 78d5eca8ea11c60ac88ebf133329fddad7c2aad2

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

@@ -26,6 +26,7 @@
using OfficeOpenXml.FormulaParsing.Excel.Functions.Math;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Text;
using SqlSugar;
using StackExchange.Profiling.Internal;
using System;
using System.Collections.Generic;
using System.ComponentModel;
@@ -49,6 +50,7 @@
using WIDESEAWCS_Core.Utilities;
using WIDESEAWCS_DTO.Enum;
using WIDESEAWCS_DTO.TaskInfo;
using WIDESEAWCS_ISystemServices;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
@@ -58,6 +60,7 @@
using WIDESEAWCS_QuartzJob.Repository;
using WIDESEAWCS_QuartzJob.Service;
using static Microsoft.IO.RecyclableMemoryStreamManager;
using static System.Net.Mime.MediaTypeNames;

namespace WIDESEAWCS_TaskInfoService
{
@@ -69,6 +72,7 @@
        private readonly ITaskExecuteDetailRepository _taskExecuteDetailRepository;
        private readonly ITask_HtyService _task_HtyService;
        private readonly IMapper _mapper;
        private readonly IEquipmentStatusService _equipmentStatus;


        private Dictionary<string, OrderByType> _taskOrderBy = new()
@@ -83,7 +87,7 @@

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

        public TaskService(ITaskRepository BaseDal, IRouterService routerService, ITaskExecuteDetailService taskExecuteDetailService, ITaskExecuteDetailRepository taskExecuteDetailRepository, IMapper mapper, ITask_HtyService task_HtyService, IRouterRepository routerRepository) : base(BaseDal)
        public TaskService(ITaskRepository BaseDal, IRouterService routerService, ITaskExecuteDetailService taskExecuteDetailService, ITaskExecuteDetailRepository taskExecuteDetailRepository, IMapper mapper, ITask_HtyService task_HtyService, IRouterRepository routerRepository, IEquipmentStatusService equipmentStatus) : base(BaseDal)
        {
            _routerService = routerService;
            _taskExecuteDetailService = taskExecuteDetailService;
@@ -91,7 +95,21 @@
            _task_HtyService = task_HtyService;
            _mapper = mapper;
            _routerRepository = routerRepository;
            _equipmentStatus = equipmentStatus;
        }

        /// <summary>
        /// å…°å‰‘WCS调取接口
        /// </summary>
        public string urlLanJianWCSAPI = WIDESEAWCS_Core.Helper.AppSettings.Configuration["urlLanJianWCSAPI"];
        /// <summary>
        /// å…°å‰‘接口名（堆垛机运行状态）
        /// </summary>
        public string LanJianStkRunStatus = WIDESEAWCS_Core.Helper.AppSettings.Configuration["LanJianStkRunStatus"];
        /// <summary>
        /// å…°å‰‘任务反馈接口
        /// </summary>
        public string LanJiantaskResult = WIDESEAWCS_Core.Helper.AppSettings.Configuration["LanJiantaskResult"];

        /// <summary>
        /// æŽ¥æ”¶ä»»åŠ¡ä¿¡æ¯
@@ -100,11 +118,25 @@
        /// <returns>返回处理结果</returns>
        public ExpoReverse TaskInstruction(ExpoTaskDTO expoTask)
        {


            ExpoReverse content = new ExpoReverse();
            try
            {
                foreach (var item in expoTask.data)
                {
                    //查询数据库，查看是否有当前任务
                    Dt_Task dt_Tasks = BaseDal.QueryFirst(x => x.TaskNum == item.taskNo);
                    if (dt_Tasks != null)
                    {
                        content.code = 1;
                        content.msg = $"明和WCS已有当前任务ID，请勿重新下发，任务号：{dt_Tasks.TaskNum}";

                        WriteLog.Write_Log("任务接收", "任务重复", "异常任务", $"任务号：{dt_Tasks.TaskNum}重复,兰剑系统下发重复任务！！！");
                        return content;
                    }


                    if (item.type == 1)     //入库
                    {
                        Dt_Task dt_Task = new Dt_Task();
@@ -118,11 +150,14 @@
                        dt_Task.SourceAddress = item.startAddress;
                        dt_Task.TargetAddress = item.endAddress;
                        dt_Task.CurrentAddress = item.startAddress;
                        dt_Task.NextAddress = "0";   //目前暂无
                        dt_Task.NextAddress = "1021";   //目前暂无
                        dt_Task.Grade = item.priority;
                        dt_Task.WMSId = 0;   //目前暂无
                        BaseDal.AddData(dt_Task);
                        content.code = 0;

                        int taskidt= BaseDal.QueryFirst(x=>x.TaskNum== dt_Task.TaskNum).TaskId;
                        _taskExecuteDetailService.AddTaskExecuteDetail(taskidt, $"系统自动流程，创建任务");
                    }
                    else if (item.type == 2)    //出库
                    {
@@ -164,6 +199,8 @@
                        dt_Task.WMSId = 0;   //目前暂无
                        BaseDal.AddData(dt_Task);
                        content.code = 0;

                        _taskExecuteDetailService.AddTaskExecuteDetail(dt_Task.TaskId,$"系统自动流程，创建任务");
                    }
                    else
                    {
@@ -171,11 +208,13 @@
                        content.msg = $"任务类型错误，wcs接收到的类型为：{item.type}";
                    }
                }
                WriteLog.Write_Log("任务接收", "接收兰剑下发任务", "成功", $"接收到的数据为：{expoTask.ToJson()}");
            }
            catch (Exception ex)
            {
                content.code = 1;
                content.msg = $"数据错误，原因：{ex.Message}";
                WriteLog.Write_Log("任务接收", "接收兰剑下发任务异常", "异常", ex.Message);
            }
            return content;
        }
@@ -256,7 +295,6 @@
                task.ModifyDate = DateTime.Now;
                BaseDal.UpdateData(task);
                _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, task.ExceptionMessage);

                content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
@@ -482,158 +520,216 @@
            WebResponseContent content = new WebResponseContent();

            Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
            if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");
            if (task == null)
                return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");

            int oldState = task.TaskState;
            if (task.TaskType == (int)TaskInboundTypeEnum.Inbound)

            try
            {
                if (task.TaskState == (int)TaskInStatusEnum.RGV_InPickupExecuting)    //由取货中==》取货完成
                if (task.TaskType == (int)TaskInboundTypeEnum.Inbound)
                {
                    task.TaskState = (int)TaskInStatusEnum.RGV_InPickupFinish;
                    task.CurrentAddress = "1021";  //放货的地址
                    task.RGVTaskType = (int)RGVTaskTypeEnum.Placing;    //放货
                    HandleInboundTask(task);
                }
                else if (task.TaskState == (int)TaskInStatusEnum.RGV_InReleaseExecuting)
                else if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
                {
                    task.TaskState = (int)TaskInStatusEnum.RGV_InReleaseFinish;
                    task.RGVTaskType = (int)RGVTaskTypeEnum.PickingUp;      //取货
                    task.Roadway = "RGV104";
                }
                else if (task.TaskState == (int)TaskInStatusEnum.RGV_InZicheExecuting)
                {
                    Dt_Router dt_Router = _routerRepository.QueryFirst(x => x.StartPosi == task.CurrentAddress && x.ChildPosi == task.TargetAddress && x.IsEnd == false);
                    if (dt_Router != null)
                    {
                        if (task.CurrentAddress == "1061")  //HCJ站台
                        {
                            task.Roadway = "RGV107";
                        }
                        task.TaskState = (int)TaskInStatusEnum.RGV_InZicheFinish;
                        task.RGVTaskType = (int)RGVTaskTypeEnum.Placing;      //取货
                        task.CurrentAddress = dt_Router.NextPosi;

                    }
                    else
                    {
                        if (task.TargetAddress == "3" && task.TargetAddress == "4")
                        {
                            task.TaskState = (int)TaskInStatusEnum.RGV_InZicheFinish;
                            task.RGVTaskType = (int)RGVTaskTypeEnum.Placing;      //取货
                            task.CurrentAddress = "1061";
                        }
                    }
                }
                else if (task.TaskState == (int)TaskInStatusEnum.RGV_InZicheReleaseExecuting)
                {
                    task.TaskState = (int)TaskInStatusEnum.RGV_InZicheReleaseFinish;
                    task.RGVTaskType = (int)RGVTaskTypeEnum.TravelingOnly;
                    task.CurrentAddress = "1021";       //此次待修改，需要考虑2号子车移动
                }
                else if (task.TaskState == (int)TaskInStatusEnum.RGV_InZichemoveExecuting)
                {
                    Dt_Router dt_Router = _routerRepository.QueryFirst(x => x.IsEnd == true && x.ChildPosi == task.TargetAddress && x.InOutType == 1);

                    task.TaskState = (int)TaskInStatusEnum.RGV_InZichemoveFinish;
                    task.RGVTaskType = (int)RGVTaskTypeEnum.TravelingOnly;
                    task.CurrentAddress = dt_Router.NextPosi;       //此次待修改，需要考虑2号子车移动
                    task.Roadway = dt_Router.ChildPosiDeviceCode;
                }
                else if (task.TaskState == (int)TaskInStatusEnum.RGV_InMothercarExecuting)
                {
                    //最总任务完成
                    task.TaskState = (int)TaskInStatusEnum.RGV_InMothercarFinish;
                }
            }
            else if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
            {
                if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutMothercarExecuting)
                {
                    Dt_Router dt_Router = _routerRepository.QueryFirst(x => x.StartPosi == task.CurrentAddress && x.IsEnd == true && x.InOutType == 2);
                    if (dt_Router != null)
                    {
                        task.TaskState = (int)TaskOutStatusEnum.RGV_OutMothercarFinish;
                        task.CurrentAddress = dt_Router.NextPosi;
                        task.RGVTaskType = (int)RGVTaskTypeEnum.PickingUp;
                        task.Roadway = dt_Router.ChildPosiDeviceCode;  //放货的地址
                    }
                    else
                    {
                        Dt_Router dt_Rout = _routerRepository.QueryFirst(x => x.StartPosi == task.CurrentAddress && x.IsEnd == false && x.InOutType == 2);
                        task.TaskState = (int)TaskOutStatusEnum.RGV_OutMothercarFinish;
                        task.CurrentAddress = dt_Rout.StartPosi;
                        task.RGVTaskType = (int)RGVTaskTypeEnum.PickingUp;
                        task.Roadway = dt_Rout.ChildPosiDeviceCode;
                    }
                }
                else if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutZicheExecuting)
                {
                    if ((task.CurrentAddress == "1101" || task.CurrentAddress == "1121") && task.TaskState == (int)TaskOutStatusEnum.RGV_OutZicheExecuting)
                    {
                        Dt_Router dt_Router = _routerRepository.QueryFirst(x => x.StartPosi == task.CurrentAddress && x.InOutType == 2);
                        task.TaskState = (int)TaskOutStatusEnum.RGV_OutZicheFinish;
                        task.RGVTaskType = (int)RGVTaskTypeEnum.Placing;
                        task.Roadway = dt_Router.ChildPosiDeviceCode;
                        task.CurrentAddress = dt_Router.NextPosi;

                    }
                    else
                    {
                        task.TaskState = (int)TaskOutStatusEnum.RGV_OutZicheFinish;
                        task.RGVTaskType = (int)RGVTaskTypeEnum.Placing;
                        task.CurrentAddress = "1171";
                        task.Roadway = "RGV116";
                    }

                    /*Dt_Router dt_Router = _routerRepository.QueryFirst(x => x.StartPosi == task.CurrentAddress && x.InOutType == 2);
                    task.TaskState = (int)TaskOutStatusEnum.RGV_OutZicheFinish;
                    task.CurrentAddress = dt_Router.NextPosi;
                    task.RGVTaskType = (int)RGVTaskTypeEnum.Placing;*/
                }
                else if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutZicheReleaseExecuting)
                {
                    if (task.CurrentAddress == "1131")
                    {
                        Dt_Router dt_Router = _routerRepository.QueryFirst(x => x.StartPosi == task.CurrentAddress && x.InOutType == 2);
                        task.TaskState = (int)TaskOutStatusEnum.RGV_OutMothercarFinish;
                        task.RGVTaskType = (int)RGVTaskTypeEnum.PickingUp;
                        task.Roadway = dt_Router.ChildPosiDeviceCode;
                    }
                    else
                    {
                        task.TaskState = (int)TaskOutStatusEnum.RGV_OutZicheReleaseFinish;
                        task.RGVTaskType = (int)RGVTaskTypeEnum.PickingUp;
                        task.Roadway = "RGV118";
                    }
                }
                else if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutPickupExecuting)
                {
                    task.TaskState = (int)TaskOutStatusEnum.RGV_OutPickupFinish;
                    task.RGVTaskType = (int)RGVTaskTypeEnum.Placing;
                    task.CurrentAddress = "";
                }
                else if (task.TaskState == (int)TaskOutStatusEnum.RGV_OutReleaseExecuting)
                {
                    task.TaskState = (int)TaskOutStatusEnum.OutFinish;      //任务完成
                    HandleOutboundTask(task);
                }
                else
                {
                    return WebResponseContent.Instance.Error();
                    return WebResponseContent.Instance.Error("未知的任务类型");
                }

                task.ExceptionMessage = string.Empty;
                BaseDal.UpdateData(task);

                _taskExecuteDetailService.AddTaskExecuteDetail(
                    task.TaskId,
                    $"自动任务状态从【{oldState}】进入到【{task.TaskState}】"
                );

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

            task.ExceptionMessage = string.Empty;
                return WebResponseContent.Instance.Error("更新任务状态时发生系统错误");
            }
        }
        #region å…¥åº“

            BaseDal.UpdateData(task);
        private void HandleInboundTask(Dt_Task task)
        {
            switch (task.TaskState)
            {
                case (int)TaskInStatusEnum.RGV_InPickupExecuting:
                    task.TaskState = (int)TaskInStatusEnum.RGV_InPickupFinish;
                    task.RGVTaskType = (int)RGVTaskTypeEnum.Placing;
                    break;

            _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"自动任务状态从【{oldState}】进入到【{task.TaskState}】，");
                case (int)TaskInStatusEnum.RGV_InReleaseExecuting:
                    HandleInboundRelease(task);
                    break;

            content = WebResponseContent.Instance.OK();
                case (int)TaskInStatusEnum.RGV_InZicheExecuting:
                    task.RGVTaskType = (int)RGVTaskTypeEnum.Placing;
                    task.TaskState = (int)TaskInStatusEnum.RGV_InZicheFinish;
                    break;

            return content;
                case (int)TaskInStatusEnum.RGV_InZicheReleaseExecuting:
                    task.TaskState = (int)TaskInStatusEnum.RGV_InZicheReleaseFinish;
                    task.RGVTaskType = (int)RGVTaskTypeEnum.TravelingOnly;
                    break;

                case (int)TaskInStatusEnum.RGV_InZichemoveExecuting:
                    HandleInboundZichemove(task);
                    break;

                case (int)TaskInStatusEnum.RGV_InMothercarExecuting:
                    task.TaskState = (int)TaskInStatusEnum.RGV_InMothercarFinish;
                    break;

                default:
                    throw new InvalidOperationException($"未知的入库任务状态: {task.TaskState}");
            }
        }

        private void HandleInboundRelease(Dt_Task task)
        {
            task.TaskState = (int)TaskInStatusEnum.RGV_InReleaseFinish;
            task.RGVTaskType = (int)RGVTaskTypeEnum.PickingUp;

            var routes = _routerRepository.QueryData(x =>
                x.StartPosi == task.NextAddress &&
                x.InOutType == 1 &&
                x.IsEnd == false
            );

            foreach (var route in routes)
            {
                if (route.ChildPosi == task.TargetAddress ||
                    (int.Parse(route.ChildPosi) > 2 && int.Parse(task.TargetAddress) > 2))
                {
                    task.Roadway = route.ChildPosiDeviceCode;
                    task.CurrentAddress = route.StartPosi;
                    task.NextAddress = route.NextPosi;
                    break; // æ‰¾åˆ°åŒ¹é…è·¯ç”±åŽé€€å‡ºå¾ªçŽ¯
                }
            }
        }

        private void HandleInboundZichemove(Dt_Task task)
        {
            try
            {
                Dt_Router dt_Router = null;
                task.TaskState = (int)TaskInStatusEnum.RGV_InZichemoveFinish;
                if (task.TargetAddress == "4" || task.TargetAddress == "3")
                {
                    dt_Router = _routerRepository.QueryFirst(x =>
                    x.StartPosi == task.NextAddress &&
                    x.InOutType == 1);
                    if (task.CurrentAddress != "1061") task.TaskState = (int)TaskInStatusEnum.RGV_InReleaseFinish;

                }
                else
                {
                    dt_Router = _routerRepository.QueryFirst(x =>
                    x.IsEnd == true &&
                    x.ChildPosi == task.NextAddress &&
                    x.InOutType == 1);
                }


                if (dt_Router == null)
                    throw new InvalidOperationException("未找到对应的结束路由");



                task.RGVTaskType = (int)RGVTaskTypeEnum.PickingUp;
                task.CurrentAddress = dt_Router.StartPosi;
                task.NextAddress = dt_Router.NextPosi;
                task.Roadway = dt_Router.ChildPosiDeviceCode;
            }
            catch (Exception ex)
            {

                throw;
            }
        }
        #endregion

        #region å‡ºåº“

        private void HandleOutboundTask(Dt_Task task)
        {
            switch (task.TaskState)
            {
                case (int)TaskOutStatusEnum.RGV_OutMothercarExecuting:
                    task.TaskState = (int)TaskOutStatusEnum.RGV_OutMothercarFinish;
                    task.RGVTaskType = (int)RGVTaskTypeEnum.PickingUp;
                    break;

                case (int)TaskOutStatusEnum.RGV_OutZicheExecuting:
                    task.TaskState = (int)TaskOutStatusEnum.RGV_OutZicheFinish;
                    task.RGVTaskType = (int)RGVTaskTypeEnum.Placing;
                    break;

                case (int)TaskOutStatusEnum.RGV_OutZicheReleaseExecuting:
                    HandleOutboundZicheRelease(task);
                    break;

                case (int)TaskOutStatusEnum.RGV_OutPickupExecuting:
                    task.TaskState = (int)TaskOutStatusEnum.RGV_OutPickupFinish;
                    task.RGVTaskType = (int)RGVTaskTypeEnum.Placing;
                    break;

                case (int)TaskOutStatusEnum.RGV_OutReleaseExecuting:
                    task.TaskState = (int)TaskOutStatusEnum.OutFinish;
                    break;

                default:
                    throw new InvalidOperationException($"未知的出库任务状态: {task.TaskState}");
            }
        }

        private void HandleOutboundZicheRelease(Dt_Task task)
        {
            var route = _routerRepository.QueryFirst(x =>
                x.StartPosi == task.CurrentAddress &&
                x.InOutType == 2
            );

            if (route == null)
                throw new InvalidOperationException("未找到对应的路由信息");

            if (route.IsEnd)
            {
                task.TaskState = (int)TaskOutStatusEnum.RGV_OutZicheReleaseFinish;
                task.RGVTaskType = (int)RGVTaskTypeEnum.PickingUp;
                task.Roadway = "RGV118";
            }
            else
            {
                var nextRoute = _routerRepository.QueryFirst(x =>
                    x.StartPosi == task.NextAddress &&
                    x.InOutType == 2
                );

                if (nextRoute == null)
                    throw new InvalidOperationException("未找到下一个路由信息");

                task.TaskState = (int)TaskOutStatusEnum.RGV_OutMothercarFinish;
                task.RGVTaskType = (int)RGVTaskTypeEnum.PickingUp;
                task.CurrentAddress = nextRoute.StartPosi;
                task.NextAddress = nextRoute.NextPosi;
                task.Roadway = route.ChildPosiDeviceCode;
            }
        }
        #endregion


        #region å…°å‰‘调取接口内容

        /// <summary>
        /// æŸ¥è¯¢RGV状态
@@ -797,16 +893,33 @@
            ExpoReverse expoReverse = new ExpoReverse();
            try
            {
                if (sCErrorStatus == null)
                {
                    expoReverse.code = 1;
                    expoReverse.msg = "明和WCS接收到的参数为空，请检查";
                    return expoReverse;
                }

                List<EquipmentStatus> equipmentdata = new List<EquipmentStatus>();

                List<EquipmentStatus> equipmentList = _equipmentStatus.GetEquipmentStatus();
                string msgeetst = "";
                foreach (var item in sCErrorStatus.data)
                {
                    if (sCErrorStatus == null)
                    {
                        expoReverse.code = 1;
                        expoReverse.msg = "明和WCS接收到的参数为空，请检查";
                        return expoReverse;
                    }
                    expoReverse.code = 0;
                    EquipmentStatus equipment = equipmentList.Find(x => x.Equipment_Number == item.stackerName);

                    msgeetst += $"《设备：{equipment.Equipment_Number}，修改前状态：{equipment.Equipment_Status}，";

                    equipment.Equipment_Status = item.errorStatus;

                    msgeetst += $"<修改后状态：{equipment.Equipment_Status}>》................";
                    equipmentdata.Add(equipment);
                }

                WriteLog.Write_Log("设备状态更改", "堆垛机状态更改", "正常", msgeetst);
                _equipmentStatus.UpdateData(equipmentdata);     //修改状态
                expoReverse.code = 0;


                return expoReverse;
            }
@@ -814,6 +927,7 @@
            {
                expoReverse.code = 1;
                expoReverse.msg = $"明和WCS接口错误：{ex.Message}";
                WriteLog.Write_Log("设备状态更改", "堆垛机状态更改", "异常", ex.Message);
                return expoReverse;
            }
        }
@@ -829,9 +943,6 @@
            try
            {
                List<Dt_Task> _TaskList = BaseDal.QueryData(x => x.TaskType == (int)TaskInboundTypeEnum.Inbound).ToList();



                foreach (var item in taskcanceled.data)
                {
                    if (taskcanceled == null)
@@ -850,6 +961,7 @@
                            _task_HtyService.AddTaskHty(dt_Task);
                            BaseDal.DeleteData(dt_Task);
                            expoReverse.code = 0;
                            WriteLog.Write_Log("任务取消信息", "任务取消", "信息", $"任务号：{dt_Task.TaskNum}，已取消");
                        }
                        else
                        {
@@ -866,6 +978,7 @@
                    }
                }


                return expoReverse;
            }
            catch (Exception ex)
@@ -875,6 +988,7 @@
                return expoReverse;
            }
        }
        #endregion



@@ -886,7 +1000,270 @@
        /// <returns></returns>
        public WebResponseContent StkRunStatus()
        {
            WebResponseContent responseContent=new WebResponseContent();
            WebResponseContent responseContent = new WebResponseContent();
            // åˆ›å»ºå¹¶èµ‹å€¼
            StkRunStatusReception reception = new StkRunStatusReception { data = new List<StkRunStatusData> { new StkRunStatusData { stackerName = "ALL" } } };
            StkRunStatusReturns LJReturns = HttpHelper.Post<StkRunStatusReturns>(urlLanJianWCSAPI + LanJianStkRunStatus, reception, "查询堆垛机运行状态");
            if (LJReturns.code == 0)
            {
                if (LJReturns.data[0].runStatus == 0)   //全部堆垛机不在运行状态
                {
                    return responseContent.OK();
                }
                else
                {
                    return responseContent.Error($"有堆垛机在运行中，不可限制");
                }

            }
            else
            {
                WriteLog.Write_Log("堆垛机运行状态查询", "状态查询失败", "接口调取失败", $"返回内容：{LJReturns.msg}");
                return responseContent.Error($"调取兰剑WCS失败！，返回内容：{LJReturns.msg}");
            }
        }


        /// <summary>
        /// ä»»åŠ¡ä¿¡æ¯çŠ¶æ€ä¸Šä¼ (固定入库接口)
        /// </summary>
        /// <param name="sCErrorStatus"></param>
        /// <returns></returns>
        public WebResponseContent TaskResultIn(string taskNo, string finalAddress, int status, string remark)
        {
            WebResponseContent responseContent = new WebResponseContent();
            TaskfeedbackResponse reception = new TaskfeedbackResponse { data = new List<TaskfeedbackData> { new TaskfeedbackData { taskNo = taskNo, type = 1, finalAddress = finalAddress, status = status, remark = remark } } };
            StkRunStatusReturns LJReturns = HttpHelper.Post<StkRunStatusReturns>(urlLanJianWCSAPI + LanJiantaskResult, reception, "任务反馈接口");
            if (LJReturns.code == 0)
            {
                responseContent.OK("上传成功");
            }
            else
            {
                responseContent.OK("上传失败，原因：" + LJReturns.msg);
            }
            // åˆ›å»ºå¹¶èµ‹å€¼
            return responseContent;
        }

        /// <summary>
        /// ä»»åŠ¡ä¿¡æ¯çŠ¶æ€ä¸Šä¼ (固定出库接口)
        /// </summary>
        /// <param name="sCErrorStatus"></param>
        /// <returns></returns>
        public WebResponseContent TaskResultOut(string taskNo, string finalAddress, int status, string remark)
        {
            WebResponseContent responseContent = new WebResponseContent();
            TaskfeedbackResponse reception = new TaskfeedbackResponse { data = new List<TaskfeedbackData> { new TaskfeedbackData { taskNo = taskNo, type = 1, finalAddress = finalAddress, status = status, remark = remark } } };
            StkRunStatusReturns LJReturns = HttpHelper.Post<StkRunStatusReturns>(urlLanJianWCSAPI + LanJiantaskResult, reception, "任务反馈接口");
            if (LJReturns.code == 0)
            {
                responseContent.OK("上传成功");
            }
            else
            {
                responseContent.OK("上传失败，原因：" + LJReturns.msg);
            }
            // åˆ›å»ºå¹¶èµ‹å€¼
            return responseContent;
        }


        /// <summary>
        /// äººå·¥æ‰‹åŠ¨å®Œæˆ
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public WebResponseContent CompletedManually(int id)
        {

            var db = BaseDal.Db as SqlSugarClient;

            try
            {
                db.Ado.BeginTran();


                Dt_Task dt_task = BaseDal.QueryData().Where(x => x.TaskId == id).FirstOrDefault();
                if (dt_task == null) return WebResponseContent.Instance.Error($"未查询到任务");

                var res = _task_HtyService.AddData(new Dt_Task_hty
                {
                    TaskNum = dt_task.TaskNum,
                    PalletCode = dt_task.PalletCode,
                    Roadway = dt_task.Roadway,
                    TaskType = dt_task.TaskType,
                    TaskState = dt_task.TaskState,
                    SourceAddress = dt_task.SourceAddress,
                    TargetAddress = dt_task.TargetAddress,
                    CurrentAddress = dt_task.CurrentAddress,
                    NextAddress = dt_task.NextAddress,
                    WMSId = dt_task.WMSId,
                    Dispatchertime = dt_task.Dispatchertime,
                    Remark = "人工手动完成",
                    Creater = App.User.UserName,
                    CreateDate = DateTime.Now,
                    RGVTaskType = dt_task.RGVTaskType,
                    RGVCurrentexecution = dt_task.RGVCurrentexecution
                });

                int oldState = dt_task.TaskState;
                _taskExecuteDetailService.AddTaskExecuteDetail(
    dt_task.TaskId,
    $"自动任务状态从【{oldState}】进入到【{dt_task.TaskState}】"
);

                if (res.Status == false)
                {
                    db.Ado.RollbackTran();
                    return WebResponseContent.Instance.Error("手动完成失败！");
                }

                var deletetask = BaseDal.DeleteData(dt_task);
                if (deletetask == false) { 
                    db.Ado.RollbackTran();
                    return WebResponseContent.Instance.Error("删除任务失败所有操作回滚！"); 
                }
                db.Ado.CommitTran();
                return WebResponseContent.Instance.OK("手动完成成功！");

            }
            catch (Exception ex)
            {
                db.Ado.RollbackTran();
                return WebResponseContent.Instance.Error("手动完成失败！");
            }
        }

        /// <summary>
        /// äººå·¥æ‰‹åŠ¨å–消任务
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public WebResponseContent MHWCSTaskCancel(int id)
        {
            var db = BaseDal.Db as SqlSugarClient;

            try
            {
                db.Ado.BeginTran();
                Dt_Task dt_task = BaseDal.QueryData().Where(x => x.TaskId == id).FirstOrDefault();
                if (dt_task == null) return WebResponseContent.Instance.Error($"未查询到任务");
                //if (dt_task.TaskState > (int)TaskInStatusEnum.RGV_InNew || dt_task.TaskState > (int)TaskOutStatusEnum.OutNew) return WebResponseContent.Instance.Error($"任务状态不允许取消");
                /*if (dt_task.TaskType >= 200 && dt_task.TaskType <= 203)
                {
                    if (dt_task.TaskState > (int)TaskInStatusEnum.RGV_InNew) return WebResponseContent.Instance.Error($"任务状态不允许取消");
                }
                else
                {
                    if (dt_task.TaskState > (int)TaskOutStatusEnum.OutNew) return WebResponseContent.Instance.Error($"任务状态不允许取消");

                }*/

                Dt_Task_hty dt_Task_Hty = new Dt_Task_hty
                {
                    TaskNum = dt_task.TaskNum,
                    PalletCode = dt_task.PalletCode,
                    Roadway = dt_task.Roadway,
                    TaskType = dt_task.TaskType,
                    TaskState = dt_task.TaskType >= (int)TaskInboundTypeEnum.Inbound ? (int)TaskInStatusEnum.InCancel : (int)TaskOutStatusEnum.OutCancel,
                    SourceAddress = dt_task.SourceAddress,
                    TargetAddress = dt_task.TargetAddress,
                    CurrentAddress = dt_task.CurrentAddress,
                    NextAddress = dt_task.NextAddress,
                    WMSId = dt_task.WMSId,
                    Dispatchertime = dt_task.Dispatchertime,
                    Remark = "人工手动取消任务",
                    Creater = App.User.UserName,
                    CreateDate = DateTime.Now,
                    RGVTaskType = dt_task.RGVTaskType,
                    RGVCurrentexecution = dt_task.RGVCurrentexecution
                };
                var res = _task_HtyService.AddData(dt_Task_Hty);
                if (res.Status == false) {
                    db.Ado.RollbackTran();
                    return WebResponseContent.Instance.Error("取消任务失败！");
                }
                int oldState = dt_task.TaskState;
                _taskExecuteDetailService.AddTaskExecuteDetail(
    dt_task.TaskId,
    $"自动任务状态从【{oldState}】进入到【{dt_Task_Hty.TaskState}】"
);

                bool deletetask = BaseDal.DeleteData(dt_task);
                if (!deletetask) {
                    db.Ado.RollbackTran();
                    return WebResponseContent.Instance.Error("删除任务失败所有操作回滚！");
                }
                db.Ado.CommitTran();
                return WebResponseContent.Instance.OK("取消任务成功！");
            }
            catch (Exception ex)
            {
                db.Ado.RollbackTran();
                return WebResponseContent.Instance.Error("取消任务失败！");
            }
        }




        /// <summary>
        /// ä»»åŠ¡ä¸‹ä¸€æ­¥æ‰§è¡Œ
        /// </summary>
        /// <param name="sCErrorStatus"></param>
        /// <returns></returns>
        public WebResponseContent NextStepeXecuted(int taskid)
        {
            WebResponseContent responseContent = new WebResponseContent();
            Dt_Task task = BaseDal.QueryData().Where(x => x.TaskNum == taskid).FirstOrDefault();
            if (task == null) return WebResponseContent.Instance.Error($"未查询到任务");
            switch (task.TaskState)
            {
                //入库状态
                case (int)TaskInStatusEnum.RGV_InNew:
                case (int)TaskInStatusEnum.RGV_InPickupFinish:
                case (int)TaskInStatusEnum.RGV_InReleaseFinish:
                case (int)TaskInStatusEnum.RGV_InZicheFinish:
                case (int)TaskInStatusEnum.RGV_InZicheReleaseFinish:
                case (int)TaskInStatusEnum.RGV_InZichemoveFinish:
                //入库状态
                //出库状态
                case (int)TaskOutStatusEnum.OutNew:
                case (int)TaskOutStatusEnum.RGV_OutMothercarFinish:
                case (int)TaskOutStatusEnum.RGV_OutZicheFinish:
                case (int)TaskOutStatusEnum.RGV_OutZicheReleaseFinish:
                case (int)TaskOutStatusEnum.RGV_OutPickupFinish:
                    //出库状态
                    //调取下发的接口
                    responseContent = UpdateTaskStatusToNext(task);
                    break;


                //入库状态
                case (int)TaskInStatusEnum.RGV_InPickupExecuting:
                case (int)TaskInStatusEnum.RGV_InReleaseExecuting:
                case (int)TaskInStatusEnum.RGV_InZicheExecuting:
                case (int)TaskInStatusEnum.RGV_InZicheReleaseExecuting:
                case (int)TaskInStatusEnum.RGV_InZichemoveExecuting:
                case (int)TaskInStatusEnum.RGV_InMothercarExecuting:
                //入库状态
                //出库状态
                case (int)TaskOutStatusEnum.RGV_OutMothercarExecuting:
                case (int)TaskOutStatusEnum.RGV_OutZicheExecuting:
                case (int)TaskOutStatusEnum.RGV_OutZicheReleaseExecuting:
                case (int)TaskOutStatusEnum.RGV_OutPickupExecuting:
                case (int)TaskOutStatusEnum.RGV_OutReleaseExecuting:
                    //出库状态
                    //调取完成接口
                    responseContent = UpdateTaskStatus(task.TaskNum);
                    break;
                default:
                    return WebResponseContent.Instance.Error("任务状态错误，执行下一步失败");
            }
            // åˆ›å»ºå¹¶èµ‹å€¼
            return responseContent;
        }
    }