using Mapster;
using Masuit.Tools;
using SixLabors.Fonts.Tables.AdvancedTypographic;
using SqlSugar;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using WIDESEA_Cache;
using WIDESEA_Core;
using WIDESEA_Core.Const;
using WIDESEA_DTO.MOM;
using WIDESEA_DTO.WMS;
using WIDESEA_IServices;
using WIDESEA_IStoragIntegrationServices;
using WIDESEA_Model.Models;
using WIDESEAWCS_BasicInfoRepository;
using WIDESEAWCS_QuartzJob.Models;

namespace WIDESEA_StorageTaskServices;

public partial class Dt_TaskService : ServiceBase<Dt_Task, IDt_TaskRepository>, IDt_TaskService
{
    private readonly LogFactory LogFactory = new LogFactory();
    private readonly IUnitOfWorkManage _unitOfWorkManage;
    private readonly IStockInfoRepository _stockInfoRepository;
    private readonly IStockInfoDetailRepository _stockInfoDetailRepository;
    private readonly IDt_Task_HtyRepository _task_HtyRepository;
    private readonly IMapper _mapper;
    private readonly ILocationInfoRepository _locationRepository;
    private readonly ITaskExecuteDetailRepository _taskExecuteDetailRepository;
    private readonly ILocationStatusChangeRecordRepository _locationStatusChangeRecordRepository;
    private readonly IBoxingInfoRepository _boxingInfoRepository; //组盘
    private readonly ICellStateService _cellStateService; //电芯属性
    private readonly IProcessApplyService _processApplyService; //工艺路线
    private readonly IDt_AreaInfoRepository _areaInfoRepository; //区域
    private readonly IAgingInOrOutInputService _agingInOrOutInputService; //静置\陈化
    private readonly IDt_StationManagerRepository _stationManagerRepository;
    private readonly ISys_ConfigService _configService;
    private readonly ISimpleCacheService _simpleCacheService;

    public Dt_TaskService(IDt_TaskRepository BaseDal,
                                IUnitOfWorkManage unitOfWorkManage,
                                IDt_OutOrderRepository outOrderRepository,
                                IStockInfoRepository stockInfoRepository,
                                IDt_Task_HtyRepository task_HtyRepository,
                                IMapper mapper,
                                ILocationInfoRepository locationRepository,
                                ITaskExecuteDetailRepository taskExecuteDetailRepository,
                                ILocationStatusChangeRecordRepository locationStatusChangeRecordRepository,
                                IBoxingInfoRepository boxingInfoRepository,
                                ICellStateService cellStateService,
                                IProcessApplyService processApplyService,
                                IDt_AreaInfoRepository areaInfoRepository,
                                IAgingInOrOutInputService agingInOrOutInputService,
                                IStockInfoDetailRepository stockInfoDetailRepository,
                                IDt_StationManagerRepository stationManagerRepository,
                                ISys_ConfigService configService,
                                ISimpleCacheService simpleCacheService) : base(BaseDal)
    {
        _unitOfWorkManage = unitOfWorkManage;
        _stockInfoRepository = stockInfoRepository;
        _task_HtyRepository = task_HtyRepository;
        _mapper = mapper;
        _locationRepository = locationRepository;
        _taskExecuteDetailRepository = taskExecuteDetailRepository;
        _locationStatusChangeRecordRepository = locationStatusChangeRecordRepository;
        _boxingInfoRepository = boxingInfoRepository;
        _cellStateService = cellStateService;
        _processApplyService = processApplyService;
        _areaInfoRepository = areaInfoRepository;
        _agingInOrOutInputService = agingInOrOutInputService;
        _stockInfoDetailRepository = stockInfoDetailRepository;
        _stationManagerRepository = stationManagerRepository;
        _configService = configService;
        _simpleCacheService = simpleCacheService;
    }

    #region 外部接口方法

    #region 出库任务完成

    public async Task<WebResponseContent> CompleteStackTaskAsync(Dt_Task task, DtStockInfo stock)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
            {
                if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
                {
                    if (!task.Roadway.Contains("FR") && stock.ProcessCode != "OCVB")
                    {
                        var agingOutputDto = MapToAgingOutputDto(stock);
                        content = await _agingInOrOutInputService.GetOCVOutputAsync(agingOutputDto);

                        if (content.Status)
                        {
                            var result = JsonConvert.DeserializeObject<BasicResult>(content.Data.ToString());

                            if (!result.Success && result.MessageCode == "E10001")
                            {
                                await HandleOutBoundError(stock, task);
                            }
                        }
                        else
                        {
                            task.Remark = "NG";
                            ConsoleHelper.WriteErrorLine("MOM通报点芯NG");
                            return content.Error("MOM通报点芯NG");
                        }
                    }
                }
            }

            if (task.Remark == "NG")
            {
                ConsoleHelper.WriteErrorLine("MOM通报点芯NG");
                return content.Error("MOM通报点芯NG");
            }
            // 更新库存状态和任务状态
            (var loc, var tas) = UpdateStockAndTaskStatus(stock, task);
            var taskHty = task.Adapt<Dt_Task_Hty>();
            taskHty.FinishTime = DateTime.Now;
            taskHty.OperateType = App.User.UserName != null ? (int)OperateTypeEnum.人工完成 : (int)OperateTypeEnum.自动完成;
            taskHty.Creater = App.User.UserName != null ? App.User.UserName : "System";

            DtStockInfo_Hty stockInfo_Hty = stock.Adapt<DtStockInfo_Hty>();
            stockInfo_Hty.ModifyDate = DateTime.Now;

            // 事务处理
            await _unitOfWorkManage.UseTranAsync(async () =>
            {
                if (task.TaskType != (int)TaskOutboundTypeEnum.OutQuality)
                {
                    await DeleteStockInfoAsync(stock.Id);
                    await DeleteStockInfoDetailsAsync(stock.StockInfoDetails);
                    await AddStockInfoHtyAsync(stockInfo_Hty);
                    await UpdateLocationAsync(loc); //质检任务需要持续锁定库位
                }
                await DeleteTaskAsync(task.TaskId);
                await AddTaskHtyAsync(taskHty);
            });

