#region << 版 本 注 释 >>
/*----------------------------------------------------------------
 * 命名空间：WIDESEAWCS_TaskInfoService
 * 创建者：胡童庆
 * 创建时间：2024/8/2 16:13:36
 * 版本：V1.0.0
 * 描述：
 *
 * ----------------------------------------------------------------
 * 修改人：
 * 修改时间：
 * 版本：V1.0.1
 * 修改说明：
 * 
 *----------------------------------------------------------------*/
#endregion << 版 本 注 释 >>

using AutoMapper;
using HslCommunication;
using Microsoft.AspNetCore.Mvc.RazorPages;
using NetTaste;
using Newtonsoft.Json;
using OfficeOpenXml.FormulaParsing.Excel.Functions.DateTime;
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;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Metadata;
using System.Security.Policy;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Comm.Http;
using WIDESEA_Common.Log;
using WIDESEA_Core.Enums;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseRepository;
using WIDESEAWCS_Core.BaseServices;
using WIDESEAWCS_Core.Enums;
using WIDESEAWCS_Core.Utilities;
using WIDESEAWCS_DTO.Enum;
using WIDESEAWCS_DTO.TaskInfo;
using WIDESEAWCS_ISystemRepository;
using WIDESEAWCS_ISystemServices;
using WIDESEAWCS_ITaskInfoRepository;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_Model.Models.System;
using WIDESEAWCS_QuartzJob;
using WIDESEAWCS_QuartzJob.Models;
using WIDESEAWCS_QuartzJob.Service;
using WIDESEAWCS_TaskInfoRepository;
using static Microsoft.IO.RecyclableMemoryStreamManager;

namespace WIDESEAWCS_TaskInfoService
{
    public partial class TaskService : ServiceBase<Dt_Task, ITaskRepository>, ITaskService
    {
        private readonly IRouterService _routerService;
        private readonly ITaskExecuteDetailService _taskExecuteDetailService;
        private readonly ITaskExecuteDetailRepository _taskExecuteDetailRepository;
        private readonly ITask_HtyService _task_HtyService;
        private readonly ITask_HtyRepository _task_HtyRepository;
        private readonly IMapper _mapper;
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly IDt_roadwayinfoService _Dt_roadwayinfoService;
        private readonly IDt_PlatformStationRepository _dt_PlatformStation;

        private Dictionary<string, OrderByType> _taskOrderBy = new()
            {
                {nameof(Dt_Task.Grade),OrderByType.Desc },
                {nameof(Dt_Task.CreateDate),OrderByType.Asc},
            };

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

        public string urlWMStaskreturn = WIDESEAWCS_Core.Helper.AppSettings.Configuration["urlWMStaskreturn"];
        public string urlWMSdeverror = WIDESEAWCS_Core.Helper.AppSettings.Configuration["urlWMSdeverror"];
        public string urlWMSliftinposition = WIDESEAWCS_Core.Helper.AppSettings.Configuration["urlWMSliftinposition"];

        public TaskService(ITaskRepository BaseDal, IDt_PlatformStationRepository dt_PlatformStation, IRouterService routerService, ITaskExecuteDetailService taskExecuteDetailService, ITaskExecuteDetailRepository taskExecuteDetailRepository, IMapper mapper, ITask_HtyService task_HtyService, ITask_HtyRepository task_HtyRepository, IUnitOfWorkManage unitOfWork, IDt_roadwayinfoService dt_RoadwayinfoService) : base(BaseDal)
        {
            _routerService = routerService;
            _taskExecuteDetailService = taskExecuteDetailService;
            _taskExecuteDetailRepository = taskExecuteDetailRepository;
            _task_HtyService = task_HtyService;
            _task_HtyRepository = task_HtyRepository;
            _mapper = mapper;
            _unitOfWorkManage = unitOfWork;
            _Dt_roadwayinfoService = dt_RoadwayinfoService;
            _dt_PlatformStation = dt_PlatformStation;
        }

        //根据任务号，查询任务
        public Dt_Task? CurrtaskInfo(int taskNum)
        {
            return BaseDal.QueryData().Where(x => x.TaskNum == taskNum).FirstOrDefault();
        }

        /// <summary>
        /// 任务完成
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <returns></returns>
        public WebResponseContent StackCraneTaskCompleted(int taskNum,string PalletCode)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");

                if (task.TaskType == (int)TaskTypeEnum.Outbound && task.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting)
                {
                    task.TaskState = (int)TaskOutStatusEnum.OutFinish;
                    BaseDal.UpdateData(task);

                    string Result = WMSTaskStatusEnum.outsuccess.GetDescription();
                    if (task.Creater.Equals("WMS"))
                    {
                        //同步给上游反馈任务完成
                        Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                        CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                        if (command.status != "success") return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");
                    }
                    task.ModifyDate = DateTime.Now;
                    BaseDal.DeleteData(task);
                    _task_HtyService.AddTaskHty(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"出库完成");

                }
                else if (task.TaskType == (int)TaskTypeEnum.Inbound && task.TaskState == (int)TaskInStatusEnum.SC_InExecuting)
                {
                    task.TaskState = (int)TaskInStatusEnum.InFinish;
                    BaseDal.UpdateData(task);
                    string Result = WMSTaskStatusEnum.insuccess.GetDescription();
                    if (task.Creater.Equals("WMS"))
                    {
                        Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                        CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                        if (command.status != "success") return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");
                    }
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = "System";
                    BaseDal.DeleteData(task);
                    _task_HtyService.AddTaskHty(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"入库完成");
                }
                else if (task.TaskType == (int)TaskTypeEnum.Inventorybound && task.TaskState == (int)TaskinventoryStatusEnum.SC_inventoryExecuting)
                {
                    task.TaskState = (int)TaskinventoryStatusEnum.inventoryFinish;
                    BaseDal.UpdateData(task);
                    string Result = WMSTaskStatusEnum.insuccess.GetDescription();
                    
                    if (task.Creater.Equals("WMS"))
                    {
                        Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                        CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                        if (command.status != "success") return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");
                    }
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = "System";
                    BaseDal.DeleteData(task);
                    _task_HtyService.AddTaskHty(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"入库完成");
                }
                else
                {
                    throw new Exception($"任务类型错误,未找到该任务类型,任务号:【{taskNum}】,任务类型:【{task.TaskType}】");
                }
                content.OK();
            }
            catch (Exception ex)
            {
                content.Error($"任务完成异常,任务号:【{taskNum}】，原因：{ex.Message}");
            }
            return content;
        }


        /// <summary>
        /// 将任务状态修改为下一个状态
        /// </summary>
        /// <param name="taskNum">任务号</param>
        public WebResponseContent UpdateTaskStatusToNext(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");
                return UpdateTaskStatusToNext(task);
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            return content;
        }

        /// <summary>
        /// 将任务状态修改为下一个状态
        /// </summary>
        /// <param name="task">任务实体对象</param>
        /// <returns></returns>
        public WebResponseContent UpdateTaskStatusToNext([NotNull] Dt_Task task)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                int oldState = task.TaskState;
                if (task.TaskType == (int)TaskTypeEnum.Outbound)
                {
                    if (task.TaskState >= (int)TaskOutStatusEnum.OutFinish)
                    {
                        return content = WebResponseContent.Instance.Error($"该任务状态不可跳转到下一步,任务号:【{task.TaskNum}】,任务状态:【{task.TaskState}】");
                    }
                    task.TaskState = (int)TaskOutStatusEnum.SC_OutExecuting;
                    task.Dispatchertime = DateTime.Now;
                }
                else if (task.TaskType == (int)TaskTypeEnum.Inbound)
                {
                    if (task.TaskState >= (int)TaskInStatusEnum.InFinish)
                    {
                        return content = WebResponseContent.Instance.Error($"该任务状态不可跳转到下一步,任务号:【{task.TaskNum}】,任务状态:【{task.TaskState}】");
                    }
                    task.TaskState = (int)TaskInStatusEnum.SC_InExecuting;
                    task.Dispatchertime = DateTime.Now;
                }
                else if (task.TaskType == (int)TaskTypeEnum.Inventorybound)
                {
                    if (task.TaskState >= (int)TaskinventoryStatusEnum.inventoryFinish)
                    {
                        return content = WebResponseContent.Instance.Error($"该任务状态不可跳转到下一步,任务号:【{task.TaskNum}】,任务状态:【{task.TaskState}】");
                    }
                    task.TaskState = (int)TaskinventoryStatusEnum.SC_inventoryExecuting;
                    task.Dispatchertime = DateTime.Now;
                }
                else
                {
                    throw new Exception($"任务类型错误,未找到该任务类型,任务号:【{task.TaskNum}】,任务类型:【{task.TaskType}】");
                }

                if (task.TaskState <= 0)
                {
                    return content = WebResponseContent.Instance.Error($"该任务状态不可跳转到下一步,任务号:【{task.TaskNum}】,任务状态:【{task.TaskState}】");
                }

                string Result = WMSTaskStatusEnum.pickup.GetDescription();
                task.ModifyDate = DateTime.Now;
                task.Modifier = "System";
                BaseDal.UpdateData(task);
                Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                //反馈至上游
                CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                Console.WriteLine(command.ToJsonString());
                _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, App.User.UserId > 0 ? $"人工手动将任务状态从【{oldState}】跳转到【{task.TaskState}】" : $"系统自动流程，任务状态从【{oldState}】转到【{task.TaskState}】");

                content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            return content;
        }




















        /// <summary>
        /// 更新任务异常信息显示
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <param name="message">异常信息</param>
        public WebResponseContent UpdateTaskExceptionMessage(int taskNum, string message)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                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.OutPending;
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)
                {
                    task.TaskState = (int)TaskInStatusEnum.InPending;
                }
                task.ExceptionMessage = message;
                task.ModifyDate = DateTime.Now;
                BaseDal.UpdateData(task);

                _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, task.ExceptionMessage);

                content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            return content;
        }

       
        

        

       
        

        /// <summary>
        /// 恢复挂起任务
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <returns>返回处理结果</returns>
        public WebResponseContent TaskStatusRecovery(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");
                if (task.TaskState != (int)TaskInStatusEnum.InPending && task.TaskState != (int)TaskOutStatusEnum.OutPending)
                {
                    return content = WebResponseContent.Instance.Error($"该任务状态不可恢复,任务号:【{taskNum}】,任务状态:【{task.TaskState}】");
                }

                Dt_TaskExecuteDetail taskExecuteDetail = _taskExecuteDetailRepository.QueryFirst(x => x.TaskId == task.TaskId && x.IsNormal, new Dictionary<string, OrderByType> { { nameof(Dt_TaskExecuteDetail.TaskDetailId), OrderByType.Desc } });
                if (taskExecuteDetail != null)
                {
                    task.TaskState = taskExecuteDetail.TaskState;
                }
                else
                {
                    if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.OutbondGroup)
                    {
                        task.TaskState = (int)TaskOutStatusEnum.OutNew;
                    }
                    else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.InboundGroup)
                    {
                        task.TaskState = (int)TaskInStatusEnum.InNew;
                    }
                    //todo
                }

                task.ExceptionMessage = string.Empty;

                BaseDal.UpdateData(task);

                _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"人工恢复挂起任务,恢复挂起时任务状态【{task.TaskState}】");

                content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            return content;
        }

        /// <summary>
        /// 回滚任务状态
        /// </summary>
        /// <param name="taskNum">任务号</param>
        /// <returns>返回处理结果</returns>
        public WebResponseContent RollbackTaskStatusToLast(int taskNum)
        {
            WebResponseContent content = new();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");

                int oldState = task.TaskState;
                Dt_TaskExecuteDetail taskExecuteDetail = _taskExecuteDetailRepository.QueryFirst(x => x.TaskId == task.TaskId && x.TaskState < task.TaskState && x.TaskState > 0, new Dictionary<string, OrderByType> { { nameof(Dt_TaskExecuteDetail.TaskDetailId), OrderByType.Desc } });
                if (taskExecuteDetail != null)
                {
                    task.TaskState = taskExecuteDetail.TaskState;
                    task.CurrentAddress = taskExecuteDetail.CurrentAddress;
                    task.NextAddress = taskExecuteDetail.NextAddress;
                }
                else
                {
                    return content = WebResponseContent.Instance.Error($"未找到任务明细信息,该任务状态不可回滚到上一步,任务号:【{taskNum}】,任务状态:【{task.TaskState}】");
                }

                task.ExceptionMessage = string.Empty;

                BaseDal.UpdateData(task);

                _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"人工将任务状态从【{oldState}】回滚到【{task.TaskState}】");

                content = WebResponseContent.Instance.OK();
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error(ex.Message);
            }
            return content;
        }



        public WebResponseContent ReceiveWCSTask(int tasknum)
        {
            Dt_Task tasks = BaseDal.QueryFirst(x => x.TaskNum == tasknum);
            if(tasks == null)
            {
                return WebResponseContent.Instance.Error();
            }
            else
            {
                try
                {
                    _task_HtyService.AddTaskHty(tasks);
                    BaseDal.DeleteData(tasks);
                    WriteLog.Write_Log("WMS手动删除任务", "删除成功", $"申请删除的条码：{tasks.TaskNum},托盘条码：{tasks.PalletCode}", new { 信息 = "删除成功" });
                    return WebResponseContent.Instance.OK();

                }
                catch (Exception ex)
                {
                    WriteLog.Write_Log("WMS手动删除任务", "删除失败", $"申请删除的条码：{tasks.TaskNum},托盘条码：{tasks.PalletCode}", new { 信息 = ex.Message });
                    return WebResponseContent.Instance.Error();
                }
            }
            
        }


        public void wcs_PLCto09(string SCLLinStack, string Logtype, string Magessadd)
        {
            WriteLog.Write_Log("任务完成交互", SCLLinStack, Logtype, new { 信息 = Magessadd });
        }



        //============================================以下是后续新增内容查找任务=============================================================
        /// <summary>
        /// 根据设备编号、当前地址按照优先级以及创建时间排序查询任务池新增的任务
        /// </summary>
        /// <param name="deviceNo">设备编号</param>
        /// <param name="currentAddress">当前地址</param>
        /// <returns>返回任务实体对象，可能为null</returns>
        public List<Dt_Task> QueryStackerCraneTask(string deviceNo, string currentAddress = "")
        {
            return BaseDal.QueryData(x => x.Roadway == deviceNo && (x.TaskState == (int)TaskInStatusEnum.InNew || x.TaskState == (int)TaskOutStatusEnum.OutNew), TaskOrderBy);
        }

        public Dt_Task CutStackerCraneTask(string deviceNo)
        {
            Dt_Task dt_Task = BaseDal.QueryFirst(x => x.Roadway == deviceNo && (x.TaskState == (int)TaskOutStatusEnum.SC_OutExecuting  || x.TaskState == (int)TaskInStatusEnum.SC_InExecuting));
            return dt_Task;
        }
        /// <summary>
        /// 手动取消任务
        /// </summary>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        public WebResponseContent TaskCancel(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task != null)
                {
                    //上报入库任务异常
                    if (task.TaskType == (int)TaskTypeEnum.Inbound)
                    {
                        string Result = WMSTaskStatusEnum.inerror.GetDescription();
                        if (task.Creater.Equals("WMS"))
                        {
                            Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                            CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                            if (command.status != "success") return content.Error($"调取上游返回失败，任务取消失败，条码：{task.PalletCode},任务号：{task.TaskNum}");
                        }
                        BaseDal.DeleteData(task);
                        task.ModifyDate = DateTime.Now;
                        task.Modifier = App.User?.UserName;
                        task.Remark = "人工手动取消";
                        BaseDal.DeleteData(task);
                        _task_HtyService.AddTaskHty(task);
                        content.Status = true;
                    }
                    else
                    {
                       return  WebResponseContent.Instance.Error($"取消失败,只能取消入库任务");
                    }
                }
                else
                {
                   return  WebResponseContent.Instance.Error($"取消失败,该任务【{taskNum}】不存在");
                }
                return content;
            }
            catch (Exception e)
            {
                return WebResponseContent.Instance.Error();
            }
        }
        /// <summary>
        ///手动完成任务
        /// </summary>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        public WebResponseContent TaskHandCompleted(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskNum == taskNum);
                if (task == null) return WebResponseContent.Instance.Error($"未找到该任务信息,任务号:【{taskNum}】");

                if (task.TaskType == (int)TaskTypeEnum.Outbound)
                {
                    string Result = WMSTaskStatusEnum.outsuccess.GetDescription();
                    if (task.Creater.Equals("WMS"))
                    {
                        Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                        CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                        if (command.status != "success") return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");
                    }
                        task.ModifyDate = DateTime.Now;
                    task.Modifier = App.User?.UserName;
                    task.Remark = "人工手动完成";
                    BaseDal.DeleteData(task);
                    _task_HtyService.AddTaskHty(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"手动出库完成");
                }
                else if (task.TaskType == (int)TaskTypeEnum.Inbound)
                {
                    string Result = WMSTaskStatusEnum.insuccess.GetDescription();
                    if (task.Creater.Equals("WMS"))
                    {
                        Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                        CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                        if (command.status != "success") return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");
                    }
                        task.ModifyDate = DateTime.Now;
                    task.Modifier = App.User?.UserName;
                    task.Remark = "人工手动完成";
                    BaseDal.DeleteData(task);
                    _task_HtyService.AddTaskHty(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"手动入库完成");
                }
                else if (task.TaskType == (int)TaskTypeEnum.Inventorybound)
                {;
                    string Result = WMSTaskStatusEnum.insuccess.GetDescription();
                    if (task.Creater.Equals("WMS"))
                    {
                        Dt_roadwayinfo roadwayinfo = _Dt_roadwayinfoService.GetRoadwayinfo(task.Roadway);
                        CommandResult command = taskreturn(int.Parse(task.WMStaskid), Result, roadwayinfo.WarehouseInvType, "");
                        if (command.status != "success") return content.Error($"调取上游返回失败，完成堆垛机任务失败，条码：{task.PalletCode},任务号：{task.TaskNum}");
                    }
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = App.User?.UserName;
                    task.Remark = "人工手动完成";
                    BaseDal.DeleteData(task);
                    _task_HtyService.AddTaskHty(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"手动入库完成");
                }
                else
                {
                    throw new Exception($"任务类型错误,未找到该任务类型,任务号:【{taskNum}】,任务类型:【{task.TaskType}】");
                }
                content.OK();
            }
            catch (Exception ex)
            {
                content.Error($"任务完成异常,任务号:【{taskNum}】，原因：{ex.Message}");
            }
            return content;
        }

        /// <summary>
        /// 手动创建任务
        /// </summary>
        /// <param name="transfer"></param>
        /// <returns></returns>
        public WebResponseContent CreateManualTask(Dt_Task transfer)
        {


            WebResponseContent content = new WebResponseContent();
            try
            {
                IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceName.Contains("堆垛机"));
                // 判断设备是否存在
                if (device == null)
                {
                    content.Error("手动创建任务失败，原因：未找到堆垛机设备");
                    WriteLog.Write_Log("手动任务创建失败", "创建失败", $"原因：未找到堆垛机设备,托盘编号：{transfer.PalletCode}，任务类型：{transfer.TaskType},起始地址：{transfer.SourceAddress}，目标地址：{transfer.TargetAddress}");
                    return content;
                }

                // 判断地址是否属于当前设备库
                if (transfer.SourceAddress.Contains(device.DeviceCode) && transfer.TargetAddress.Contains(device.DeviceCode))
                {
                    // 入库
                    if (transfer.TaskType == 200)
                    {
                        Dt_PlatformStation _PlatformStation = _dt_PlatformStation.QueryFirst(x => x.Station_code == transfer.SourceAddress);
                        if (_PlatformStation == null)
                        {
                            content.Error($"手动创建任务失败,原因:{device.DeviceCode}库不存在这个库口：{transfer.SourceAddress}");
                            WriteLog.Write_Log("手动任务创建失败", "创建失败", $"托盘编号：{transfer.PalletCode}，任务类型：{transfer.TaskType},起始地址：{transfer.SourceAddress}，目标地址：{transfer.TargetAddress}");
                        }
                        else
                        {
                            // 正常创建任务
                            transfer.TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum));
                            transfer.TaskState = 200;
                            transfer.CurrentAddress = transfer.SourceAddress;
                            transfer.NextAddress = transfer.TargetAddress;
                            transfer.Roadway = device.DeviceCode;
                            transfer.Creater = "WCS";
                            transfer.Grade = 1;
                            transfer.CreateDate = DateTime.Now;
                            _unitOfWorkManage.BeginTran();
                            BaseDal.AddData(transfer);
                            _unitOfWorkManage.CommitTran();
                            content.OK("手动任务创建成功！");
                            WriteLog.Write_Log("手动任务创建成功", "创建成功", $"托盘编号：{transfer.PalletCode}，任务类型：{transfer.TaskType},起始地址：{transfer.SourceAddress}，目标地址：{transfer.TargetAddress}");
                        }
                        return content;

                    }
                    // 出库
                    else if (transfer.TaskType == 100)
                    {
                        Dt_PlatformStation _PlatformStation = _dt_PlatformStation.QueryFirst(x => x.Station_code == transfer.TargetAddress);
                        if (_PlatformStation == null)
                        {
                            content.Error($"手动创建任务失败,原因:{device.DeviceCode}库不存在这个库口：{transfer.TargetAddress}");
                        }
                        else
                        {
                            // 正常创建任务
                            transfer.TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum));
                            transfer.TaskState = 100;
                            transfer.CurrentAddress = transfer.SourceAddress;
                            transfer.NextAddress = transfer.TargetAddress;
                            transfer.Roadway = device.DeviceCode;
                            transfer.Creater = "WCS";
                            transfer.Grade = 1;
                            transfer.CreateDate = DateTime.Now;
                            _unitOfWorkManage.BeginTran();
                            BaseDal.AddData(transfer);
                            _unitOfWorkManage.CommitTran();
                            content.OK("手动任务创建成功！");
                            WriteLog.Write_Log("手动任务创建成功", "创建成功", $"托盘编号：{transfer.PalletCode}，任务类型：{transfer.TaskType},起始地址：{transfer.SourceAddress}，目标地址：{transfer.TargetAddress}");
                        }
                        return content;
                    }


                }
                else
                {
                    content.Error($"手动创建任务失败,原因:{device.DeviceCode}库地址不匹配,起始地址：{transfer.SourceAddress}，目标地址：{transfer.TargetAddress}");
                    WriteLog.Write_Log("手动任务创建失败", "创建失败", $"托盘编号：{transfer.PalletCode}，任务类型：{transfer.TaskType},起始地址：{transfer.SourceAddress}，目标地址：{transfer.TargetAddress}");
                }
            }
            catch (Exception ex)
            {
                content.Error($"手动创建任务失败，系统异常：{ex.Message}");
                WriteLog.Write_Log("手动任务异常", "异常", ex.ToString());
            }
            return content;
        }
    }
}