            return content.OK("任务完成成功", task.Remark);
        }
        catch (Exception err)
        {
            LogFactory.GetLog("任务完成").Error(true, $"系统异常，异常信息：{err.Message}");
            return content.Error(err.Message);
        }
    }

    private AgingOutputDto MapToAgingOutputDto(DtStockInfo stock, ResponseEqptRunDto? info = null)
    {
        // TODO Value值根据MOM下发的静置时间到当前时间的分钟数
        var area = _areaInfoRepository.QueryFirst(x => x.AreaCode == stock.AreaCode);
        if (area == null)
        {
            throw new Exception("未找到对应的库区信息");
        }

        var parameterInfo = JsonConvert.DeserializeObject<List<ParameterInfo>>(stock.ParameterInfos).FirstOrDefault(y => y.Description.Contains("时间"));
        if (parameterInfo == null) throw new Exception("");

        var outHours = (DateTime.Now - (stock.LinedProcessFeedbackTime == null ? stock.CreateDate : stock.LinedProcessFeedbackTime.ToDateTime())).TotalHours;

        //if (stock.LinedProcessFeedbackTime == null)
        //{
        //    outHours = (DateTime.Now - stock.CreateDate).TotalHours;
        //}
        //else
        //{
        //    outHours = (DateTime.Now - stock.LinedProcessFeedbackTime.ToDateTime()).TotalHours;
        //}

        var isNG = outHours > parameterInfo.LowerSpecificationsLimit.ToDouble() && outHours < parameterInfo.UpperSpecificationsLimit.ToDouble();

        var defectCode = string.Empty;
        if (!isNG) defectCode = "TQCK";
        return new AgingOutputDto
        {
            OpFlag = 1,
            Software = area.Spare3,
            EquipmentCode = area.Spare2,
            TrayBarcode = stock.PalletCode,
            SerialNos = stock.StockInfoDetails.Select(x => new SerialNoOutDto
            {
                SlotNo = x.OrderNo.ToInt32(),
                SerialNo = x.SerialNumber,
                SerialNoResult = true, //isNG,
                ParameterInfo = new List<ParameterInfoOutput> {
                    new ParameterInfoOutput() {
                        Value = outHours.ToString(),
                        ParameterCode =parameterInfo.ParameterCode,
                        ParameterDesc = parameterInfo.Description,
                        ParameterResult  = "OK", //isNG.ToString(),
                        TargetValue = parameterInfo.TargetValue,
                        LowerLimit = parameterInfo.LowerSpecificationsLimit,
                        UpperLimit = parameterInfo.UpperSpecificationsLimit,
                        DefectCode = defectCode,
                        UOMCode = parameterInfo.UOMCode,
                    }
                }
            }).ToList()
        };
    }

    private (DtLocationInfo, Dt_Task) UpdateStockAndTaskStatus(DtStockInfo stock, Dt_Task task)
    {
        var location = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress && x.RoadwayNo == task.Roadway);
        //var details = _stockInfoDetailRepository.QueryData(x => x.StockId == stock.Id);
        int lastStatus = location.LocationStatus;
        location.LocationStatus = (int)LocationEnum.Free;
        task.TaskState = (int)TaskOutStatusEnum.OutFinish;
        //task.CurrentAddress = task.NextAddress;
        //task.NextAddress = task.TargetAddress;

        _locationStatusChangeRecordRepository.AddLocationStatusChangeRecord(location, lastStatus, (int)StatusChangeTypeEnum.AutomaticDelivery, task.TaskNum);

        LogFactory.GetLog("任务完成").Info(true, "更新库存状态与任务状态");
        return (location, task);
    }

    private async Task DeleteStockInfoAsync(int stockId)
    {
        var isStockUpdated = await _stockInfoRepository.DeleteDataByIdAsync(stockId);
        if (!isStockUpdated)
        {
            throw new Exception("库存信息更新失败");
        }
    }

    private async Task AddStockInfoHtyAsync(DtStockInfo_Hty dtStock)
    {
        var isStockAdd = await SqlSugarHelper.DbWMS.InsertNav(dtStock).IncludesAllFirstLayer().ExecuteCommandAsync();
        if (!isStockAdd)
        {
            throw new Exception("库存历史信息添加失败");
        }
    }

    private async Task UpdateLocationAsync(DtLocationInfo info)
    {
        var isStockUpdated = await _locationRepository.UpdateDataAsync(info);
        if (!isStockUpdated)
        {
            throw new Exception("库存信息更新失败");
        }
    }

    private async Task DeleteStockInfoDetailsAsync(IEnumerable<DtStockInfoDetail> details)
    {
        var ids = details.Select(x => (object)x.Id).ToArray();
        var isStockDetailUpdated = await _stockInfoDetailRepository.DeleteDataByIdsAsync(ids);
        if (!isStockDetailUpdated)
        {
            throw new Exception("库存详情信息更新失败");
        }
    }

    private async Task DeleteTaskAsync(int taskId)
    {
        var isTaskUpdated = await BaseDal.DeleteDataByIdAsync(taskId);
        if (!isTaskUpdated)
        {
            throw new Exception("任务信息更新失败");
        }
    }

    private async Task AddTaskHtyAsync(Dt_Task_Hty taskHty)
    {
        var isTaskAdd = await _task_HtyRepository.AddDataAsync(taskHty) > 0;
        if (!isTaskAdd)
        {
            throw new Exception("历史任务信息添加失败");
        }
    }

    #endregion 出库任务完成

    #region 火警任务完成
    public async Task<WebResponseContent> CompleteOutFireAlarmTaskAsync(Dt_Task task, DtStockInfo stock)
    {
        WebResponseContent content = new WebResponseContent();
        (var loc, var tas) = UpdateStockAndTaskStatus(stock, task);
        var taskHty = task.Adapt<Dt_Task_Hty>();
        taskHty.FinishTime = DateTime.Now;
        taskHty.OperateType = App.User.UserName != null ? (int)OperateTypeEnum.人工完成 : (int)OperateTypeEnum.自动完成;
        taskHty.Creater = App.User.UserName != null ? App.User.UserName : "System";

        DtStockInfo_Hty stockInfo_Hty = stock.Adapt<DtStockInfo_Hty>();
        stockInfo_Hty.ModifyDate = DateTime.Now;

        // 事务处理
        await _unitOfWorkManage.UseTranAsync(async () =>
        {
            if (task.TaskType != (int)TaskOutboundTypeEnum.OutQuality)
            {
                await DeleteStockInfoAsync(stock.Id);
                await DeleteStockInfoDetailsAsync(stock.StockInfoDetails);
                await AddStockInfoHtyAsync(stockInfo_Hty);
                await UpdateLocationAsync(loc); //质检任务需要持续锁定库位
            }
            await DeleteTaskAsync(task.TaskId);
            await AddTaskHtyAsync(taskHty);
        });
        return content.OK("任务完成成功", task.Remark);
    }
    #endregion

    #region 移库任务完成

    /// <summary>
    /// 移库任务完成
    /// </summary>
    /// <param name="saveModel">任务数据合集</param>
    /// <returns>返回结果集</returns>
    public async Task<WebResponseContent> CompleteTransferTaskAsync(Dt_Task task, DtStockInfo stock)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            // 更新货位和库存信息
            (DtStockInfo updateStock, DtLocationInfo locationInForm, DtLocationInfo locationInfoTo) = UpdateStockLocation(stock, task);
            var taskHty = CreateHistoricalTask(task);
            LogFactory.GetLog("任务完成").InfoFormat(true, "移库任务完成", $"货位地址：{task.TargetAddress},修改后库存数据：{JsonConvert.SerializeObject(updateStock)}，原先货位数据：{locationInForm}");

            // 执行数据库事务
            bool isResult = await ExecuteTransaction(updateStock, taskHty, locationInForm, locationInfoTo, task.TaskId);
            if (isResult)
                content.OK("移库任务完成成功");
            else
                content.Error("移库任务完成失败");
        }
        catch (Exception err)
        {
            Console.WriteLine(err.Message.ToString());
        }
        return content;
    }

    #endregion 移库任务完成

    #region 入库任务完成

    /// <summary>
    /// 完成入库任务
    /// </summary>
    /// <param name="task">任务数据合集</param>
    /// <returns>返回结果集</returns>
    public async Task<WebResponseContent> CompleteInboundTaskAsync(Dt_Task task)
    {
        // 初始化响应内容
        WebResponseContent content = new WebResponseContent();
        try
        {
            if (task.TaskType == (int)TaskInboundTypeEnum.InNG)
            {
                task.TaskState = (int)TaskInStatusEnum.SC_InFinish;
                // 创建历史任务实例模型
                var taskHtyNG = CreateHistoricalTask(task);

                // 执行数据库事务
                await _unitOfWorkManage.UseTranAsync(async () =>
                {
                    // 添加历史任务
                    var isTaskHtyAdd = await _task_HtyRepository.AddDataAsync(taskHtyNG) > 0;

                    // 删除任务数据
                    var isTaskDelete = await Delete(task.TaskId);
                    if (!isTaskHtyAdd || !isTaskDelete)
                        throw new Exception("添加失败");
                });
                return content.OK("入库任务完成成功");
            }

            // 获取装箱信息和目标位置信息
            var boxing = await _boxingInfoRepository.QueryFirstNavAsync(x => x.PalletCode == task.PalletCode);
            var locationInf = await _locationRepository.QueryFirstAsync(x => x.LocationCode == task.TargetAddress && x.RoadwayNo == task.Roadway);

            int lastStatus = locationInf.LocationStatus;
            // 更新目标位置状态为库存中
            locationInf.LocationStatus = (int)LocationEnum.InStock;

            // 创建历史任务实例模型
            var taskHty = CreateHistoricalTask(task);

            if (task.TaskType == (int)TaskInboundTypeEnum.InQuality)
            {
                await _locationRepository.UpdateDataAsync(locationInf);
                await _task_HtyRepository.AddDataAsync(taskHty);
                await BaseDal.DeleteDataAsync(task);

                //记录货位变动信息
                _locationStatusChangeRecordRepository.AddLocationStatusChangeRecord(locationInf, lastStatus, (int)StatusChangeTypeEnum.AutomaticStorage, task.TaskNum);

                return content.OK("入库任务完成成功");
            }
            // 根据是否有组盘信息创建库存实例模型
            DtStockInfo stock = boxing == null ? CreateEmptyPalletStock(task, locationInf) : CreateFullPalletStock(task, locationInf, boxing);

            // 执行数据库事务
            bool isResult = await ExecuteTransaction(stock, taskHty, locationInf, task.TaskId, boxing);
            if (isResult)
            {
                _locationStatusChangeRecordRepository.AddLocationStatusChangeRecord(locationInf, lastStatus, (int)StatusChangeTypeEnum.AutomaticStorage, task.TaskNum);

                stock.StockInfoDetails = new List<DtStockInfoDetail>() { { stock.StockInfoDetails[0] } };
                stock.LocationInfo = locationInf;

                content.OK("入库任务完成成功");
            }
            else
            {
                content.Error("入库任务完成失败");
            }
        }
        catch (Exception err)
        {
            // 记录异常信息到控制台和日志
            Console.WriteLine(err.Message.ToString());
            LogFactory.GetLog("任务完成").Error(true, err);
            content.Error(err.Message);
            task.ErrorMessage = err.Message;
            task.TaskState = (int)TaskInStatusEnum.SC_InExecuting;
            await BaseDal.Update(task);
        }
        return content;
    }

    /// <summary>
    /// 创建空托盘的库存实例模型
    /// </summary>
    private DtStockInfo CreateEmptyPalletStock(Dt_Task task, DtLocationInfo locationInf)
    {
        var loation = _locationRepository.QueryFirst(x => x.RoadwayNo == task.Roadway && x.LocationCode == task.TargetAddress);
        var area = _areaInfoRepository.QueryFirst(x => x.AreaID == loation.AreaId);
        return new DtStockInfo()
        {
            PalletCode = task.PalletCode,
            LocationCode = task.TargetAddress,
            CreateDate = DateTime.Now,
            Creater = "system",
            IsFull = false,
            AreaCode = area.AreaCode ?? "",
            LocationId = loation.Id,
            ProductionLine = task.ProductionLine,
            StockInfoDetails = new List<DtStockInfoDetail>()
            {
                new DtStockInfoDetail()
                {
                    MaterielCode = "空托盘",
                    Id = 0,
                    Status = (int)StockStateEmun.已入库
                }
            }
        };
    }

    /// <summary>
    /// 创建分容的实托盘的库存实例模型
    /// </summary>
    private DtStockInfo CreateFullPalletStockByFR(Dt_Task task, DtLocationInfo locationInf)
    {
        var loation = _locationRepository.QueryFirst(x => x.RoadwayNo == task.Roadway && x.LocationCode == task.TargetAddress);
        var area = _areaInfoRepository.QueryFirst(x => x.AreaID == loation.AreaId);
        return new DtStockInfo()
        {
            PalletCode = task.PalletCode,
            LocationCode = task.TargetAddress,
            CreateDate = DateTime.Now,
            Creater = "system",
            IsFull = false,
            AreaCode = area.AreaCode ?? "",
            LocationId = loation.Id,
            StockInfoDetails = new List<DtStockInfoDetail>()
            {
                new DtStockInfoDetail()
                {
                    MaterielCode = "实托盘",
                    Id = 0,
                    Status = (int)StockStateEmun.已入库
                }
            }
        };
    }

    /// <summary>
    /// 创建实盘的库存实例模型并调用MOM入库
    /// </summary>
    private DtStockInfo CreateFullPalletStock(Dt_Task task, DtLocationInfo locationInf, DtBoxingInfo boxing)
    {
        var loation = _locationRepository.QueryFirst(x => x.RoadwayNo == task.Roadway && x.LocationCode == task.TargetAddress);
        if (loation == null)
            throw new Exception("未找到对应位置信息");

        var area = new Dt_AreaInfo();
        if (task.Roadway.Contains("FR"))
        {
            area = _areaInfoRepository.QueryFirst(x => x.AreaID == loation.AreaId);
        }
        else
        {
            //var station = _stationManagerRepository.QueryFirst(x => x.stationChildCode == task.SourceAddress);
            //if (station.stationPLC == "1017")
            //    area = _areaInfoRepository.QueryFirst(x => x.AreaID == Convert.ToInt32(station.stationNGLocation));
            //else
            //    area = _areaInfoRepository.QueryFirst(x => x.AreaID == loation.AreaId);
            //if (area == null)
            //    throw new Exception("未找到对应区域信息");

            if (boxing.ProcessCode == "OCV1")
                area = _areaInfoRepository.QueryFirst(x => x.AreaID == 6);
            else if (boxing.ProcessCode == "OCVB")
                area = _areaInfoRepository.QueryFirst(x => x.AreaID == 7);
            else
                area = _areaInfoRepository.QueryFirst(x => x.AreaID == loation.AreaId);

            if (area == null)
                throw new Exception("未找到对应区域信息");
        }

        var boxDetail = boxing.BoxingInfoDetails.Adapt<List<DtStockInfoDetail>>();
        boxDetail.ForEach(x => { x.Status = (int)StockStateEmun.已入库; });
        var stock = new DtStockInfo()
        {
            PalletCode = task.PalletCode,
            LocationCode = task.TargetAddress,
            CreateDate = DateTime.Now,
            Creater = "system",
            IsFull = boxing.IsFull,
            AreaCode = area.AreaCode,
            LocationId = loation.Id,
            StockInfoDetails = boxDetail,
            ProcessCode = boxing.ProcessCode,
            NextProcessCode = boxing.NextProcessCode,
            Remark = boxing.BoxingInfoDetails.Count().ToString(),
        };

        if (boxing.ProcessCode != "OCVB" && !task.Roadway.Contains("FR"))
        {
            // 处理请求参数
            AgingInputDto agingInputDto = new AgingInputDto()
            {
                SerialNos = boxing.BoxingInfoDetails
                    .Select(item => new SerialNoInDto { SerialNo = item.SerialNumber, PositionNo = item.OrderNo })
                    .ToList(),
                TrayBarcode = task.PalletCode,
                OpFlag = 1,
                EquipmentCode = area.Spare2,
                Software = area.Spare3
            };

            var result = _agingInOrOutInputService.GetOCVInputAsync(agingInputDto).Result;
            var respone = JsonConvert.DeserializeObject<ResponeAgingInputDto>(result.Data.ToString());

            bool isFull = false;
            if (!task.Roadway.Contains("FR"))
            {
                isFull = respone.SpecialParameterDuration.IsNullOrEmpty();
            }
            if (respone.ProductionLine == null || respone.ParameterInfos == null || respone.ParameterInfos.IsNullOrEmpty())
            {
                throw new Exception($"MOM数据返回错误,产线{respone.ProductionLine},ParameterInfos{respone.ParameterInfos}");
            }
            stock.LinedProcessFeedbackTime = respone.LinedProcessFeedbackTime;
            stock.SpecialParameterDuration = respone.SpecialParameterDuration;
            //2024年11月16日：新增字段计算应出库时间
            stock.OutboundTime = Convert.ToDateTime(respone.LinedProcessFeedbackTime == null ? DateTime.Now : respone.LinedProcessFeedbackTime).AddHours(Convert.ToDouble(respone.SpecialParameterDuration));
            stock.ProductionLine = respone.ProductionLine;
            stock.ParameterInfos = respone.ParameterInfos.ToJsonString();
            stock.StockStatus = 1;
        }
        else
        {
            stock.OutboundTime = DateTime.Now;
            stock.StockStatus = 1;
            stock.ProductionLine = boxing.ProductionLine;
        }

        // 记录日志
        LogFactory.GetLog("任务完成").InfoFormat(true, "入库任务完成", $"货位地址：{task.TargetAddress},修改后货位数据：{locationInf}");

        return stock;
    }

    #endregion 入库任务完成

    #region 任务完成

    /// <summary>
    /// 完成任务
    /// </summary>
    /// <param name="taskNum">任务编号</param>
    /// <returns>返回结果集</returns>
    public async Task<WebResponseContent> CompleteAsync(int taskNum)
    {
        // 初始化响应内容
        WebResponseContent content = new WebResponseContent();

        // 提取任务数据
        LogFactory.GetLog("任务完成").InfoFormat(true, "提取任务数据", $"任务号：{taskNum}");

        // 验证任务是否存在
        var task = await GetByTaskNum(taskNum);
        if (task == null)
        {
            return content.Error("任务不存在");
        }
        LogFactory.GetLog("任务完成").InfoFormat(true, "验证任务是否存在", JsonConvert.SerializeObject(task));

        if (task.TaskType == (int)TaskOutboundTypeEnum.InToOut)
        {
            return await CompleteInToOutTaskAsync(task);
        }
        // 验证库存是否存在
        var stock = await _stockInfoRepository.QueryFirstNavAsync(x => x.PalletCode == task.PalletCode);

        // 根据任务类型调用相应的完成任务方法
        switch (task.TaskType)
        {
            case (int)TaskInboundTypeEnum.Inbound:
            case (int)TaskInboundTypeEnum.InTray:
            case (int)TaskInboundTypeEnum.InNG:
            case (int)TaskInboundTypeEnum.InQuality:
                LogFactory.GetLog("任务完成").InfoFormat(true, "入库任务", "");
                return await CompleteInboundTaskAsync(task);

            case (int)TaskOutboundTypeEnum.OutTray:
            case (int)TaskOutboundTypeEnum.Outbound:
            case (int)TaskOutboundTypeEnum.OutNG:
                LogFactory.GetLog("任务完成").InfoFormat(true, "出库任务", "");
                return await CompleteStackTaskAsync(task, stock);

            case (int)TaskOutboundTypeEnum.OutFireAlarm:

                LogFactory.GetLog("任务完成").InfoFormat(true, "火警任务", "");
                return await CompleteOutFireAlarmTaskAsync(task, stock);

            case (int)TaskRelocationTypeEnum.Relocation:
                return await CompleteTransferTaskAsync(task, stock);

            default:
                return content.Error("任务类型不存在");
        }
    }

    #endregion 任务完成

    #region 请求任务入库

    public async Task<WebResponseContent> RequestTaskAsync(RequestTaskDto input)
    {
        WebResponseContent content = new WebResponseContent();

        try
        {
            // 查询任务
            var task = await QueryTaskByPalletCode(input.PalletCode);
            if (task != null)
            {
                return CreateAndReturnWMSTaskDTO(task);
            }

            // 查询库存信息（这里后续要完善质检回库逻辑）
            var stock = await QueryStockInfo(input.PalletCode);
            if (stock != null)
            {
                Dt_Task taskNew = new Dt_Task
                {
                    Grade = 1,
                    Roadway = stock.LocationInfo.RoadwayNo,
                    TargetAddress = stock.LocationInfo.RoadwayNo,
                    Dispatchertime = DateTime.Now,
                    MaterialNo = "",
                    NextAddress = stock.LocationInfo.RoadwayNo,
                    OrderNo = null,
                    PalletCode = stock.PalletCode,
                    SourceAddress = input.Position,
                    CurrentAddress = input.Position,
                    TaskState = stock.LocationInfo.RoadwayNo.Contains("CH") ? (int)TaskInStatusEnum.InNew : (int)TaskInStatusEnum.Line_InFinish,
                    TaskType = (int)TaskInboundTypeEnum.InQuality,
                    TaskNum = BaseDal.GetTaskNo().Result,
                    Creater = "System", // 修正拼写错误
                    CreateDate = DateTime.Now,
                    TaskId = 0,
                    ProductionLine = stock.ProductionLine,
                    ProcessCode = stock.ProcessCode,
                };

                var taskDTO = CreateTaskDTO(taskNew);
                BaseDal.AddData(taskNew);
                return content.OK(data: taskDTO);
                // TODO质检回库
            }

            // 根据位置查询区域信息
            var areaCode = Regex.Replace(input.Position, @"-(\d+)", "");
            var area = await QueryAreaInfoByPosition(areaCode);
            if (area == null)
            {
                return content.Error("该点位不在区域列表中存在");
            }

            // 创建并获取整盘电芯状态
            TrayCellsStatusDto trayCells = CreateTrayCellsStatusDto(area, input.PalletCode);
            content = await GetTrayCellStatusAsync(trayCells);
            if (!content.Status)
            {
                ConsoleHelper.WriteErrorLine($"获取电芯状态失败:{content.Message}");
                return content;
            }

            var result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(content.Data.ToString());

            if (!result.Success)
            {
                ConsoleHelper.WriteErrorLine($"获取电芯状态失败:{result.MOMMessage}");
                if (result.SerialNos.Count <= 0)
                {
                    // 空托盘入库逻辑
                    var staion = _stationManagerRepository.QueryFirst(x => x.stationChildCode == input.Position && x.stationType == 1 && x.remark == "IN");
                    if (staion != null)
                    {
                        return await HandleErrorCells(input, area);
                    }
                    else
                    {
                        return await RequestTrayInTaskAsync(input);
                    }
                }
                else
                    return content.Error(result.MOMMessage);
            }

            if (result.SerialNos.Count <= 0)
            {
                var config = _configService.GetByConfigKey(CateGoryConst.CONFIG_SYS_InStacker, SysConfigConst.InboundIsEmpty);
                var strings = config.ConfigValue.Split(',').ToList();
                if (strings.Contains(input.Position))
                {
                    // todo送至NG口
                    ConsoleHelper.WriteErrorLine($"当前位置不能入空托盘");
                    return content.Error("当前位置不能入空托盘");
                }
                else
                    return await RequestTrayInTaskAsync(input);
            }
            else
            {
                // 处理异常电芯情况
                var serialNosError = result.SerialNos.Where(x => x.SerialNoStatus != 1 && x.SerialNoStatus != 4).ToList();
                if (serialNosError.Count > 0)
                {
                    return await HandleErrorCells(input, area, serialNosError);
                }

                var boxing = CreateBoxingInfo(result, input.PalletCode);
                if (boxing == null) return content.Error("组盘失败");

                input.ProductionLine = result.ProductionLine;
                return await ProcessBasedOnProcessCode(boxing, area, input, result);
            }
        }
        catch (Exception err)
        {
            // 更详细的异常处理，可以根据异常类型记录不同的错误日志等
            content.Error(err.Message);
            Console.WriteLine(err.Message);
        }

        return content;
    }

    /// <summary>
    /// 更新任务货位
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<WebResponseContent> UpdateExistingTask(RequestTaskDto input)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == input.PalletCode);
            if (task == null)
                return content.Error($"暂未找到【{input.PalletCode}】的任务");

            return content = await UpdateExistingTask(input, task);
        }
        catch (Exception err)
        {
            return content.Error(err.Message);
        }
    }

    /// <summary>
    /// 空托盘入库申请
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public async Task<WebResponseContent> RequestTrayInTaskAsync(RequestTaskDto input)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            // 调用BaseDal.QueryFirstAsync方法，查询任务
            var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == input.PalletCode);
            if (task != null && task.TaskState == (int)TaskInStatusEnum.InNew)
            {
                // 创建WMS任务
                WMSTaskDTO taskDTO = CreateTaskDTO(task);
                return content.OK(data: task);
            }

            // 根据位置查询区域信息
            var areaCode = Regex.Replace(input.Position, @"-(\d+)", "");
            var area = await QueryAreaInfoByPosition(areaCode);
            if (area == null)
            {
                return content.Error("该点位不在区域列表中存在");
            }

            // 获取整盘电芯属性状态
            TrayCellsStatusDto trayCells = CreateTrayCellsStatusDto(area, input.PalletCode);
            content = await GetTrayCellStatusAsync(trayCells);
            if (!content.Status)
            {
                ConsoleHelper.WriteErrorLine($"获取电芯状态失败:{content.Message}");
                return content;
            }

            var result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(content.Data.ToString());
            if (result.ProductionLine.IsNullOrEmpty())
            {
                ConsoleHelper.WriteErrorLine($"当前托盘无产线,联系MOM添加产线");
                return content.Error("当前托盘无产线,联系MOM添加产线");
            }

            var stationManagers = _stationManagerRepository.QueryData(x => x.stationType == 6 && x.stationChildCode == input.Position).FirstOrDefault();
            if (stationManagers == null)
            {
                stationManagers = _stationManagerRepository.QueryData(x => x.stationType == 1 && x.stationChildCode == input.Position).FirstOrDefault();
                if (stationManagers == null)
                    throw new Exception("未找到空托盘入库站台和入库站台配置");
            }
            List<string> strings = stationManagers.Roadway.Split(',').ToList();

            return await CreateNewTask(input, result.ProductionLine, result.ProcessCode, strings, 1);
        }
        catch (Exception)
        {
            throw;
        }
    }

    // 获取托盘单元格状态
    private async Task<WebResponseContent> GetTrayCellStatusAsync(TrayCellsStatusDto trayCells)
    {
        // 调用_cellStateService.GetTrayCellStatusAsync方法，获取托盘单元格状态
        return await _cellStateService.GetTrayCellStatusAsync(trayCells);
    }

    // 获取组盘信息
    private DtBoxingInfo CreateBoxingInfo(ResultTrayCellsStatus result, string palletCode)
    {
        return new DtBoxingInfo
        {
            PalletCode = palletCode,
            IsFull = true,
            ProcessCode = result.ProcessCode,
            ProductionLine = result.ProductionLine,
            BoxingInfoDetails = result.SerialNos.Select(serialNoObj => new DtBoxingInfoDetail
            {
                SerialNumber = serialNoObj.SerialNo,
                OrderNo = serialNoObj.PositionNo.ToString(),
                Status = serialNoObj.SerialNoStatus,
                MaterielCode = result.BindCode,
                Remark = result.TrayBarcodePropertys.ToJsonString(),
            }).ToList()
        };
    }

    // 获取工艺申请
    private async Task<ProcessApplyDto> GetProcessApplyAsync(ResultTrayCellsStatus content)
    {
        // 创建一个ProcessApplyDto对象，并赋值
        return new ProcessApplyDto()
        {
            //WipOrderNo = result.BindCode,
            SerialNos = content.SerialNos.Select(item => new SerialNos
            {
                SerialNo = item.SerialNo
            }).ToList()
        };
    }

    #endregion 请求任务入库

    #region 请求出库（实盘&空盘）

    /// <summary>
    /// 请求托盘任务
    /// </summary>
    /// <param name="position">目标位置</param>
    /// <param name="tag">托盘类型（1：实盘，2：空盘）</param>
    /// <param name="areaCode">区域编码</param>
    /// <param name="roadways">巷道编码集合</param>
    /// <returns>返回结果集</returns>
    public async Task<WebResponseContent> RequestTrayOutTaskAsync(string position, int tag, string areaCode, List<string> areaCodes, string productionLine)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            // 记录异常信息并抛出
            LogFactory.GetLog($"{position}请求{productionLine}任务").Info(true, $"{position}-{tag}-{areaCode}-{JsonConvert.SerializeObject(areaCodes)}-{productionLine}");
            // 根据托盘类型查询库存信息
            DtStockInfo stockInfo = tag == (int)TaskOutboundTypeEnum.Outbound
                ? areaCode != "CWSC1" ? await QueryStockInfoForRealTrayAsync(areaCode, areaCodes, productionLine) : await QueryStockInfoForRealTrayCWAsync(areaCodes, productionLine)
                : await QueryStockInfoForEmptyTrayAsync(areaCode, position);

            if (stockInfo == null)
            {
                return content.Error("库存信息不存在");
            }

            //ConsoleHelper.WriteColorLine(JsonConvert.SerializeObject(stockInfo), ConsoleColor.DarkMagenta);

            // 新增重复任务校验
            var hasTask = BaseDal.QueryFirst(x => x.PalletCode == stockInfo.PalletCode);
            if (hasTask != null)
            {
                WMSTaskDTO taskDTO1 = CreateTaskDTO(hasTask);
                return content.OK("已存在出库任务", data: taskDTO1);
            }

            // 创建新任务实例
            var task = CreateTask(stockInfo, position, tag);
            var taskId = await BaseDal.AddDataAsync(task);
            bool isResult = taskId > 0;
            if (!isResult)
            {
                return content.Error("任务创建失败");
            }

            // 创建任务DTO
            WMSTaskDTO taskDTO = CreateTaskDTO(task);
            //if (tag == 1)
            {
                // 更新库存位置状态为不可用
                stockInfo.LocationInfo.LocationStatus = (int)LocationEnum.InStockDisable;
                await _locationRepository.UpdateDataAsync(stockInfo.LocationInfo);
            }

            // 返回成功响应
            return content.OK(data: taskDTO);
        }
        catch (Exception ex)
        {
            // 记录异常信息并抛出
            LogFactory.GetLog("请求托盘任务").Error(true, ex);
            ConsoleHelper.WriteErrorLine("请求空/实托盘任务" + ex.Message + "\r\n" + ex.StackTrace);
            return content.Error(ex.Message);
        }
    }

    /// <summary>
    /// 查询实盘库存信息
    /// </summary>
    private async Task<DtStockInfo> QueryStockInfoForRealTrayAsync(string areaCode, List<string> devices, string productionLine)
    {
        try
        {
            var area = await _areaInfoRepository.QueryFirstAsync(x => x.AreaCode == areaCode);
            if (area == null)
            {
                ConsoleHelper.WriteErrorLine($"查询实盘库存信息时,未找到区域代码为{areaCode}的数据");
                return null;
            }

            var outBoundMateriel = AppSettings.app<OutBoundMateriel>("OutBoundMateriel");
            List<string>? materielCodes = outBoundMateriel.Count != 0
                ? outBoundMateriel.Where(x => x.ProductionLine == productionLine && x.ProcessCode == area.AreaCode)
                                  .Select(x => x.MaterielCode)
                                  .ToList()
                : null;

            var result = new DtStockInfo();

            result = await _stockInfoRepository.Db.Queryable<DtStockInfo>()
                            .Includes(x => x.LocationInfo)
                            .Includes(x => x.StockInfoDetails)
                            .Where(x => x.AreaCode == areaCode && x.OutboundTime < DateTime.Now && x.IsFull)
                            .WhereIF(!productionLine.IsNullOrEmpty(), x => x.ProductionLine == productionLine)
                            .WhereIF(!devices.IsNullOrEmpty(), x => devices.Contains(x.LocationInfo.RoadwayNo))
                            .Where(x => x.LocationInfo.LocationStatus == (int)LocationEnum.InStock && x.LocationInfo.AreaId == area.AreaID && x.LocationInfo.EnalbeStatus == (int)EnableEnum.Enable)
                            .WhereIF(!materielCodes.IsNullOrEmpty(), x => x.StockInfoDetails.Any(y => materielCodes.Contains(y.MaterielCode)))
                            .OrderBy(x => x.OutboundTime)
                            .FirstAsync();

            if (result.IsNullOrEmpty())
                ConsoleHelper.WriteErrorLine($"{area.AreaName}-{productionLine}查询实盘库存信息失败:未找到符合条件的数据");

            return result;
        }
        catch (Exception ex)
        {
            ConsoleHelper.WriteErrorLine("查询实盘库存信息失败:" + ex.Message + "\r\n" + ex.StackTrace);
            return null;
        }
    }

    /// <summary>
    /// 查询常温实盘库存信息
    /// </summary>
    private async Task<DtStockInfo> QueryStockInfoForRealTrayCWAsync(List<string> areaCodes, string productionLine)
    {
        try
        {
            var areaId = (await _areaInfoRepository.QueryDataAsync(x => areaCodes.Contains(x.AreaCode))).Select(x => x.AreaID).ToList();
            if (areaId.Count == 0)
            {
                ConsoleHelper.WriteErrorLine($"查询常温实盘库存信息时,未找到区域代码为{JsonConvert.SerializeObject(areaCodes)}的数据");
                return null;
            }

            //var outBoundMateriel = AppSettings.app<OutBoundMateriel>("OutBoundMateriel");
            //List<string> materielCodes = null;
            //if (outBoundMateriel.Count != 0)
            //{
            //    materielCodes = outBoundMateriel.Where(x => x.ProductionLine == productionLine && x.ProcessCode == areaCodes[0]).Select(x => x.MaterielCode).ToList();
            //}

            var outBoundMateriel = AppSettings.app<OutBoundMateriel>("OutBoundMateriel");
            List<string>? materielCodes = outBoundMateriel.Count != 0
                ? outBoundMateriel.Where(x => x.ProductionLine == productionLine && x.ProcessCode == areaCodes[0])
                                  .Select(x => x.MaterielCode)
                                  .ToList()
                : null;

            var deviceCode = SqlSugarHelper.DbWCS.Queryable<Dt_DeviceInfo>()
                .Where(x => x.DeviceStatus == "1")
                .Where(x => x.DeviceCode.Contains("CWSC"))
                .ToList().Select(x => x.DeviceCode).ToList();

            var result = await _stockInfoRepository.Db.Queryable<DtStockInfo>()
                .Where(x => areaCodes.Contains(x.AreaCode) && x.OutboundTime < DateTime.Now && x.IsFull == true) // 过滤条件
                .WhereIF(!productionLine.IsNullOrEmpty(), x => x.ProductionLine == productionLine)
                .Includes(x=>x.LocationInfo)
                .WhereIF(!deviceCode.IsNullOrEmpty(), x => deviceCode.Contains(x.LocationInfo.RoadwayNo))
                .Where(x => x.LocationInfo.LocationStatus == (int)LocationEnum.InStock && areaId.Contains(x.LocationInfo.AreaId) && x.LocationInfo.EnalbeStatus == (int)EnableEnum.Enable) // 过滤条件
                .Includes(x=>x.StockInfoDetails)
                .WhereIF(!materielCodes.IsNullOrEmpty(), x => x.StockInfoDetails.Any(y => materielCodes.Contains(y.MaterielCode)))
                .OrderBy(x => x.OutboundTime) // 排序
                .FirstAsync(); // 获取第一个元素

            if (result.IsNullOrEmpty())
                ConsoleHelper.WriteErrorLine($"{JsonConvert.SerializeObject(areaCodes)}-{productionLine}查询常温实盘库存信息失败:未找到符合条件的数据");

            return result;
        }
        catch (Exception ex)
        {
            ConsoleHelper.WriteErrorLine("QueryStockInfoForRealTrayCWAsync查询实盘库存信息失败:" + ex.Message + "\r\n" + ex.StackTrace);
            return null;
        }
    }

    /// <summary>
    /// 查询空盘库存信息
    /// </summary>
    private async Task<DtStockInfo> QueryStockInfoForEmptyTrayAsync(string areaCode, string position)
    {
        try
        {
            var area = await _areaInfoRepository.QueryFirstAsync(x => x.AreaCode == areaCode);

            ConsoleHelper.WriteColorLine(position + "..." + areaCode, ConsoleColor.Magenta);
            var station = await _stationManagerRepository.QueryFirstAsync(x => x.stationChildCode == position && x.stationType == 17);

            ConsoleHelper.WriteColorLine(station.Roadway, ConsoleColor.Magenta);
            var stackers = station.Roadway.Split(',').ToList();

            var deviceCode = SqlSugarHelper.DbWCS.Queryable<Dt_DeviceInfo>()
                .Where(x => x.DeviceStatus == "1")
                .Where(x => stackers.Contains(x.DeviceCode))
                .ToList().Select(x => x.DeviceCode).ToList();

            var result = await _stockInfoRepository.Db.Queryable<DtStockInfo>()
                .WhereIF(!station.Roadway.Contains("JZSC"), x => x.ProductionLine == station.productLine)
                .Where(x => x.AreaCode == areaCode && x.IsFull == false)
                .Includes(x => x.StockInfoDetails)
                .Where(x => x.StockInfoDetails.Any(y => y.MaterielCode == "空托盘"))
                .Includes(x => x.LocationInfo)
                .WhereIF(!deviceCode.IsNullOrEmpty(), x => deviceCode.Contains(x.LocationInfo.RoadwayNo))
                .Where(x => x.LocationInfo.LocationStatus == (int)LocationEnum.InStock && x.LocationInfo.AreaId == area.AreaID && x.LocationInfo.EnalbeStatus == (int)EnableEnum.Enable) // 过滤条件
                .OrderBy(x => x.CreateDate) // 排序
                .FirstAsync(); // 转换为列表

            if (result.IsNullOrEmpty())
                ConsoleHelper.WriteErrorLine($"{area}-{station.productLine}查询空盘库存信息失败:未找到符合条件的数据");

            return result;
        }
        catch (Exception ex)
        {
            ConsoleHelper.WriteErrorLine($"QueryStockInfoForEmptyTrayAsync查询实盘库存信息失败:" + ex.Message + "\r\n" + ex.StackTrace);
            return null;
        }
    }

    /// <summary>
    /// 创建任务实例
    /// </summary>
    private Dt_Task CreateTask(DtStockInfo stockInfo, string position, int tag)
    {
        return new Dt_Task
        {
            Grade = tag == 104 ? (stockInfo.LocationInfo.RoadwayNo.Contains("CWSC")|| stockInfo.LocationInfo.RoadwayNo.Contains("JZSC") ? 1 : 2) : (stockInfo.LocationInfo.RoadwayNo.Contains("CWSC") || stockInfo.LocationInfo.RoadwayNo.Contains("JZSC") ? 2 : 1),
            Roadway = stockInfo.LocationInfo.RoadwayNo,
            TargetAddress = position,
            Dispatchertime = DateTime.Now,
            MaterialNo = "",
            NextAddress = position,
            OrderNo = null,
            PalletCode = stockInfo.PalletCode,
            SourceAddress = stockInfo.LocationCode,
            CurrentAddress = stockInfo.LocationCode,
            TaskState = (int)TaskOutStatusEnum.OutNew,
            TaskType = tag,
            TaskNum = BaseDal.GetTaskNo().Result,
            Creater = "System", // 修正拼写错误
            CreateDate = DateTime.Now,
            TaskId = 0,
            ProductionLine = stockInfo.ProductionLine,
            ProcessCode = stockInfo.ProcessCode,
        };
    }

    /// <summary>
    /// 创建任务DTO
    /// </summary>
    private WMSTaskDTO CreateTaskDTO(Dt_Task task)
    {
        return new WMSTaskDTO
        {
            TaskNum = task.TaskNum.Value,
            Grade = task.Grade.Value,
            PalletCode = task.PalletCode,
            RoadWay = task.Roadway,
            SourceAddress = task.SourceAddress,
            TargetAddress = task.TargetAddress,
            TaskState = task.TaskState.Value,
            Id = 0,
            TaskType = task.TaskType,
            ProductionLine = task.ProductionLine,
        };
    }

    #endregion 请求出库（实盘&空盘）

    #region 任务状态更改

    /// <summary>
    /// 更新任务状态&出库解盘
    /// </summary>
    /// <param name="taskNum"></param>
    /// <param name="taskState"></param>
    /// <returns></returns>
    public async Task<WebResponseContent> UpdateTaskStatus(int taskNum, int taskState)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var task = await BaseDal.QueryFirstAsync(x => x.TaskNum == taskNum);
            if (task == null)
                return content.Error("未找到任务");

            if (taskState == (int)TaskOutStatusEnum.Line_OutFinish || taskState == (int)TaskInStatusEnum.SC_InFinish)
            {
                var taskHty = CreateHistoricalTask(task);
                await _unitOfWorkManage.UseTranAsync(async () =>
                {
                    var asb = await BaseDal.DeleteDataByIdAsync(task.TaskId);
                    var asbHty = await _task_HtyRepository.AddDataAsync(taskHty) > 0;
                    if (asb && asbHty)
                        content.OK();
                    else
                        throw new Exception();
                });
                content.OK();
            }
            else
            {
                task.TaskState = taskState;
                var asb = await BaseDal.UpdateDataAsync(task);
                if (asb)
                    content.OK();
                else
                    content.Error();
            }
        }
        catch (Exception ex)
        {
            content.Error(ex.Message);
        }
        return content;
    }

    #endregion 任务状态更改

    #region 指定任务出库

    public async Task<WebResponseContent> CreateAndSendOutboundTask(string locationCode, string palletCode)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            // 查询库存信息
            var stockInfo = await _stockInfoRepository.QueryFirstNavAsync(x => x.LocationCode == locationCode && x.PalletCode == palletCode);
            if (stockInfo == null)
            {
                return content.Error("未查询到对应的库存信息");
            }
            if (stockInfo.LocationInfo.LocationStatus != (int)LocationEnum.InStock)
            {
                return content.Error("该货位状态不等于【有货】请查看是否已经有任务！");
            }

            var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == palletCode);
            if (task != null)
            {
                return content.Error($"【{palletCode}】已存在任务");
            }

            int taskType = 0;
            if (stockInfo.IsFull)
                taskType = (int)TaskOutboundTypeEnum.OutQuality;
            else
                taskType = (int)TaskOutboundTypeEnum.OutTray;

            if (stockInfo.AreaCode.Contains("CH"))
            {
                // 创建并添加任务到数据库
                task = CreateTask(stockInfo, "002-071-001", taskType);
            }
            else
            {
                if (stockInfo.LocationInfo.RoadwayNo.Contains("JZSC"))
                {
                    var targetAddress = "001-061-001";
                    //if (stockInfo.LocationInfo.RoadwayNo == "JZSC4")
                    //    targetAddress = "001-021-001";
                    task = CreateTask(stockInfo, targetAddress, taskType);
                }
            }
            //var taskId = await BaseDal.AddDataAsync(task);
            //if (taskId <= 0)
            //{
            //    return content.Error("任务创建失败");
            //}

            // 创建任务传输用的DTO对象
            var taskDTO = CreateTaskDTO(task);

            // 获取WMS IP地址用于发送任务请求
            var wmsIpAddress = GetWCSIpReceiveTask();
            if (wmsIpAddress == null)
            {
                throw new InvalidOperationException("WMS IP 未配置");
            }

            var tasks = new List<WMSTaskDTO>() { taskDTO };
            // 发送任务请求到WMS
            var result = await HttpHelper.PostAsync(wmsIpAddress, tasks.ToJsonString());
            content = JsonConvert.DeserializeObject<WebResponseContent>(result);
            if (content.Status)
            {
                // 添加任务到数据库
                await BaseDal.AddDataAsync(task);
                // 更新库存位置状态为不可用
                stockInfo.LocationInfo.LocationStatus = (int)LocationEnum.InStockDisable;
                await _locationRepository.UpdateDataAsync(stockInfo.LocationInfo);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"发生异常: {ex.Message}");
            content.Error(ex.Message);
        }

        return content;
    }

    private string GetWCSIpReceiveTask()
    {
        var configs = _configService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
        var wmsBase = configs.FirstOrDefault(x => x.ConfigKey == SysConfigConst.WCSIPAddress)?.ConfigValue;
        var ipAddress = configs.FirstOrDefault(x => x.ConfigKey == SysConfigConst.ReceiveTask)?.ConfigValue;
        if (wmsBase == null || ipAddress == null)
        {
            return null;
        }
        return wmsBase + ipAddress;
    }

    #endregion 指定任务出库

    #region 静置异常口入库

    public async Task<WebResponseContent> CreateAndSendInboundTask(string palletCode, string position)
    {
        #region
        //WebResponseContent content = new WebResponseContent();
        //try
        //{
        //    // 查询库存信息
        //    var stockInfo = await _stockInfoRepository.QueryFirstNavAsync(x => x.PalletCode == palletCode);
        //    if (stockInfo == null)
        //    {
        //        var taskOld = BaseDal.QueryFirst(x => x.PalletCode == palletCode);
        //        if (!taskOld.IsNullOrEmpty())
        //        {// 创建WMS任务
        //            WMSTaskDTO taskDTO = new WMSTaskDTO()
        //            {
        //                TaskNum = taskOld.TaskNum.Value,
        //                Grade = 1,
        //                PalletCode = taskOld.PalletCode,
        //                RoadWay = taskOld.Roadway,
        //                SourceAddress = taskOld.CurrentAddress,
        //                TargetAddress = taskOld.TargetAddress,
        //                TaskState = taskOld.TaskState.Value,
        //                Id = 0,
        //                TaskType = taskOld.TaskType,
        //            };
        //            return content.OK(data: taskDTO);
        //        }
        //        var area = _areaInfoRepository.QueryFirst(x => x.AreaID == 2);
        //        var station = _stationManagerRepository.QueryFirst(x => x.stationChildCode == position);
        //        TrayCellsStatusDto trayCells = CreateTrayCellsStatusDto(area, palletCode);
        //        content = await GetTrayCellStatusAsync(trayCells);
        //        if (!content.Status) return content;

        //        ConsoleHelper.WriteErrorLine(content.ToJsonString());
        //        var result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(content.Data.ToString());
        //        if (!result.Success) return content.Error(result.MOMMessage);

        //        if (result.SerialNos.Count > 0)
        //        {
        //            var boxing = CreateBoxingInfo(result, palletCode);
        //            if (boxing == null) return content.Error("组盘失败");

        //            // 获取工艺路线
        //            ProcessApplyDto process = await GetProcessApplyAsync(result);
        //            // 赋值上位软件名称和设备编码
        //            process.Software = area.Spare3;
        //            process.EquipmentCode = area.Spare2;
        //            content = await _processApplyService.GetProcessApplyAsync(process);
        //            if (!content.Status) return content.Error("工艺申请失败");

        //            var resultProcessApply = JsonConvert.DeserializeObject<ResultProcessApply>(content.Data.ToString());
        //            if (!resultProcessApply.Success) return content.Error("工艺申请失败");

        //            var number = resultProcessApply.ProcessInfo.Where(x => x.ProcessCode.Contains(boxing.ProcessCode)).FirstOrDefault().Number.ToInt32();
        //            foreach (var item in resultProcessApply.ProcessInfo)
        //            {
        //                if (item.Number.ToInt32() == number + 1)
        //                {
        //                    boxing.NextProcessCode = item.ProcessCode;
        //                }
        //            }
        //            var location = await GetLocationDistributeAsync(station.Roadway);

        //            ConsoleHelper.WriteErrorLine(location.ToJsonString());

        //            // 创建新任务实例
        //            var task = new Dt_Task
        //            {
        //                CurrentAddress = station.stationLocation,
        //                Grade = 1,
        //                Roadway = station.Roadway,
        //                TargetAddress = location.LocationCode,
        //                Dispatchertime = DateTime.Now,
        //                MaterialNo = "",
        //                NextAddress = location.LocationCode,
        //                OrderNo = null,
        //                PalletCode = palletCode,
        //                SourceAddress = position,
        //                TaskState = (int)TaskInStatusEnum.Line_InFinish,
        //                TaskType = (int)TaskInboundTypeEnum.Inbound,
        //                TaskNum = await BaseDal.GetTaskNo(),
        //                Creater = "Systeam"
        //            };

        //            // 创建WMS任务
        //            WMSTaskDTO taskDTO = new WMSTaskDTO()
        //            {
        //                TaskNum = task.TaskNum.Value,
        //                Grade = 1,
        //                PalletCode = task.PalletCode,
        //                RoadWay = task.Roadway,
        //                SourceAddress = task.SourceAddress,
        //                TargetAddress = task.TargetAddress,
        //                TaskState = task.TaskState.Value,
        //                Id = 0,
        //                TaskType = task.TaskType,
        //            };

        //            await _unitOfWorkManage.UseTranAsync(async () =>
        //            {
        //                // 添加任务到数据库
        //                await BaseDal.AddDataAsync(task);
        //                // 更新库存位置状态为不可用
        //                location.LocationStatus = (int)LocationEnum.InStockDisable;
        //                await _locationRepository.UpdateDataAsync(location);
        //                await _boxingInfoRepository.AddDataNavAsync(boxing);
        //            });

        //            content.OK(data: taskDTO);
        //        }
        //        else
        //            content.Error(result.MOMMessage);
        //    }
        //    else
        //    {
        //        // TODO质检回库
        //        var area = _areaInfoRepository.QueryFirst(x => x.AreaID == 2);
        //    }
        //}
        //catch (Exception ex)
        //{
        //    content.Error(ex.Message);
        //}
        //return content;
        #endregion 静置异常口入库
        WebResponseContent content = new WebResponseContent();
        try
        {
            // 查询库存信息
            var stockInfo = await _stockInfoRepository.QueryFirstNavAsync(x => x.PalletCode == palletCode);
            if (stockInfo == null)
            {
                var taskOld = BaseDal.QueryFirst(x => x.PalletCode == palletCode);
                if (taskOld != null)
                {
                    // 创建WMS任务
                    WMSTaskDTO taskDTO = CreateWMSTaskDTO(taskOld);
                    return content.OK(data: taskDTO);
                }
                var area = _areaInfoRepository.QueryFirst(x => x.AreaID == 2);
                var station = _stationManagerRepository.QueryFirst(x => x.stationChildCode == position);
                TrayCellsStatusDto trayCells = CreateTrayCellsStatusDto(area, palletCode);
                content = await GetTrayCellStatusAsync(trayCells);
                if (!content.Status) return content;

                ConsoleHelper.WriteErrorLine(content.ToJsonString());
                var result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(content.Data.ToString());
                if (result == null) return content.Error(result?.MOMMessage ?? "Deserialization error");

                if (result.SerialNos.Count > 0)
                {
                    var boxing = CreateBoxingInfo(result, palletCode);
                    if (boxing == null) return content.Error("组盘失败");

                    // 获取工艺路线
                    ProcessApplyDto process = await GetProcessApplyAsync(result);
                    // 赋值上位软件名称和设备编码
                    process.Software = area.Spare3;
                    process.EquipmentCode = area.Spare2;

                    content = await _processApplyService.GetProcessApplyAsync(process);
                    if (!content.Status) return content.Error("工艺申请失败");

                    var resultProcessApply = JsonConvert.DeserializeObject<ResultProcessApply>(content.Data.ToString()) as ResultProcessApply;
                    if (resultProcessApply == null || !resultProcessApply.Success) return content.Error("工艺申请失败");

                    var number = resultProcessApply.ProcessInfo.Where(x => x.ProcessCode.Contains(boxing.ProcessCode)).FirstOrDefault()?.Number.ToInt32() ?? 0;
                    foreach (var item in resultProcessApply.ProcessInfo)
                    {
                        if (item.Number.ToInt32() == number + 1)
                        {
                            boxing.NextProcessCode = item.ProcessCode;
                        }
                    }
                    var location = await GetLocationDistributeAsync(station.Roadway);

                    ConsoleHelper.WriteErrorLine(location.ToJsonString());

                    // 创建新任务实例
                    var task = new Dt_Task
                    {
                        CurrentAddress = station.stationLocation,
                        Grade = 1,
                        Roadway = station.Roadway,
                        TargetAddress = location.LocationCode,
                        Dispatchertime = DateTime.Now,
                        MaterialNo = "",
                        NextAddress = location.LocationCode,
                        OrderNo = null,
                        PalletCode = palletCode,
                        SourceAddress = position,
                        TaskState = (int)TaskInStatusEnum.Line_InFinish,
                        TaskType = (int)TaskInboundTypeEnum.Inbound,
                        TaskNum = await BaseDal.GetTaskNo(),
                        Creater = "System",
                        ProductionLine = result.ProductionLine,
                        ProcessCode = result.ProcessCode,
                    };

                    // 创建WMS任务
                    WMSTaskDTO taskDTO = CreateWMSTaskDTO(task);

                    await _unitOfWorkManage.UseTranAsync(async () =>
                    {
                        // 添加任务到数据库
                        await BaseDal.AddDataAsync(task);
                        // 更新库存位置状态为不可用
                        location.LocationStatus = (int)LocationEnum.Lock;
                        await _locationRepository.UpdateDataAsync(location);
                        await _boxingInfoRepository.AddDataNavAsync(boxing);
                    });

                    content.OK(data: taskDTO);
                }
                else
                {
                    var location = await GetLocationDistributeAsync(station.Roadway);
                    var task = new Dt_Task
                    {
                        CurrentAddress = station.stationLocation,
                        Grade = 1,
                        Roadway = station.Roadway,
                        TargetAddress = location.LocationCode,
                        Dispatchertime = DateTime.Now,
                        MaterialNo = "",
                        NextAddress = location.LocationCode,
                        OrderNo = null,
                        PalletCode = palletCode,
                        SourceAddress = position,
                        TaskState = (int)TaskInStatusEnum.Line_InFinish,
                        TaskType = (int)TaskInboundTypeEnum.InTray,
                        TaskNum = await BaseDal.GetTaskNo(),
                        Creater = "System",
                        ProductionLine = result.ProductionLine,
                        ProcessCode = result.ProcessCode,
                    };
                    // 创建WMS任务
                    WMSTaskDTO taskDTO = CreateWMSTaskDTO(task);

                    await _unitOfWorkManage.UseTranAsync(async () =>
                    {
                        // 添加任务到数据库
                        await BaseDal.AddDataAsync(task);
                        // 更新库存位置状态为不可用
                        location.LocationStatus = (int)LocationEnum.Lock;
                        await _locationRepository.UpdateDataAsync(location);
                    });

                    content.OK(data: taskDTO);
                }
            }
            else
            {
                // TODO质检回库
                var area = _areaInfoRepository.QueryFirst(x => x.AreaID == 2);
            }
        }
        catch (Exception ex)
        {
            // 更详细的日志记录，可使用日志框架替换 Console.WriteLine
            Console.WriteLine($"Error in CreateAndSendInboundTask: {ex.Message}");
            content.Error(ex.Message);
        }
        return content;
    }

    private WMSTaskDTO CreateWMSTaskDTO(object source)
    {
        if (source is Dt_Task taskOld)
        {
            return new WMSTaskDTO()
            {
                TaskNum = taskOld.TaskNum.Value,
                Grade = 1,
                PalletCode = taskOld.PalletCode,
                RoadWay = taskOld.Roadway,
                SourceAddress = taskOld.SourceAddress,
                TargetAddress = taskOld.TargetAddress,
                TaskState = taskOld.TaskState.Value,
                Id = 0,
                TaskType = taskOld.TaskType,
                ProductionLine = taskOld.ProductionLine
            };
        }
        else if (source is Dt_Task task)
        {
            return new WMSTaskDTO()
            {
                TaskNum = task.TaskNum.Value,
                Grade = 1,
                PalletCode = task.PalletCode,
                RoadWay = task.Roadway,
                SourceAddress = task.SourceAddress,
                TargetAddress = task.TargetAddress,
                TaskState = task.TaskState.Value,
                Id = 0,
                TaskType = task.TaskType,
                ProductionLine = task.ProductionLine
            };
        }
        else
        {
            throw new ArgumentException("Invalid source object type for WMSTaskDTO creation.");
        }
    }

    #endregion 外部接口方法

    #region  静置查询实托
    public async Task<WebResponseContent> QueryStockInfoForRealTrayJZAsync(string ProductLine, string PalletCode)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var deviceCode = SqlSugarHelper.DbWCS.Queryable<Dt_DeviceInfo>()
                .Where(x => x.DeviceStatus == "1")
                .Where(x => x.DeviceCode.Contains("JZSC"))
                .ToList().Select(x => x.DeviceCode).ToList();

            var result = await _stockInfoRepository.Db.Queryable<DtStockInfo>()
                .Where(x=> x.IsFull == true) // 过滤条件
                .WhereIF(!ProductLine.IsNullOrEmpty(), x => x.ProductionLine == ProductLine)
                .Includes(x => x.LocationInfo)
                .WhereIF(!deviceCode.IsNullOrEmpty(), x => deviceCode.Contains(x.LocationInfo.RoadwayNo))
                .Where(x => x.LocationInfo.LocationStatus == (int)LocationEnum.InStock && x.LocationInfo.AreaId==2 && x.LocationInfo.EnalbeStatus == (int)EnableEnum.Enable) // 过滤条件
                .Includes(x => x.StockInfoDetails)
                .OrderBy(x => x.OutboundTime) // 排序
                .FirstAsync();
            if (result.IsNullOrEmpty())
                content.Error();
            else
                content.OK();
            LogFactory.GetLog($"静置查询实盘库存{ProductLine}").Info(true, $"托盘号：{JsonConvert.SerializeObject(result.PalletCode)}-----产线{JsonConvert.SerializeObject(result.ProductionLine)}");
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
        return content;
    }

    #endregion

    #region 查询静置空闲库位
    public WebResponseContent QueryLocationFreeJZ(string RoadwayNo)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var result = _locationRepository.QueryData(x => x.EnalbeStatus != (int)EnableEnum.Disable && x.LocationStatus == (int)LocationEnum.Free && x.RoadwayNo.Contains("JZSC"));
            LogFactory.GetLog($"静置{RoadwayNo}查询空闲库位").Info(true, $"{JsonConvert.SerializeObject(result)}");
            if (result.Count > 5)
            {
                return content.OK();
            }
            return content.Error("库位已满");
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }

    #endregion

    #region 大屏接口

    /// <summary>
    /// 获取任务信息
    /// </summary>
    /// <returns></returns>
    public WebResponseContent GetTaskInfo()
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var task = BaseDal.QueryData(x => true).ToList();
            var newTask = task.Select(x => new
            {
                x.PalletCode,
                x.Roadway,
                x.SourceAddress,
                x.TargetAddress,
                x.ProductionLine,
                TaskType = new List<string> { GetTaskTypeDesc(x.TaskType) }[0], // 每个任务独立生成 TaskType
                TaskState = new List<string> { GetTaskStateDesc(x.TaskState) }[0] // 每个任务独立生成 TaskState
            }).ToList();

            return content.OK(data: newTask);
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }
    /// <summary>
    /// 获取库存信息
    /// </summary>
    /// <returns></returns>
    public WebResponseContent GetStockInfo()
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var now = DateTime.Now;
            var startOfDay = new DateTime(now.Year, now.Month, now.Day);
            var endOfDay = startOfDay.AddDays(1);
            var filteredItems = _stockInfoRepository.Db.Queryable<DtStockInfo>()
                                .Where(x => x.OutboundTime >= startOfDay && x.OutboundTime < endOfDay && x.IsFull)
                                .Includes(x => x.StockInfoDetails)
                                .ToList();

            var result = filteredItems
                .GroupBy(x => x.AreaCode)
                .Select(g => new GroupedStockInfo
                {
                    AreaCode = g.Key,
                    TotalQuantity = g.Sum(item => item.StockInfoDetails?.Count ?? 0),
                    Items = g.ToList()
                })
                .ToList();
            return content.OK(data: result);
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }
    /// <summary>
    /// 获取货位状态
    /// </summary>
    /// <returns></returns>
    public WebResponseContent GetStockQuantity()
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var location = _locationRepository.Db.Queryable<DtLocationInfo>().ToList();

            return content.OK(data: location);

        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }
    public WebResponseContent Getproductionvolume()
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var now = DateTime.Now;
            var startOfDay = new DateTime(now.Year, now.Month, now.Day);
            var endOfDay1 = startOfDay.AddDays(-7);
            var taskHty = _task_HtyRepository.Db.Queryable<Dt_Task_Hty>().Where(it => it.CreateDate > endOfDay1).ToList();
            return content.OK(data: taskHty);
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }

    }

    public WebResponseContent Getoutput()
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var now = DateTime.Now;
            var firstDayOfYear = new DateTime(now.Year, 1, 1);
            var taskHty = _task_HtyRepository.Db.Queryable<Dt_Task_Hty>().Where(it => it.CreateDate > firstDayOfYear&&it.TaskType==100).ToList();
            return content.OK(data: taskHty);
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }

    }
    #endregion
    public WebResponseContent GetTimeout()
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var now = DateTime.Now;
            // 使用Subtract方法
            var threeHoursAgo = now.Subtract(TimeSpan.FromHours(3));

            List<DtStockInfo> dtStocks = _stockInfoRepository.Db.Queryable<DtStockInfo>()
                               .Where(x => x.OutboundTime < threeHoursAgo).ToList();
            return content.OK1(total1: dtStocks.Count, data: dtStocks);
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }

    }

    public WebResponseContent Getproductionstatistics()
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var now = DateTime.Now;
            var thirtyDaysAgo = now.AddDays(-30);
            var roadwayMappings = new Dictionary<string, string> {
                    { "JZ", "静置库" },
                    { "CH", "陈化库" },
                    { "FR", "分容库" },
                    { "GW", "高温库" },
                    { "CW", "常温库" }
                };

            var roadwayKeys = roadwayMappings.Keys.ToArray();

            var taskHty = _task_HtyRepository.Db.Queryable<Dt_Task_Hty>()
                .Where(it =>
                    it.CreateDate >= thirtyDaysAgo &&
                    it.CreateDate <= now &&
                    it.TaskType == 100 &&
                    roadwayKeys.Any(rk => it.Roadway.Contains(rk)))
                .ToList()
                .Select(t => new {
                    OriginalRoadway = t.Roadway,
                    MatchedKey = roadwayKeys.FirstOrDefault(rk => t.Roadway.Contains(rk)),
                    CreateDate = t.CreateDate
                })
                .Where(t => t.MatchedKey != null)
                .GroupBy(t => new {
                    RoadwayKey = t.MatchedKey,
                    Date = t.CreateDate.Date,
                    Hour = t.CreateDate.Hour
                })
                .OrderByDescending(group => group.Key.Date)
                .ThenByDescending(group => group.Key.Hour)
                .Select(group => new {
                    Hour = $"{group.Key.Date:yyyy/M/d} {group.Key.Hour}:00",
                    Count = group.Count(),
                    Roadway = roadwayMappings[group.Key.RoadwayKey] // 映射为中文名称
                })
                .ToList();
            return content.OK1(total1: taskHty.Count, data: taskHty);
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }
    #endregion 外部接口方法

    #region 内部调用方法

    /// <summary>
    /// 创建一个新的任务
    /// </summary>
    /// <param name="model">任务模型</param>
    /// <returns>创建的任务</returns>
    public async Task<Dt_Task> Create(Dt_Task model)
    {
        return await BaseDal.Create(model);
    }

    /// <summary>
    /// 批量创建任务
    /// </summary>
    /// <param name="models">任务模型列表</param>
    /// <returns>是否创建成功</returns>
    public async Task<bool> Create(List<Dt_Task> models)
    {
        return await BaseDal.Create(models);
    }

    /// <summary>
    /// 删除一个任务
    /// </summary>
    /// <param name="id">任务ID</param>
    /// <returns>是否删除成功</returns>
    public async Task<bool> Delete(int id)
    {
        return await BaseDal.Delete(id);
    }

    /// <summary>
    /// 批量删除任务
    /// </summary>
    /// <param name="ids">任务ID列表</param>
    /// <returns>是否删除成功</returns>
    public async Task<bool> Delete(List<int> ids)
    {
        return await BaseDal.Delete(ids);
    }

    public override WebResponseContent DeleteData(object[] key)
    {
        WebResponseContent content = new WebResponseContent();
        // 创建历史任务实例模型
        try
        {
            foreach (var item in key)
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskId == Convert.ToInt32(key));
                if (task == null)
                {
                    return content.Error("未找到任务信息!");
                }
                var taskHtyNG = CreateHistoricalTask(task, true);

                // 执行数据库事务

                // 添加历史任务
                var isTaskHtyAdd = _task_HtyRepository.AddData(taskHtyNG) > 0;

                // 删除任务数据
                var isTaskDelete = BaseDal.Delete(task.TaskId);
            }

            return content.OK("删除成功!");
        }
        catch (Exception ex)
        {
            return content.Error("删除任务异常：" + ex.Message);
        }
    }

    /// <summary>
    /// 通过ID获取任务
    /// </summary>
    /// <param name="id">任务ID</param>
    /// <returns>任务模型</returns>
    public async Task<Dt_Task> GetById(int id)
    {
        return await BaseDal.GetById(id);
    }

    /// <summary>
    /// 获取所有任务列表
    /// </summary>
    /// <returns>任务模型列表</returns>
    public async Task<List<Dt_Task>> GetList()
    {
        return await BaseDal.GetList();
    }

    /// <summary>
    /// 根据出库订单ID获取任务列表
    /// </summary>
    /// <param name="outOrderId">出库订单ID</param>
    /// <returns>任务模型列表</returns>
    public async Task<List<Dt_Task>> GetListByOutOrder(int outOrderId)
    {
        return await BaseDal.GetListByOutOrder(outOrderId);
    }

    /// <summary>
    /// 根据出库订单ID和状态获取任务列表
    /// </summary>
    /// <param name="outOrderId">出库订单ID</param>
    /// <param name="status">任务状态</param>
    /// <returns>任务模型列表</returns>
    public async Task<List<Dt_Task>> GetListByOutOrderAndStatus(int outOrderId, int status)
    {
        return await BaseDal.GetListByOutOrderAndStatus(outOrderId, status);
    }

    /// <summary>
    /// 根据状态获取任务列表
    /// </summary>
    /// <param name="status">任务状态</param>
    /// <returns>任务模型列表</returns>
    public async Task<List<Dt_Task>> GetListByStatus(int status)
    {
        return await BaseDal.GetListByStatus(status);
    }

    /// <summary>
    /// 更新一个任务
    /// </summary>
    /// <param name="model">任务模型</param>
    /// <returns>是否更新成功</returns>
    public async Task<bool> Update(Dt_Task model)
    {
        return await BaseDal.UpdateDataAsync(model);
    }

    /// <summary>
    /// 批量更新任务
    /// </summary>
    /// <param name="models">任务模型列表</param>
    /// <returns>是否更新成功</returns>
    public async Task<bool> Update(List<Dt_Task> models)
    {
        return await BaseDal.UpdateDataAsync(models);
    }

    /// <summary>
    /// 检查任务是否存在
    /// </summary>
    /// <param name="palletCode">托盘编码</param>
    /// <returns>任务是否存在</returns>
    public bool IsExist(string palletCode)
    {
        return Db.Queryable<Dt_Task>().Any(x => x.PalletCode == palletCode);
    }

    /// <summary>
    /// 根据货位ID获取任务
    /// </summary>
    /// <param name="locationID"></param>
    /// <returns></returns>
    public async Task<Dt_Task> GetByLocation(string locationID)
    {
        return await BaseDal.QueryFirstAsync(x => x.SourceAddress == locationID);
    }

    /// <summary>
    /// 根据任务号获取任务
    /// </summary>
    /// <param name="taskNum"></param>
    /// <returns></returns>
    public async Task<Dt_Task> GetByTaskNum(int taskNum)
    {
        return await BaseDal.QueryFirstAsync(x => x.TaskNum == taskNum);
    }

    #endregion 内部调用方法

    #region private 内部方法


    /// <summary>
    /// 获取任务类型描述方法
    /// </summary>
    /// <param name="taskType"></param>
    /// <returns></returns>
    private string GetTaskTypeDesc(int taskType)
    {
        return taskType switch
        {
            (int)TaskInboundTypeEnum.Inbound => TaskInboundTypeEnum.Inbound.GetIntegralRuleTypeEnumDesc(),
            (int)TaskInboundTypeEnum.InTray => TaskInboundTypeEnum.InTray.GetIntegralRuleTypeEnumDesc(),
            (int)TaskInboundTypeEnum.InNG => TaskInboundTypeEnum.InNG.GetIntegralRuleTypeEnumDesc(),
            (int)TaskInboundTypeEnum.InQuality => TaskInboundTypeEnum.InQuality.GetIntegralRuleTypeEnumDesc(),
            (int)TaskOutboundTypeEnum.OutTray => TaskOutboundTypeEnum.OutTray.GetIntegralRuleTypeEnumDesc(),
            (int)TaskOutboundTypeEnum.Outbound => TaskOutboundTypeEnum.Outbound.GetIntegralRuleTypeEnumDesc(),
            (int)TaskOutboundTypeEnum.OutNG => TaskOutboundTypeEnum.OutNG.GetIntegralRuleTypeEnumDesc(),
        };
    }

    // 定义获取任务状态描述方法
    private string GetTaskStateDesc(int? taskState)
    {
        return taskState switch
        {
            (int)TaskInStatusEnum.InNew => TaskInStatusEnum.InNew.GetIntegralRuleTypeEnumDesc(),
            (int)TaskInStatusEnum.Line_InExecuting => TaskInStatusEnum.Line_InExecuting.GetIntegralRuleTypeEnumDesc(),
            (int)TaskInStatusEnum.Line_InFinish => TaskInStatusEnum.Line_InFinish.GetIntegralRuleTypeEnumDesc(),
            (int)TaskInStatusEnum.SC_InExecuting => TaskInStatusEnum.SC_InExecuting.GetIntegralRuleTypeEnumDesc(),
            (int)TaskInStatusEnum.SC_InFinish => TaskInStatusEnum.SC_InFinish.GetIntegralRuleTypeEnumDesc(),
            (int)TaskOutStatusEnum.OutNew => TaskOutStatusEnum.OutNew.GetIntegralRuleTypeEnumDesc(),
            (int)TaskOutStatusEnum.SC_OutExecuting => TaskOutStatusEnum.SC_OutExecuting.GetIntegralRuleTypeEnumDesc(),
            (int)TaskOutStatusEnum.SC_OutFinish => TaskOutStatusEnum.SC_OutFinish.GetIntegralRuleTypeEnumDesc(),
            (int)TaskOutStatusEnum.Line_OutExecuting => TaskOutStatusEnum.Line_OutExecuting.GetIntegralRuleTypeEnumDesc(),
            (int)TaskOutStatusEnum.Line_OutFinish => TaskOutStatusEnum.Line_OutFinish.GetIntegralRuleTypeEnumDesc(),
        };
    }

    /// <summary>
    /// 创建历史任务记录
    /// </summary>
    /// <param name="task"></param>
    /// <returns></returns>
    private Dt_Task_Hty CreateHistoricalTask(Dt_Task task, bool isHand = false)
    {
        // 更新任务状态
        task.TaskState = task.TaskType > 199 ? (int)TaskInStatusEnum.InFinish : (int)TaskOutStatusEnum.OutFinish;
        task.CurrentAddress = task.NextAddress;

        // 创建历史任务
        var taskHty = _mapper.Map<Dt_Task_Hty>(task);
        taskHty.FinishTime = DateTime.Now;
        taskHty.TaskId = 0;
        taskHty.OperateType = isHand ? (int)OperateTypeEnum.人工删除 : App.User.UserName != null ? (int)OperateTypeEnum.人工完成 : (int)OperateTypeEnum.自动完成;
        taskHty.SourceId = task.TaskId;
        if (isHand)
        {
            taskHty.Creater = App.User.UserName != null ? App.User.UserName : "System";
        }
        taskHty.TaskState = task.TaskType > 199 ? (int)TaskInStatusEnum.InFinish : (int)TaskOutStatusEnum.OutFinish;
        return taskHty;
    }

    /// <summary>
    /// 更新库存位置
    /// </summary>
    /// <param name="stock">库存对象</param>
    /// <param name="toLocation">目标位置</param>
    // 更新库存和位置信息
    private (DtStockInfo, DtLocationInfo, DtLocationInfo) UpdateStockLocation(DtStockInfo stock, Dt_Task task)
    {
        //修改来源库位和 目标库位状态
        var fromLocation = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress && x.RoadwayNo == task.Roadway);
        fromLocation.LocationStatus = LocationEnum.Free.ObjToInt();
        var toLocation = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress && x.RoadwayNo == task.Roadway);
        toLocation.LocationStatus = LocationEnum.InStock.ObjToInt();

        // 将库存位置设置为目标位置
        stock.LocationCode = task.TargetAddress;

        // 返回更新后的库存和位置信息
        return (stock, fromLocation, toLocation);
    }

    /// <summary>
    /// 执行数据库事务
    /// </summary>
    /// <param name="stock">库存对象</param>
    /// <param name="taskHty">历史任务对象</param>
    /// <param name="taskId">任务ID</param>
    /// <returns></returns>
    private async Task<bool> ExecuteTransaction(DtStockInfo stock, Dt_Task_Hty taskHty, DtLocationInfo locationInfo, int taskId, DtBoxingInfo boxingInfo = null)
    {
        _unitOfWorkManage.BeginTran();
        try
        {
            var isUpdateStock = true;
            var isDeleteBoxing = true;
            if (taskHty.TaskType == (int)TaskTypeEnum.Outbound)
            {
                // 更新库存
                isUpdateStock = await _stockInfoRepository.UpdateDataAsync(stock);
            }
            else
            {
                // 添加库存
                isUpdateStock = await _stockInfoRepository.AddDataNavAsync(stock);
                if (boxingInfo != null)
                {
                    isDeleteBoxing = await _boxingInfoRepository.Db.DeleteNav<DtBoxingInfo>(x => x.Id == boxingInfo.Id)
                                            .Include(x => x.BoxingInfoDetails)
                                            .ExecuteCommandAsync();
                }
            }

            #region 更新库存信息（暂时不需要）
            if (stock.IsFull)
            {
                // 查询符合条件的库存信息
                var stocks = _stockInfoRepository.QueryData(x => x.AreaCode == stock.AreaCode && x.ProductionLine == stock.ProductionLine && x.SpecialParameterDuration != stock.SpecialParameterDuration);

                // 查询任务信息
                var tasks = BaseDal.QueryData(x => x.PalletCode != stock.PalletCode && x.ProductionLine == stock.ProductionLine).Select(x => x.PalletCode).ToList();

                if (stocks != null && stocks.Count > 0)
                {
                    // 过滤出需要更新的库存信息
                    var stocksToUpdate = stocks.Where(item => !tasks.Contains(item.PalletCode)).ToList();
                    foreach (var item in stocksToUpdate)
                    {
                        // 更新库存信息的特定参数
                        item.SpecialParameterDuration = stock.SpecialParameterDuration;
                        item.ParameterInfos = stock.ParameterInfos;
                        item.OutboundTime = Convert.ToDateTime(item.LinedProcessFeedbackTime == null ? item.CreateDate : item.LinedProcessFeedbackTime).AddHours(Convert.ToDouble(stock.SpecialParameterDuration));
                    }
                    if (stocksToUpdate.Count > 0)
                    {
                        // 异步更新库存信息
                        var isUpdates = await _stockInfoRepository.UpdateDataAsync(stocksToUpdate);
                    }
                }
            }
            #endregion

            // 添加历史任务
            var isTaskHtyAdd = await _task_HtyRepository.AddDataAsync(taskHty) > 0;

            // 修改移库前货位状态
            var isUpdateLoc = _locationRepository.UpdateData(locationInfo);

            // 删除任务数据
            var isTaskDelete = await Delete(taskId);

            // 提交或回滚事务
            if (isUpdateStock && isTaskHtyAdd && isTaskDelete && isUpdateLoc && isDeleteBoxing)
            {
                LogFactory.GetLog("任务完成").InfoFormat(true, "任务完成", $"事务处理完成,提交事务。添加历史任务：{isTaskHtyAdd},删除任务数据：{isTaskDelete},更新或添加库存：{isUpdateStock},修改移库前货位状态：{isUpdateLoc}");
                _unitOfWorkManage.CommitTran();
                return true;
            }
            else
            {
                LogFactory.GetLog("任务完成").InfoFormat(true, "任务完成", $"数据处理失败,请检查数据是否正确,数据回滚。添加历史任务：{isTaskHtyAdd},删除任务数据：{isTaskDelete},更新库存：{isUpdateStock},修改移库前货位状态：{isUpdateLoc}");
                _unitOfWorkManage.RollbackTran();
                return false;
            }
        }
        catch (Exception err)
        {
            LogFactory.GetLog("任务完成").InfoFormat(true, $"任务完成,系统异常，异常信息：{err.Message}", "无参数");
            _unitOfWorkManage.RollbackTran();
            throw; // 抛出异常以便外部捕获
        }
    }

    #region 任务请求方法

    private static readonly SemaphoreSlim _semaphoreUpdate = new SemaphoreSlim(1, 1);
    // 更新任务货位

    private async Task<WebResponseContent> UpdateExistingTask(RequestTaskDto input, Dt_Task task)
    {
        await _semaphoreUpdate.WaitAsync();
        try
        {
            if (task == null)
            {
                return new WebResponseContent().Error("任务对象为空");
            }

            try
            {
                // 创建WebResponseContent对象
                var content = new WebResponseContent();

                // 获取目标地址和更新任务状态

                input.Position = Regex.Replace(input.Position, @"-(\d+)", "");
                if (Convert.ToInt32(input.Position) > 1999)
                {
                    input.Position = (Convert.ToInt32(input.Position) - 1000).ToString();
                }

                if (task.TaskType == (int)TaskInboundTypeEnum.InNG)
                {
                    // TODO 根据巷道查找对应NG口，现在默认去静置堆垛机的异常口货位号
                    task.CurrentAddress = input.Position;
                    task.TargetAddress = "002-021-000";
                    task.NextAddress = "002-021-000";
                    task.TaskState = (int)TaskInStatusEnum.Line_InFinish;
                    bool isResult = await BaseDal.UpdateDataAsync(task);
                    return content.OK(data: task);
                }
                else if (task.TaskType == (int)TaskInboundTypeEnum.InQuality)
                {
                    var stockInfo = await _stockInfoRepository.QueryFirstNavAsync(x => x.PalletCode == input.PalletCode);
                    task.CurrentAddress = input.Position;
                    task.TargetAddress = stockInfo.LocationInfo.LocationCode;
                    task.NextAddress = stockInfo.LocationInfo.LocationCode;
                    task.TaskState = (int)TaskInStatusEnum.Line_InFinish;
                    bool isResult = await BaseDal.UpdateDataAsync(task);
                    return content.OK(data: task);
                }
                else
                {
                    var location = await GetLocationDistributeAsync(task.Roadway);
                    if (location == null)
                    {
                        return content.Error("无法获取货位信息");
                    }

                    string toAddress = location.LocationCode;
                    int taskState = (int)TaskInStatusEnum.Line_InFinish;
                    int beforeStatus = location.LocationStatus;
                    // 更新货位信息
                    location.LocationStatus = (int)LocationEnum.Lock;

                    // 更新任务信息
                    MapTaskProperties(task, input, toAddress, taskState);

                    // 开始事务
                    var isResult = await UpdateTaskAsync(task, location, beforeStatus);
                    if (!isResult)
                    {
                        _unitOfWorkManage.RollbackTran();
                        return content.Error("更新任务失败");
                    }

                    // 提交事务
                    _unitOfWorkManage.CommitTran();
                    return content.OK(data: task);
                }
            }
            catch (Exception ex)
            {
                // 回滚事务
                _unitOfWorkManage.RollbackTran();
                // 这里可以添加日志记录
                return new WebResponseContent().Error($"更新任务时发生错误: {ex.Message}");
            }
        }
        catch (Exception)
        {
            throw;
        }
        finally { _semaphoreUpdate.Release(); }
    }

    private void MapTaskProperties(Dt_Task task, RequestTaskDto input, string toAddress, int taskState)
    {
        task.CurrentAddress = input.Position;
        task.TargetAddress = toAddress;
        task.NextAddress = toAddress;
        task.TaskState = taskState;
    }

    // 修改任务
    private async Task<bool> UpdateTaskAsync(Dt_Task task, DtLocationInfo location, int beforeStatus)
    {
        bool isResult = await BaseDal.UpdateDataAsync(task);
        bool isTaskDetail = await _taskExecuteDetailRepository.AddDetailAsync(task, false, TaskDescription.GetTaskUpdateDescription(task.PalletCode, task.CurrentAddress, task.TargetAddress, TaskInStatusEnum.Line_InFinish.GetIntegralRuleTypeEnumDesc()));

        LocationChangeRecordDto changeRecordDto = new LocationChangeRecordDto()
        {
            AfterStatus = location.LocationStatus,
            BeforeStatus = beforeStatus,
            TaskNum = task.TaskNum.Value,
            LocationId = location.Id,
            LocationCode = location.LocationCode,
            ChangeType = (int)StatusChangeTypeEnum.AutomaticStorage,
        };

        bool isUpdateChange = _locationStatusChangeRecordRepository.AddStatusChangeRecord(changeRecordDto);
        bool isUpdateLo = await _locationRepository.UpdateDataAsync(location);

        return isResult && isUpdateLo && isTaskDetail;
    }

    /// <summary>
    /// 创建新任务
    /// </summary>
    /// <param name="input">请求模型</param>
    /// <param name="process">巷道</param>
    /// <param name="flag">标识（0-入库，1-空托盘入库，2-NG入库，3-出库）</param>
    /// <returns></returns>
    private async Task<WebResponseContent> CreateNewTask(RequestTaskDto input, string productionLine, string processCode, List<string> process = null, int flag = 0)
    {
        WebResponseContent content = new WebResponseContent();

        // 获取目标地址
        //string ToAddress = await GetRoadWayAsync(process);
        string ToAddress = string.Empty;
        if (flag < 2)
            ToAddress = await GetRoadWayAsync(process);
        else
            ToAddress = process[0];

        // 创建新任务实例
        var task = new Dt_Task
        {
            CurrentAddress = input.Position,
            Grade = 1,
            Roadway = ToAddress,
            TargetAddress = ToAddress,
            Dispatchertime = DateTime.Now,
            MaterialNo = "",
            NextAddress = ToAddress,
            OrderNo = null,
            PalletCode = input.PalletCode,
            SourceAddress = input.Position,
            TaskState = flag == 3 ? (int)TaskOutStatusEnum.OutNew : (int)TaskInStatusEnum.InNew,
            TaskType = flag == 0 ? (int)TaskInboundTypeEnum.Inbound : flag == 1 ? (int)TaskInboundTypeEnum.InTray : flag == 2 ? (int)TaskInboundTypeEnum.InNG : (int)TaskOutboundTypeEnum.Outbound,
            TaskNum = await BaseDal.GetTaskNo(),
            Creater = "System",
            ProductionLine = productionLine,
            ProcessCode = processCode
        };

        // 尝试添加新任务
        var taskId = await BaseDal.AddDataAsync(task);
        bool isResult = taskId > 0;
        if (isResult)
        {
            task.TaskId = taskId;
            isResult = await _taskExecuteDetailRepository.AddDetailAsync(task, false, TaskDescription.GetTaskUpdateDescription(input.PalletCode, input.Position, ToAddress, TaskInStatusEnum.InNew.GetIntegralRuleTypeEnumDesc()));

            //var location = _locationRepository.QueryFirst(x => x.RoadwayNo == task.Roadway && x.LocationCode == task.TargetAddress);
            //location.LocationStatus = (int)LocationEnum.Lock;
            //var isLocation = _locationRepository.UpdateData(location);

            if (isResult)
            {
                // 创建WMS任务
                WMSTaskDTO taskDTO = new WMSTaskDTO()
                {
                    TaskNum = task.TaskNum.Value,
                    Grade = 1,
                    PalletCode = task.PalletCode,
                    RoadWay = task.Roadway,
                    SourceAddress = task.SourceAddress,
                    TargetAddress = task.TargetAddress,
                    TaskState = task.TaskState.Value,
                    Id = 0,
                    TaskType = task.TaskType,
                    ProductionLine = task.ProductionLine
                };
                content.OK(data: taskDTO);
            }
            else
                content.Error("添加任务失败");
        }
        else
            content.Error("添加任务失败");
        return content;
    }

    private static readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

    /// <summary>
    /// 查找货位
    /// </summary>
    /// <param name="IsFull">区域主键</param>
    /// <param name="roadWay">巷道</param>
    /// <returns></returns>
    public async Task<DtLocationInfo> GetLocationDistributeAsync(string roadWay, bool IsFull = true)
    {
        #region 获取货位

        await _semaphore.WaitAsync();
        try
        {
            List<DtLocationInfo> locations;
            if (IsFull)
            {
                locations = await _locationRepository.QueryDataAsync(x => x.LocationStatus == (int)LocationEnum.Free && x.RoadwayNo == roadWay && x.EnalbeStatus == (int)EnableEnum.Enable);
            }
            else
            {
                locations = await _locationRepository.QueryDataAsync(x => x.LocationStatus == (int)LocationEnum.Free && x.RoadwayNo == roadWay && x.EnalbeStatus == (int)EnableEnum.Enable);
            }

            if (locations == null)
            {
                return null;
            }

            return locations.OrderBy(x => x.Layer).ThenBy(x => x.Column).ThenBy(x => x.Row).FirstOrDefault();
        }
        catch (Exception err)
        {
            Console.WriteLine(err.Message.ToString());
            return null;
        }
        finally
        {
            _semaphore.Release();
        }

        #endregion 获取货位
    }

    /// <summary>
    /// 根据巷道获取巷道或站台
    /// </summary>
    /// <returns></returns>
    public async Task<string> GetRoadWayAsync(List<string> process)
    {
        var deviceCode = await SqlSugarHelper.DbWCS.Queryable<Dt_DeviceInfo>()
             .Where(x => x.DeviceStatus == 1.ToString() && process.Contains(x.DeviceCode))
             .Select(x => x.DeviceCode).ToListAsync();

        var minGroup = _locationRepository.QueryData(x => deviceCode.Contains(x.RoadwayNo) && x.LocationStatus == (int)LocationEnum.Free)
             .GroupBy(x => x.RoadwayNo)
             .OrderByDescending(g => g.Count()) // 根据每个组的元素数量排序
             .ToList(); // 取出数量最多的组

        Dictionary<string, int> result = new Dictionary<string, int>();
        foreach (var item in minGroup)
        {
            var number = BaseDal.QueryData(x => x.TargetAddress == item.Key).Count();
            result.Add(item.Key, item.Count() - number);
        }

        string minRoadwayNo = result.OrderByDescending(x => x.Value).FirstOrDefault().Key; // 数量最多的组的Key

        return minRoadwayNo;
    }

    /// <summary>
    /// 根据区域获取巷道或站台
    /// </summary>
    /// <returns></returns>
    public async Task<string> GetRoadWayAsync(int areaCode)
    {
        var minGroup = _locationRepository.QueryData(x => x.AreaId == areaCode && x.LocationStatus == (int)LocationEnum.Free)
            .GroupBy(x => x.RoadwayNo)
             .OrderBy(g => g.Count()) // 根据每个组的元素数量排序
             .ToList(); // 取出数量最少的组

        Dictionary<string, int> result = new Dictionary<string, int>();
        foreach (var item in minGroup)
        {
            var number = BaseDal.QueryData(x => x.TargetAddress == item.Key).Count();
            result.Add(item.Key, item.Count() - number);
        }

        string minRoadwayNo = result.OrderByDescending(x => x.Value).FirstOrDefault().Key; // 数量最多的组的Key

        return minRoadwayNo;
    }

    // 新的出库错误处理逻辑
    private async Task HandleOutBoundError(DtStockInfo stock, Dt_Task task)
    {
        WebResponseContent content = new WebResponseContent();
        var area = _areaInfoRepository.QueryFirst(x => x.AreaCode == stock.AreaCode);
        if (area == null)
        {
            throw new Exception("未找到对应的库区信息");
        }

        var trayCells = new TrayCellsStatusDto
        {
            Software = area.Spare3,
            TrayBarcode = task.PalletCode,
            EquipmentCode = area.Spare2,
            SceneType = area.Spare4
        };

        content = await _cellStateService.GetTrayCellStatusAsync(trayCells);
        if (!content.Status) return;

        var ResultTray = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(content.Data.ToString());
        if (ResultTray.SerialNos.Count > 0)
        {
            var parameterInfo = GetParameterInfo(stock);

            var outHours = CalculateOutHours(stock);
            var isNG = outHours > parameterInfo.LowerSpecificationsLimit.ToDouble()
                        && outHours < parameterInfo.UpperSpecificationsLimit.ToDouble();

            var defectCode = !isNG ? "TQCK" : string.Empty;

            var outputDto = CreateAgingOutputDto(area, stock, ResultTray, parameterInfo, outHours, defectCode);
            content = await _agingInOrOutInputService.GetOCVOutputAsync(outputDto);

            var result = JsonConvert.DeserializeObject<BasicResult>(content.Data.ToString());
            if (!result.Success)
                task.Remark = "NG";
        }
    }

    // 计算出库小时的方法
    private double CalculateOutHours(DtStockInfo stock) =>
        (DateTime.Now - Convert.ToDateTime(stock.LinedProcessFeedbackTime ?? stock.CreateDate.ToString())).TotalHours;

    // 生成 AgingOutputDto 的封装方法
    private AgingOutputDto CreateAgingOutputDto(Dt_AreaInfo area, DtStockInfo stock, ResultTrayCellsStatus resultTray,
        ParameterInfo parameterInfo, double outHours, string defectCode)
    {
        return new AgingOutputDto
        {
            OpFlag = 1,
            Software = area.Spare3,
            EquipmentCode = area.Spare2,
            TrayBarcode = stock.PalletCode,
            SerialNos = resultTray.SerialNos.Select(x => new SerialNoOutDto
            {
                SlotNo = x.PositionNo,
                SerialNo = x.SerialNo,
                SerialNoResult = true,
                ParameterInfo = new List<ParameterInfoOutput>
                {
                    new ParameterInfoOutput
                    {
                        Value = outHours.ToString(),
                        ParameterCode = parameterInfo.ParameterCode,
                        ParameterDesc = parameterInfo.Description,
                        ParameterResult  = "OK",
                        TargetValue = parameterInfo.TargetValue,
                        LowerLimit = parameterInfo.LowerSpecificationsLimit,
                        UpperLimit = parameterInfo.UpperSpecificationsLimit,
                        DefectCode = defectCode,
                    }
                }
            }).ToList()
        };
    }

    // 获取参数信息的辅助方法
    private ParameterInfo GetParameterInfo(DtStockInfo stock) =>
        JsonConvert.DeserializeObject<List<ParameterInfo>>(stock.ParameterInfos)
            .FirstOrDefault(y => y.Description.Contains("时间"));

    #endregion 任务请求方法

    #endregion private 内部方法
}