2024-11-20 提交更新，查询空盘与实盘逻辑更改

陈勇

2024-11-20 7f08d970686ee8acd0a6061619a1f5206fc48bae

2024-11-20 提交更新，查询空盘与实盘逻辑更改

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoService/TaskService.cs

@@ -547,7 +547,7 @@
                    task.TaskState = nextStatus;
                    task.ModifyDate = DateTime.Now;
                    task.Modifier = "System";
                    BaseDal.UpdateData(task);
                    BaseDal.DeleteData(task);
                    _taskExecuteDetailService.AddTaskExecuteDetail(task.TaskId, $"堆垛机入库完成");
                }
                else if (task.TaskType.GetTaskTypeGroup() == TaskTypeGroup.RelocationGroup)

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/ConveyorLineJob/CommonConveyorLineJob.cs

@@ -228,7 +228,7 @@
                }
                else
                {
                    taskCommand.TargetAddress = 0;
                    taskCommand.TargetAddress = 1000;
                }

                conveyorLine.SendCommand(taskCommand, childDeviceCode);
@@ -269,7 +269,7 @@
                    taskOutboundTypeEnum = TaskOutboundTypeEnum.OutTray;
                else
                    taskOutboundTypeEnum = TaskOutboundTypeEnum.Outbound;
                await CheckAndCreateTask(taskOutboundTypeEnum, childDeviceCode, index, platform.Stacker.Split(',')[0], platform.Stacker.Split(',').ToList());
                await CheckAndCreateTask(taskOutboundTypeEnum, childDeviceCode, index, platform.Stacker);
            }
            catch (Exception)
            {

 Code Management/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/ConveyorLineJob/Task/RequestInbound.cs

@@ -57,6 +57,10 @@
            {
                RequestWmsTask(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
            }
            else if ((conveyorLine.DeviceCode == "1001" && childDeviceCode == "1068"))
            {
                ConveyorLineOutFinish(conveyorLine, command, childDeviceCode, ProtocalDetailValue);
            }
        }

        /// <summary>

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_Model/Models/BasicModel/DtStockInfo.cs

@@ -18,10 +18,16 @@
        public int Id { get; set; }

        /// <summary>
        /// ä¸»é”®
        /// æ‰˜ç›˜æ¡ç 
        /// </summary>
        [SugarColumn(IsNullable = false, Length = 50, ColumnDescription = "托盘编号")]
        public string PalletCode { get; set; }

        /// <summary>
        /// è´§ä½ç¼–号
        /// </summary>
        [SugarColumn(IsNullable = true, ColumnDescription = "货位ID")]
        public int LocationId { get; set; }

        /// <summary>
        /// è´§ä½ç¼–号
@@ -52,6 +58,11 @@
        public string SpecialParameterDuration { get; set; }

        /// <summary>
        /// ç”Ÿäº§äº§çº¿
        /// </summary>
        public string ProductionLine { get; set; }

        /// <summary>
        /// åŒºåŸŸç¼–码
        /// </summary>
        [SugarColumn(IsNullable = true, ColumnDescription = "区域编码")]
@@ -74,7 +85,7 @@
        /// è´§ä½æ•°æ®
        /// </summary>
        [SugarColumn(ColumnName = "LocationInfo")]
        [Navigate(NavigateType.OneToOne, nameof(LocationCode), nameof(DtLocationInfo.LocationCode))]
        [Navigate(NavigateType.OneToOne, nameof(LocationId), nameof(DtLocationInfo.Id))]
        public DtLocationInfo? LocationInfo { get; set; }
    }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StoragIntegrationServices/MOM/AgingInOrOutInput/AgingInOrOutInputService.cs

@@ -26,7 +26,7 @@
            input.EmployeeNo = "MITest";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
            var inputJson = input.ToDictionary();
            var x = await HttpsClient.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/AgingInput", inputJson);
            var x = await HttpsClient.PostAsync("http://c24-cellmi3:12020/api/MachineIntegration/AgingInput", inputJson);
            content.OK(data: x);

            LogFactory.GetLog("静置陈化入库（整托盘）").Info(true, $"\r\r--------------------------------------");
@@ -53,9 +53,9 @@
        {
            input.SessionId = Guid.NewGuid().ToString();
            input.EmployeeNo = "MITest";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ"); 
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
            var inputJson = input.ToDictionary();
            var x = await HttpsClient.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/AgingOutput", inputJson);
            var x = await HttpsClient.PostAsync("http://c24-cellmi3:12020/api/MachineIntegration/AgingOutput", inputJson);
            content.OK(data: x);
            LogFactory.GetLog("静置陈化出库（整托盘）").Info(true, $"\r\r--------------------------------------");
            LogFactory.GetLog("静置陈化出库（整托盘）").Info(true, x);

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StoragIntegrationServices/MOM/CellState/CellStateService.cs

@@ -34,7 +34,7 @@
            input.EmployeeNo = "MITest";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
            var inputJson = input.ToDictionary();
            var x = await HttpsClient.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/CellState", inputJson);
            var x = await HttpsClient.PostAsync("http://c24-cellmi3:12020/api/MachineIntegration/CellState", inputJson);
            #region
            //if (x != null)
            //{
@@ -93,7 +93,7 @@
            input.EmployeeNo = "MITest";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
            var inputJson = input.ToDictionary();
            var x = await HttpsClient.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/TrayCellsStatus", inputJson);
            var x = await HttpsClient.PostAsync("http://c24-cellmi3:12020/api/MachineIntegration/TrayCellsStatus", inputJson);
            if (x != null)
            {
                // ååºåˆ—化ResultTrayCellsStatus对象
@@ -119,7 +119,7 @@
                //// èµ‹å€¼DtBoxingInfoDetails
                //boxingInfo.BoxingInfoDetails = details;
                //var abc = await _boxingInfoService.AddBoxingInfoAsync(boxingInfo);
                    content.OK("组盘成功", x);
                content.OK("组盘成功", x);
            }
            LogFactory.GetLog("整盘电芯属性获取").Info(true, $"\r\r--------------------------------------");
            LogFactory.GetLog("整盘电芯属性获取").Info(true, x);

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StoragIntegrationServices/MOM/ProcessApply/ProcessApplyService.cs

@@ -27,7 +27,7 @@
            input.EmployeeNo = "MITest";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
            var inputIson = input.ToDictionary();
            var x = await HttpsClient.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/ProcessApply", inputIson);
            var x = await HttpsClient.PostAsync("http://c24-cellmi3:12020/api/MachineIntegration/ProcessApply", inputIson);
            if (x != null)
            {
                //var ResultProcess = JsonConvert.DeserializeObject<ResultProcessApply>(x);

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StoragIntegrationServices/MOM/Unbind/UnbindService.cs

@@ -27,12 +27,12 @@
        {
            input.SessionId = Guid.NewGuid().ToString();
            input.Software = "WMS";
            input.EquipmentCode = "ECH001-B";
            input.EquipmentCode = "24MEJQ08-1091";
            input.EmployeeNo = "MITest";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
            var inputJson = input.ToDictionary();
            LogFactory.GetLog("托盘单电芯解绑1").Info(true, JsonConvert.SerializeObject(inputJson));
            var x = await HttpsClient.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/TrayCellUnbind", inputJson);
            var x = await HttpsClient.PostAsync("http://c24-cellmi3:12020/api/MachineIntegration/TrayCellUnbind", inputJson);
            LogFactory.GetLog("托盘单电芯解绑").Info(true, $"\r\r--------------------------------------");
            LogFactory.GetLog("托盘单电芯解绑").Info(true, x);
        }
@@ -56,12 +56,12 @@
        {
            input.SessionId = Guid.NewGuid().ToString();
            input.Software = "WMS";
            input.EquipmentCode = "ECH001-B";
            input.EquipmentCode = "24MEJQ08-1091";
            input.EmployeeNo = "MITest";
            input.RequestTime = TimeZoneInfo.ConvertTimeToUtc(DateTime.Now).ToString("yyyy-MM-ddTHH:mm:ss.fffZ");
            var inputJson = input.ToDictionary();
            Console.WriteLine(inputJson);
            var x = await HttpsClient.PostAsync("http://ts-momapp01:12020/api/MachineIntegration/TrayUnbind", inputJson);
            var x = await HttpsClient.PostAsync("http://c24-cellmi3:12020/api/MachineIntegration/TrayUnbind", inputJson);
            LogFactory.GetLog("整盘电芯解绑").Info(true, $"\r\r--------------------------------------");
            LogFactory.GetLog("整盘电芯解绑").Info(true, x);
        }

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StorageTaskServices/Task/Dt_TaskService - ¸´ÖÆ.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,1187 @@
using log4net.Core;
using Mapster;
using Masuit.Tools;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using WIDESEA_DTO.MOM;
using WIDESEA_DTO.WMS;
using WIDESEA_IStorageBasicRepository;
using WIDESEA_IStoragIntegrationServices;
using WIDESEA_Model.Models;
using WIDESEA_StorageBasicRepository;
using WIDESEA_StorageTaskRepository;
using WIDESEA_StoragIntegrationServices;

namespace WIDESEA_StorageOutTaskServices
{
    public class Dt_TaskService1 : ServiceBase<Dt_Task, IDt_TaskRepository>, IDt_TaskService
    {
        private readonly LogFactory _logFactory = new LogFactory();
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly IDt_OutOrderRepository _outOrderRepository;
        private readonly IStockInfoRepository _stockInfoRepository;
        private readonly IStockInfoDetailRepository _stockInfoDetailRepository;
        private readonly IDt_Task_HtyRepository _task_HtyRepository;
        private readonly IDt_OutOrderAndStockRepository _outOrderAndStockRepository;
        private readonly IDt_OutOrderAndStock_HtyRepository _outOrderAndStock_HtyRepository;
        private readonly IMapper _mapper;
        private readonly IDt_MaterielInfoRepository _materielInfoRepository;
        private readonly ILocationInfoRepository _locationRepository;
        private readonly IDt_WareAreaInfoRepository _wareAreaInfoRepository;
        private readonly IPointStackerRelationRepository _pointStackerRelationRepository;
        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 IProductionRepository _productionRepository; // ç”Ÿäº§

        public Dt_TaskService1(IDt_TaskRepository BaseDal,
            IUnitOfWorkManage unitOfWorkManage,
            IDt_OutOrderRepository outOrderRepository,
            IStockInfoRepository stockInfoRepository,
            IDt_OutOrderAndStockRepository dt_OutOrderAndStockRepository,
            IDt_OutOrderAndStock_HtyRepository dt_OutOrderAndStock_HtyRepository,
            IDt_Task_HtyRepository task_HtyRepository,
            IMapper mapper,
            IDt_MaterielInfoRepository materielInfoRepository,
            ILocationInfoRepository locationRepository,
            IDt_WareAreaInfoRepository wareAreaInfoRepository,
            IPointStackerRelationRepository pointStackerRelationRepository,
            ITaskExecuteDetailRepository taskExecuteDetailRepository,
            ILocationStatusChangeRecordRepository locationStatusChangeRecordRepository,
            IBoxingInfoRepository boxingInfoRepository,
            ICellStateService cellStateService,
            IProcessApplyService processApplyService,
            IDt_AreaInfoRepository areaInfoRepository,
            IAgingInOrOutInputService agingInOrOutInputService,
            IStockInfoDetailRepository stockInfoDetailRepository,
            IProductionRepository productionRepository) : base(BaseDal)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _outOrderRepository = outOrderRepository;
            _stockInfoRepository = stockInfoRepository;
            _outOrderAndStockRepository = dt_OutOrderAndStockRepository;
            _outOrderAndStock_HtyRepository = dt_OutOrderAndStock_HtyRepository;
            _task_HtyRepository = task_HtyRepository;
            _mapper = mapper;
            _materielInfoRepository = materielInfoRepository;
            _locationRepository = locationRepository;
            _wareAreaInfoRepository = wareAreaInfoRepository;
            _pointStackerRelationRepository = pointStackerRelationRepository;
            _taskExecuteDetailRepository = taskExecuteDetailRepository;
            _locationStatusChangeRecordRepository = locationStatusChangeRecordRepository;
            _boxingInfoRepository = boxingInfoRepository;
            _cellStateService = cellStateService;
            _processApplyService = processApplyService;
            _areaInfoRepository = areaInfoRepository;
            _agingInOrOutInputService = agingInOrOutInputService;
            _stockInfoDetailRepository = stockInfoDetailRepository;
            _productionRepository = productionRepository;
        }

        // å¤–部接口方法

        #region å‡ºåº“任务完成
        // å‡ºåº“任务完成
        public async Task<WebResponseContent> CompleteStackTaskAsync(Dt_Task task, DtStockInfo stock)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
                {
                    var process = await SqlSugarHelper.Db.Queryable<Dt_EquipmentProcess>()
                        .FirstAsync(x => x.EquipmentName == task.Roadway);
                    var info = JsonConvert.DeserializeObject<ResponseEqptRunDto>(process.ProcessValue);

                    var agingOutputDto = MapToAgingOutputDto(stock, info);
                    content = await _agingInOrOutInputService.GetOCVOutputAsync(agingOutputDto);
                    ValidateResponse(content);
                }

                // æ›´æ–°åº“存状态和任务状态
                (var loc, var tas) = UpdateStockAndTaskStatus(stock, task);

                // äº‹åŠ¡å¤„理
                await _unitOfWorkManage.UseTranAsync(async () =>
                {
                    await UpdateLocationAsync(loc);
                    await DeleteStockInfoAsync(stock.Id);
                    await DeleteStockInfoDetailsAsync(stock.StockInfoDetails);
                    //await DeleteTaskAsync(task.TaskId);
                });

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

        // æ˜ å°„到老化输出DTO
        private AgingOutputDto MapToAgingOutputDto(DtStockInfo stock, ResponseEqptRunDto info)
        {
            // TODO Value值根据MOM下发的静置时间到当前时间的分钟数
            return new AgingOutputDto
            {
                OpFlag = 1,
                Software = "WMS",
                EquipmentCode = "ECH001-B",
                TrayBarcode = stock.PalletCode,
                SerialNos = stock.StockInfoDetails.Select(x => new SerialNoOutDto
                {
                    SlotNo = x.OrderNo.ToInt32(),
                    SerialNo = x.SerialNumber,
                    SerialNoResult = true,
                    ParameterInfo = info.ParameterInfo.Select(y => new ParameterInfo
                    {
                        LowerLomit = y.LowerControlLimit,
                        UpperLimit = y.UpperControlLimit,
                        ParameterResult = y.EquipmentAvailabilityFlag,
                        ParameterCode = y.ParameterCode,
                        ParameterDesc = y.Description,
                        TargetValue = y.TargetValue,
                        Value = (DateTime.Parse(stock.LinedProcessFeedbackTime, null, System.Globalization.DateTimeStyles.RoundtripKind).ToLocalTime() - stock.CreateDate).TotalMinutes.ToString(),
                        DefectCode = y.UOMCode
                    }).ToList()
                }).ToList()
            };
        }

        // éªŒè¯å“åº”内容
        private void ValidateResponse(WebResponseContent content)
        {
            var result = JsonConvert.DeserializeObject<BasicResult>(content.Data.ToString());
            if (!result.Success)
            {
                throw new Exception(result.MOMMessage);
            }
        }

        // æ›´æ–°åº“存状态和任务状态
        private (DtLocationInfo, Dt_Task) UpdateStockAndTaskStatus(DtStockInfo stock, Dt_Task task)
        {
            var location = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress);
            var details = _stockInfoDetailRepository.QueryData(x => x.StockId == stock.Id);

            location.LocationStatus = (int)LocationEnum.Free;
            task.TaskState = (int)TaskOutStatusEnum.OutFinish;
            //task.CurrentAddress = task.NextAddress;
            //task.NextAddress = task.TargetAddress;

            _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 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<bool> DeleteTaskAsync(int taskId)
        {
            var isTaskUpdated = await BaseDal.DeleteDataByIdAsync(taskId);
            if (!isTaskUpdated)
            {
                throw new Exception("任务信息更新失败");
            }
            return isTaskUpdated;
        }

        #region ç§»åº“任务完成
        // ç§»åº“任务完成
        public async Task<WebResponseContent> CompleteTransferTaskAsync(Dt_Task task, DtStockInfo stock)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                // æ›´æ–°è´§ä½å’Œåº“存信息
                (DtStockInfo updateStock, DtLocationInfo locationInf) = UpdateStockLocation(stock, task.NextAddress);
                var taskHty = CreateHistoricalTask(task);
                _logFactory.GetLog("任务完成").InfoFormat(true, "移库任务完成", $"货位地址：{task.TargetAddress},修改后库存数据：{JsonConvert.SerializeObject(updateStock)}，原先货位数据：{locationInf}");

                // æ‰§è¡Œæ•°æ®åº“事务
                bool isResult = await ExecuteTransaction(updateStock, taskHty, locationInf, task.TaskId);
                if (isResult)
                    content.OK("移库任务完成成功");
                else
                    content.Error("移库任务完成失败");
            }
            catch (Exception err)
            {
                Console.WriteLine(err.Message.ToString());
            }
            return content;
        }
        #endregion

        // æ›´æ–°åº“存位置
        private (DtStockInfo, DtLocationInfo) UpdateStockLocation(DtStockInfo stock, string toLocation)
        {
            var locationInfo = _locationRepository.QueryFirst(x => x.LocationCode == stock.LocationCode);
            locationInfo.LocationStatus = LocationEnum.InStock.ObjToInt();

            stock.LocationCode = toLocation;
            stock.LocationInfo.LocationStatus = LocationEnum.InStock.ObjToInt();

            return (stock, locationInfo);
        }

        // åˆ›å»ºåŽ†å²ä»»åŠ¡è®°å½•
        private Dt_Task_Hty CreateHistoricalTask(Dt_Task task)
        {
            task.TaskState = TaskOutStatusEnum.OutFinish.ObjToInt();
            task.CurrentAddress = task.NextAddress;

            var taskHty = _mapper.Map<Dt_Task_Hty>(task);
            taskHty.FinishTime = DateTime.Now;
            taskHty.TaskId = 0;
            taskHty.OperateType = (int)OperateTypeEnum.自动完成;
            taskHty.SourceId = task.TaskId;
            taskHty.TaskState = TaskOutStatusEnum.OutFinish.ObjToInt();
            return taskHty;
        }

        // æ‰§è¡Œæ•°æ®åº“事务
        private async Task<bool> ExecuteTransaction(DtStockInfo stock, Dt_Task_Hty taskHty, DtLocationInfo locationInfo, int taskId)
        {
            _unitOfWorkManage.BeginTran();
            try
            {
                var isUpdateStock = true;
                if (taskHty.TaskType == (int)TaskTypeEnum.Outbound)
                {
                    // æ›´æ–°åº“å­˜
                    isUpdateStock = await _stockInfoRepository.UpdateDataAsync(stock);
                }
                else
                {
                    // æ·»åŠ åº“å­˜
                    isUpdateStock = await _stockInfoRepository.AddDataNavAsync(stock);
                }

                // æ·»åŠ åŽ†å²ä»»åŠ¡
                var isTaskHtyAdd = await _task_HtyRepository.AddDataAsync(taskHty) > 0;

                // ä¿®æ”¹ç§»åº“前货位状态
                var isUpdateLoc = _locationRepository.UpdateData(locationInfo);

                // åˆ é™¤ä»»åŠ¡æ•°æ®
                var isTaskDelete = await DeleteTaskAsync(taskId);

                // æäº¤æˆ–回滚事务
                if (isUpdateStock && isTaskHtyAdd && isTaskDelete && isUpdateLoc)
                {
                    _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; // æŠ›å‡ºå¼‚常以便外部捕获
            }
        }

        #endregion

        #region å…¥åº“任务完成
        // å…¥åº“任务完成
        public async Task<WebResponseContent> CompleteInboundTaskAsync(Dt_Task task)
        {
            // åˆå§‹åŒ–响应内容
            WebResponseContent content = new WebResponseContent();
            try
            {
                // èŽ·å–装箱信息和目标位置信息
                var boxing = await _boxingInfoRepository.QueryFirstNavAsync(x => x.PalletCode == task.PalletCode);
                var locationInf = await _locationRepository.QueryFirstAsync(x => x.LocationCode == task.TargetAddress);

                // æ›´æ–°ç›®æ ‡ä½ç½®çŠ¶æ€ä¸ºåº“存中
                locationInf.LocationStatus = (int)LocationEnum.InStock;

                // åˆ›å»ºåŽ†å²ä»»åŠ¡å®žä¾‹æ¨¡åž‹
                var taskHty = CreateHistoricalTask(task);

                // æ ¹æ®æ˜¯å¦æœ‰ç»„盘信息创建库存实例模型
                DtStockInfo stock = boxing == null ? CreateEmptyPalletStock(task, locationInf) : CreateFullPalletStock(task, locationInf, boxing);

                // æ‰§è¡Œæ•°æ®åº“事务
                bool isResult = await ExecuteTransaction(stock, taskHty, locationInf, task.TaskId);
                if (isResult)
                {
                    content.OK("入库任务完成成功");
                }
                else
                {
                    content.Error("入库任务完成失败");
                }
            }
            catch (Exception err)
            {
                // è®°å½•å¼‚常信息到控制台和日志
                Console.WriteLine(err.Message.ToString());
                _logFactory.GetLog("任务完成").Error(true, err);
            }
            return content;
        }

        // åˆ›å»ºç©ºæ‰˜ç›˜çš„库存实例模型
        private DtStockInfo CreateEmptyPalletStock(Dt_Task task, DtLocationInfo locationInf)
        {
            return new DtStockInfo()
            {
                PalletCode = task.PalletCode,
                LocationCode = task.TargetAddress,
                CreateDate = DateTime.Now,
                Creater = "system",
                IsFull = false,
                AreaCode = task.Roadway,
                StockInfoDetails = new List<DtStockInfoDetail>()
            {
                new DtStockInfoDetail()
                {
                    MaterielCode = "空托盘",
                    Id = 0,
                    Status = (int)StockStateEmun.已入库
                }
            }
            };
        }

        // åˆ›å»ºå®žç›˜çš„库存实例模型并调用MOM入库
        private DtStockInfo CreateFullPalletStock(Dt_Task task, DtLocationInfo locationInf, DtBoxingInfo boxing)
        {
            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 = task.Roadway,
                StockInfoDetails = boxDetail,
            };

            // å¤„理请求参数
            AgingInputDto agingInputDto = new AgingInputDto()
            {
                SerialNos = boxing.BoxingInfoDetails
                    .Select(item => new SerialNoInDto { SerialNo = item.SerialNumber, PositionNo = item.OrderNo })
                    .ToList(),
                TrayBarcode = task.PalletCode,
                OpFlag = 1,
                EquipmentCode = "ECH001-B",
                Software = "WMS"
            };
            var result = _agingInOrOutInputService.GetOCVInputAsync(agingInputDto).Result;
            var respone = JsonConvert.DeserializeObject<ResponeAgingInputDto>(result.Data.ToString());
            stock.LinedProcessFeedbackTime = respone.LinedProcessFeedbackTime;
            stock.SpecialParameterDuration = respone.SpecialParameterDuration;
            //2024å¹´11月16日：新增字段计算应出库时间
            stock.OutboundTime = Convert.ToDateTime(respone.LinedProcessFeedbackTime).AddHours(Convert.ToDouble(respone.SpecialParameterDuration));

            // è®°å½•æ—¥å¿—
            _logFactory.GetLog("任务完成").InfoFormat(true, "入库任务完成", $"货位地址：{task.TargetAddress},修改后货位数据：{locationInf}");

            return stock;
        }
        #endregion

        #region å®Œæˆä»»åŠ¡
        // å®Œæˆä»»åŠ¡
        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));

            // éªŒè¯åº“存是否存在
            var stock = await _stockInfoRepository.QueryFirstNavAsync(x => x.PalletCode == task.PalletCode);

            // æ ¹æ®ä»»åŠ¡ç±»åž‹è°ƒç”¨ç›¸åº”的完成任务方法
            switch (task.TaskType)
            {
                case (int)TaskInboundTypeEnum.Inbound:
                case (int)TaskInboundTypeEnum.InTray:
                    _logFactory.GetLog("任务完成").InfoFormat(true, "入库任务", "");
                    return await CompleteInboundTaskAsync(task);

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

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

        #region å…¥åº“任务请求
        // è¯·æ±‚任务巷道
        public async Task<WebResponseContent> RequestTaskAsync(RequestTaskDto input)
        {
            // åˆ›å»ºä¸€ä¸ªWebResponseContent对象
            WebResponseContent content = new WebResponseContent();

            try
            {
                // è°ƒç”¨BaseDal.QueryFirstAsync方法，查询任务
                var task = await BaseDal.QueryFirstAsync(x => x.PalletCode == input.PalletCode);
                if (task != null)
                {
                    //if (task.TaskState == (int)TaskInStatusEnum.InNew)
                    {
                        // åˆ›å»ºWMS任务
                        WMSTaskDTO taskDTO = new WMSTaskDTO()
                        {
                            TaskNum = task.TaskNum.Value,
                            Grade = 1,
                            PalletCode = task.PalletCode,
                            RoadWay = task.Roadway,
                            SourceAddress = task.SourceAddress,
                            TargetAddress = task.Roadway,
                            TaskState = task.TaskState.Value,
                            Id = 0,
                            TaskType = task.TaskType,
                        };
                        return content.OK(data: taskDTO);
                    }
                }

                // åˆ›å»ºä¸€ä¸ªTrayCellsStatusDto对象，并赋值
                TrayCellsStatusDto trayCells = new TrayCellsStatusDto()
                {
                    Software = "WMS",
                    TrayBarcode = input.PalletCode,
                    //EquipmentCode = "EQ_CWJZ01"
                    EquipmentCode = "ECH001-B"
                };

                // è°ƒç”¨GetTrayCellStatusAsync方法，获取整盘电芯
                content = await GetTrayCellStatusAsync(trayCells);
                // å¦‚果状态为false，则返回content
                if (!content.Status) return content;

                // æ·»åŠ ç»„盘信息
                // å°†content.Data转换为ResultTrayCellsStatus对象
                var result = JsonConvert.DeserializeObject<ResultTrayCellsStatus>(content.Data.ToString());
                if (result.SerialNos.Count <= 0)
                    return content.Error(result.MOMMessage);

                // TODO èŽ·å–本地料框属性与整盘电芯属性获取的值进行对比，如果一致则继续，否则返回错误信息
                //var productions = await _productionRepository.QueryDataAsync(x => result.TrayBarcodePropertys.Select(x => x.TrayBarcodeProperty).ToList().Contains(x.TrayBarcodeProperty));
                //if (productions.Count <= 0)
                //    return content.Error("料框属性不存在");

                // è°ƒç”¨CreateBoxingInfo方法，创建组盘信息

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

                // è°ƒç”¨GetProcessApplyAsync方法，获取工艺路线
                ProcessApplyDto process = await GetProcessApplyAsync(result);

                // å¦‚æžœprocess为null，则返回content
                if (process == null) return content;

                // è°ƒç”¨_processApplyService.GetProcessApplyAsync方法，获取工艺申请
                content = await _processApplyService.GetProcessApplyAsync(process);

                // å¦‚果状态为false，则返回null
                if (!content.Status) return content.Error("工艺申请失败");

                // è°ƒç”¨GetProcessResponseAsync方法，获取工艺响应
                //var processResponse = await GetProcessResponseAsync(process, input.Position);

                List<string> strings = input.Position == "1088" ? new List<string>() { "CHSC01" } : new List<string>() { "JZSC01" };
                // è°ƒç”¨CreateNewTask方法，创建新任务
                content = await CreateNewTask(input, strings);
                if (content.Status)
                {
                    var isBox = await _boxingInfoRepository.AddDataNavAsync(boxing);
                }
            }
            catch (Exception err)
            {
                // å¦‚果发生异常，则调用content.Error方法，记录错误信息，并输出错误信息
                content.Error(err.Message);
                Console.WriteLine(err.Message);
            }

            // è¿”回content
            return content;
        }

        // è¯·æ±‚任务货位
        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)
            {

                throw;
            }
        }

        // æ›´æ–°ä»»åŠ¡è´§ä½
        private async Task<WebResponseContent> UpdateExistingTask(RequestTaskDto input, Dt_Task task)
        {
            if (task == null)
            {
                return new WebResponseContent().Error("任务对象为空");
            }

            try
            {
                // åˆ›å»ºWebResponseContent对象
                var content = new WebResponseContent();

                // èŽ·å–目标地址和更新任务状态
                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}");
            }
        }

        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;
        }

        // èŽ·å–货位
        public async Task<DtLocationInfo> GetLocationDistributeAsync(string roadWay, bool IsFull = true)
        {
            #region èŽ·å–货位

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

                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;
            }

            #endregion èŽ·å–货位
        }
        #endregion

        #region ç©ºæ‰˜ç›˜å…¥åº“
        // ç©ºæ‰˜ç›˜å…¥åº“申请
        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 = new WMSTaskDTO()
                    {
                        TaskNum = task.TaskNum.Value,
                        Grade = 1,
                        PalletCode = task.PalletCode,
                        RoadWay = task.Roadway,
                        SourceAddress = task.SourceAddress,
                        TargetAddress = task.Roadway,
                        TaskState = task.TaskState.Value,
                        Id = 0,
                        TaskType = task.TaskType,
                    };
                    return content.OK(data: task);
                }

                // èŽ·å–目标地址
                List<string> strings = input.Position == "1016" ? new List<string>() { "CHSC01" } : new List<string>() { "JZSC01" };

                return await CreateNewTask(input, strings, 1);
                //return await CreateNewTask(input, null, 1);
            }
            catch (Exception)
            {

                throw;
            }
        }

        // åˆ›å»ºæ–°ä»»åŠ¡
        private async Task<WebResponseContent> CreateNewTask(RequestTaskDto input, List<string> process = null, int flag = 0)
        {
            var content = new WebResponseContent();

            if (input == null)
            {
                return content.Error("输入参数无效");
            }

            try
            {
                // èŽ·å–目标地址
                string toAddress = await GetRoadWayAsync(input, process);

                // åˆ›å»ºæ–°ä»»åŠ¡å®žä¾‹
                var task = new Dt_Task
                {
                    CurrentAddress = input.Position,
                    Grade = 1,
                    Roadway = toAddress,
                    TargetAddress = toAddress,
                    Dispatchertime = DateTime.Now,
                    MaterialNo = string.Empty,
                    NextAddress = toAddress,
                    OrderNo = null,
                    PalletCode = input.PalletCode,
                    SourceAddress = input.Position,
                    TaskState = (int)TaskInStatusEnum.InNew,
                    TaskType = flag == 0 ? (int)TaskInboundTypeEnum.Inbound : (int)TaskInboundTypeEnum.InTray,
                    TaskNum = await BaseDal.GetTaskNo(),
                    Creater = "System" // ä¿®æ­£æ‹¼å†™é”™è¯¯
                };

                // å°è¯•æ·»åŠ æ–°ä»»åŠ¡
                var taskId = await BaseDal.AddDataAsync(task);
                if (taskId <= 0)
                {
                    return content.Error("添加任务失败");
                }

                task.TaskId = taskId;

                // æ·»åŠ ä»»åŠ¡æ‰§è¡Œè¯¦æƒ…
                bool detailAdded = await _taskExecuteDetailRepository.AddDetailAsync(
                    task,
                    false,
                    TaskDescription.GetTaskUpdateDescription(input.PalletCode, input.Position, toAddress, TaskInStatusEnum.InNew.GetIntegralRuleTypeEnumDesc())
                );

                if (!detailAdded)
                {
                    return content.Error("添加任务执行详情失败");
                }

                // åˆ›å»ºWMS任务
                var taskDTO = new WMSTaskDTO
                {
                    TaskNum = task.TaskNum.Value,
                    Grade = task.Grade.Value,
                    PalletCode = task.PalletCode,
                    RoadWay = task.Roadway,
                    SourceAddress = task.SourceAddress,
                    TargetAddress = task.Roadway,
                    TaskState = task.TaskState.Value,
                    Id = 0,
                    TaskType = task.TaskType,
                };

                return content.OK(data: taskDTO);
            }
            catch (Exception ex)
            {
                // è¿™é‡Œå¯ä»¥æ·»åŠ æ—¥å¿—记录
                return content.Error($"创建任务时发生错误: {ex.Message}");
            }
        }

        // èŽ·å–巷道或站台
        public async Task<string> GetRoadWayAsync(RequestTaskDto input, List<string> process)
        {
            var minGroup = _locationRepository.QueryData(x => process.Contains(x.RoadwayNo) && x.LocationStatus == (int)LocationEnum.Free)
                 .GroupBy(x => x.RoadwayNo)
                 .OrderByDescending(g => g.Count()) // æ ¹æ®æ¯ä¸ªç»„的元素数量排序
                 .First(); // å–出数量最多的组

            string minRoadwayNo = minGroup.Key; // æ•°é‡æœ€å¤šçš„组的Key

            return minRoadwayNo;
        }

        // èŽ·å–托盘单元格状态
        private async Task<WebResponseContent> GetTrayCellStatusAsync(TrayCellsStatusDto trayCells)
        {
            // è°ƒç”¨_cellStateService.GetTrayCellStatusAsync方法，获取托盘单元格状态
            return await _cellStateService.GetTrayCellStatusAsync(trayCells);
        }

        // èŽ·å–组盘信息
        private async Task<DtBoxingInfo> CreateBoxingInfo(ResultTrayCellsStatus result, string palletCode)
        {
            return new DtBoxingInfo
            {
                PalletCode = palletCode,
                IsFull = true,
                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()
            {
                EquipmentCode = "ECH001-B",
                Software = "WMS",
                //WipOrderNo = result.BindCode,
                SerialNos = content.SerialNos.Select(item => new SerialNos
                {
                    SerialNo = item.SerialNo
                }).ToList()
            };
        }

        // èŽ·å–工艺响应
        private async Task<List<Dt_EquipmentProcess>> GetProcessResponseAsync(ProcessApplyDto process, string position)
        {
            // å¦‚æžœprocess为null，则返回null
            if (process == null) return null;

            // è°ƒç”¨_processApplyService.GetProcessApplyAsync方法，获取工艺申请
            WebResponseContent content = await _processApplyService.GetProcessApplyAsync(process);
            // å¦‚果状态为false，则返回null
            if (!content.Status) return null;

            // å°†content.Data转换为ResultProcessApply对象
            var apply = JsonConvert.DeserializeObject<ResultProcessApply>(content.Data.ToString());
            // æ ¹æ®position的值，返回不同的Dt_EquipmentProcess列表
            switch (position)
            {
                case "1088":
                    return SqlSugarHelper.Db.Queryable<Dt_EquipmentProcess>()
                        .Where(x => x.EquipmentType == "陈化" && x.WipOrderNo == apply.WipOrderNo || x.ProductDesc == apply.ProductNo)
                        .ToList();
                case "1339":
                case "1406":
                    return SqlSugarHelper.Db.Queryable<Dt_EquipmentProcess>()
                        .Where(x => x.EquipmentType == "静置" && x.WipOrderNo == apply.WipOrderNo || x.ProductDesc == apply.ProductNo)
                        .ToList();

                default:
                    return new List<Dt_EquipmentProcess>();
            }
        }
        #endregion

        #region è¯·æ±‚出库（实盘&空盘）
        // è¯·æ±‚托盘任务
        public async Task<WebResponseContent> RequestTrayOutTaskAsync(string position, int tag, string areaCode, List<string> roadways)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                // æ ¹æ®æ‰˜ç›˜ç±»åž‹æŸ¥è¯¢åº“存信息
                DtStockInfo stockInfo = tag == (int)TaskOutboundTypeEnum.Outbound
                    ? QueryStockInfoForRealTrayAsync(areaCode, roadways).Result
                    : QueryStockInfoForEmptyTrayAsync(areaCode, roadways).Result;

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

                // æ–°å¢žé‡å¤ä»»åŠ¡æ ¡éªŒ
                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);
                return content.Error(ex.Message);
            }
        }

        // æŸ¥è¯¢å®žç›˜åº“存信息
        private async Task<DtStockInfo> QueryStockInfoForRealTrayAsync(string areaCode, List<string> roadways)
        {
            // TODO时间根据MOM系统配置的出库时间来获取,暂时不知道MOM返回的时间是什么所以这里测试时候在改
            var result = await _stockInfoRepository.Db.Queryable<DtStockInfo>().Where(x =>
                x.AreaCode == areaCode &&
                Convert.ToDateTime(x.LinedProcessFeedbackTime).AddHours(Convert.ToDouble(x.SpecialParameterDuration)) < DateTime.Now)
                .Includes(x => x.LocationInfo)
                .Where(x => x.LocationInfo.LocationStatus == (int)LocationEnum.InStock && roadways.Contains(x.LocationInfo.RoadwayNo))
                .Includes(x => x.StockInfoDetails)
                .Where(x => x.StockInfoDetails.Any(detail => detail.Status == (int)StockStateEmun.已入库))
                .OrderBy(x => x.CreateDate)
                .FirstAsync();
            return result;
        }

        // æŸ¥è¯¢ç©ºç›˜åº“存信息
        private async Task<DtStockInfo> QueryStockInfoForEmptyTrayAsync(string areaCode, List<string> roadways)
        {
            var result = await _stockInfoRepository.Db.Queryable<DtStockInfo>()
                .Includes(x => x.LocationInfo)
                .Where(x => x.LocationInfo.LocationStatus == (int)LocationEnum.InStock && roadways.Contains(x.LocationInfo.RoadwayNo))
                .Includes(x => x.StockInfoDetails)
                .Where(x => x.StockInfoDetails.Any(detail => detail.Status == (int)StockStateEmun.已入库 && detail.MaterielCode == "空托盘"))
                .OrderBy(x => x.CreateDate)
                .FirstAsync();
            return result;
        }

        // åˆ›å»ºä»»åŠ¡å®žä¾‹
        private Dt_Task CreateTask(DtStockInfo stockInfo, string position, int tag)
        {
            return new Dt_Task
            {
                Grade = 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 == (int)TaskOutboundTypeEnum.Outbound ? (int)TaskOutboundTypeEnum.Outbound : (int)TaskOutboundTypeEnum.OutTray,
                TaskNum = BaseDal.GetTaskNo().Result,
                Creater = "System" // ä¿®æ­£æ‹¼å†™é”™è¯¯
            };
        }

        // åˆ›å»ºä»»åŠ¡DTO
        private WMSTaskDTO CreateTaskDTO(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,
            };
        }
        #endregion

        #region æ›´æ–°ä»»åŠ¡çŠ¶æ€
        // æ›´æ–°ä»»åŠ¡çŠ¶æ€
        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)TaskOutStatusEnum.SC_OutFinish)
                {
                    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> OutUnblockInterface(int taskNum)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                var task = await BaseDal.QueryFirstAsync(x => x.TaskNum == taskNum);
                if (task == null)
                    return content.Error("未找到任务");
                task.TaskState = (int)TaskOutStatusEnum.Line_OutFinish;
                var taskHty = CreateHistoricalTask(task);
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }
        #endregion

        #region å†…部调用方法

        // åˆ›å»ºä¸€ä¸ªæ–°çš„任务
        public async Task<Dt_Task> Create(Dt_Task model)
        {
            return await BaseDal.Create(model);
        }

        // æ‰¹é‡åˆ›å»ºä»»åŠ¡
        public async Task<bool> Create(List<Dt_Task> models)
        {
            return await BaseDal.Create(models);
        }

        // åˆ é™¤ä¸€ä¸ªä»»åŠ¡
        public async Task<bool> Delete(int id)
        {
            return await BaseDal.Delete(id);
        }

        // æ‰¹é‡åˆ é™¤ä»»åŠ¡
        public async Task<bool> Delete(List<int> ids)
        {
            return await BaseDal.Delete(ids);
        }

        // é€šè¿‡ID获取任务
        public async Task<Dt_Task> GetById(int id)
        {
            return await BaseDal.GetById(id);
        }

        // èŽ·å–所有任务列表
        public async Task<List<Dt_Task>> GetList()
        {
            return await BaseDal.GetList();
        }

        // æ ¹æ®å‡ºåº“订单ID获取任务列表
        public async Task<List<Dt_Task>> GetListByOutOrder(int outOrderId)
        {
            return await BaseDal.GetListByOutOrder(outOrderId);
        }

        // æ ¹æ®å‡ºåº“订单ID和状态获取任务列表
        public async Task<List<Dt_Task>> GetListByOutOrderAndStatus(int outOrderId, int status)
        {
            return await BaseDal.GetListByOutOrderAndStatus(outOrderId, status);
        }

        // æ ¹æ®çŠ¶æ€èŽ·å–任务列表
        public async Task<List<Dt_Task>> GetListByStatus(int status)
        {
            return await BaseDal.GetListByStatus(status);
        }

        // æ›´æ–°ä¸€ä¸ªä»»åŠ¡
        public async Task<bool> Update(Dt_Task model)
        {
            return await BaseDal.UpdateDataAsync(model);
        }

        // æ‰¹é‡æ›´æ–°ä»»åŠ¡
        public async Task<bool> Update(List<Dt_Task> models)
        {
            return await BaseDal.UpdateDataAsync(models);
        }

        // æ£€æŸ¥ä»»åŠ¡æ˜¯å¦å­˜åœ¨
        public bool IsExist(string palletCode)
        {
            return Db.Queryable<Dt_Task>().Any(x => x.PalletCode == palletCode);
        }

        // æ ¹æ®è´§ä½ID获取任务
        public async Task<Dt_Task> GetByLocation(string locationID)
        {
            return await Db.Queryable<Dt_Task>().Where(x => x.SourceAddress == locationID).FirstAsync();
        }

        // æ ¹æ®ä»»åŠ¡å·èŽ·å–任务
        public async Task<Dt_Task> GetByTaskNum(int taskNum)
        {
            return await Db.Queryable<Dt_Task>().Where(x => x.TaskNum == taskNum).FirstAsync();
        }
        #endregion
    }
}

 Code Management/WMS/WIDESEA_WMSServer/WIDESEA_StorageTaskServices/Task/Dt_TaskService.cs

@@ -130,7 +130,7 @@
        {
            OpFlag = 1,
            Software = "WMS",
            EquipmentCode = "ECH001-B",
            EquipmentCode = "24MEJQ08-1091",
            TrayBarcode = stock.PalletCode,
            SerialNos = stock.StockInfoDetails.Select(x => new SerialNoOutDto
            {
@@ -254,91 +254,6 @@
    /// </summary>
    /// <param name="task">任务数据合集</param>
    /// <returns>返回结果集</returns>
    //public async Task<WebResponseContent> CompleteInboundTaskAsync(Dt_Task task)
    //{
    //    WebResponseContent content = new WebResponseContent();
    //    try
    //    {
    //        var boxing = await _boxingInfoRepository.QueryFirstNavAsync(x => x.PalletCode == task.PalletCode);
    //        var locationInf = await _locationRepository.QueryFirstAsync(x => x.LocationCode == task.TargetAddress);

    //        locationInf.LocationStatus = (int)LocationEnum.InStock;

    //        // åˆ›å»ºåŽ†å²ä»»åŠ¡å®žä¾‹æ¨¡åž‹
    //        var taskHty = CreateHistoricalTask(task);

    //        // åˆ›å»ºåº“存实例模型
    //        DtStockInfo stock;
    //        if (boxing == null)
    //        {
    //            // ç©ºæ‰˜ç›˜

    //            stock = new DtStockInfo()
    //            {
    //                PalletCode = task.PalletCode,
    //                LocationCode = task.TargetAddress,
    //                CreateDate = DateTime.Now,
    //                Creater = "system",
    //                IsFull = boxing.IsFull,
    //                StockInfoDetails = new List<DtStockInfoDetail>()
    //                {
    //                    new DtStockInfoDetail()
    //                    {
    //                         MaterielCode = "空托盘",
    //                         Id = 0,
    //                    }
    //                }
    //            };
    //        }
    //        else
    //        {
    //            // å®žç›˜
    //            var boxDetail = boxing.BoxingInfoDetails.Adapt<List<DtStockInfoDetail>>();
    //            // åˆ›å»ºåº“存实例模型
    //            stock = new DtStockInfo()
    //            {
    //                PalletCode = task.PalletCode,
    //                LocationCode = task.TargetAddress,
    //                CreateDate = DateTime.Now,
    //                Creater = "system",
    //                IsFull = boxing.IsFull,
    //                StockInfoDetails = boxDetail,
    //            };

    //            AgingInputDto agingInputDto = new AgingInputDto()
    //            {
    //                SerialNos = boxing.BoxingInfoDetails
    //                    .Select(item => new SerialNoInDto { SerialNo = item.SerialNumber, PositionNo = item.OrderNo })
    //                    .ToList(),
    //                TrayBarcode = task.PalletCode,
    //                OpFlag = 1
    //            };
    //            var result = await _agingInOrOutInputService.GetOCVInputAsync(agingInputDto);
    //            stock.Remark = JsonConvert.DeserializeObject<ResponeAgingInputDto>(result.Data.ToString()).LinedProcessFeedbackTime;

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

    //        }

    //        // æ‰§è¡Œæ•°æ®åº“事务
    //        bool isResult = await ExecuteTransaction(stock, taskHty, locationInf, task.TaskId);
    //        if (isResult)
    //            content.OK("入库任务完成成功");
    //        else
    //            content.Error("入库任务完成失败");
    //    }
    //    catch (Exception err)
    //    {
    //        Console.WriteLine(err.Message.ToString());
    //    }
    //    return content;
    //}

    /// <summary>
    /// å®Œæˆå…¥åº“任务
    /// </summary>
    /// <param name="task">任务数据合集</param>
    /// <returns>返回结果集</returns>
    public async Task<WebResponseContent> CompleteInboundTaskAsync(Dt_Task task)
    {
        // åˆå§‹åŒ–响应内容
@@ -383,6 +298,8 @@
    /// </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,
@@ -390,7 +307,8 @@
            CreateDate = DateTime.Now,
            Creater = "system",
            IsFull = false,
            AreaCode = task.Roadway,
            AreaCode = area.AreaCode,
            LocationId = loation.Id,
            StockInfoDetails = new List<DtStockInfoDetail>()
            {
                new DtStockInfoDetail()
@@ -408,6 +326,8 @@
    /// </summary>
    private DtStockInfo CreateFullPalletStock(Dt_Task task, DtLocationInfo locationInf, DtBoxingInfo boxing)
    {
        var loation = _locationRepository.QueryFirst(x => x.RoadwayNo == task.Roadway && x.LocationCode == task.TargetAddress);
        var area = _areaInfoRepository.QueryFirst(x => x.AreaID == loation.AreaId);
        var boxDetail = boxing.BoxingInfoDetails.Adapt<List<DtStockInfoDetail>>();
        boxDetail.ForEach(x => { x.Status = (int)StockStateEmun.已入库; });
        var stock = new DtStockInfo()
@@ -417,7 +337,8 @@
            CreateDate = DateTime.Now,
            Creater = "system",
            IsFull = boxing.IsFull,
            AreaCode = task.Roadway,
            AreaCode = area.AreaCode,
            LocationId = loation.Id,
            StockInfoDetails = boxDetail,
        };

@@ -429,7 +350,7 @@
                .ToList(),
            TrayBarcode = task.PalletCode,
            OpFlag = 1,
            EquipmentCode = "ECH001-B",
            EquipmentCode = "24MEJQ08-1091",
            Software = "WMS"
        };
        var result = _agingInOrOutInputService.GetOCVInputAsync(agingInputDto).Result;
@@ -438,6 +359,7 @@
        stock.SpecialParameterDuration = respone.SpecialParameterDuration;
        //2024å¹´11月16日：新增字段计算应出库时间
        stock.OutboundTime = Convert.ToDateTime(respone.LinedProcessFeedbackTime).AddHours(Convert.ToDouble(respone.SpecialParameterDuration));
        stock.ProductionLine = respone.ProductionLine;

        // è®°å½•æ—¥å¿—
        LogFactory.GetLog("任务完成").InfoFormat(true, "入库任务完成", $"货位地址：{task.TargetAddress},修改后货位数据：{locationInf}");
@@ -529,13 +451,14 @@
                    return content.OK(data: taskDTO);
                }
            }

            // åˆ›å»ºä¸€ä¸ªTrayCellsStatusDto对象，并赋值
            TrayCellsStatusDto trayCells = new TrayCellsStatusDto()
            {
                Software = "WMS",
                TrayBarcode = input.PalletCode,
                //EquipmentCode = "EQ_CWJZ01"
                EquipmentCode = "ECH001-B"
                EquipmentCode = "24MEJQ08-1091"
            };

            // è°ƒç”¨GetTrayCellStatusAsync方法，获取整盘电芯
@@ -692,7 +615,7 @@
        // åˆ›å»ºä¸€ä¸ªProcessApplyDto对象，并赋值
        return new ProcessApplyDto()
        {
            EquipmentCode = "ECH001-B",
            EquipmentCode = "24MEJQ08-1091",
            Software = "WMS",
            //WipOrderNo = result.BindCode,
            SerialNos = content.SerialNos.Select(item => new SerialNos
@@ -803,19 +726,19 @@
    /// </summary>
    private async Task<DtStockInfo> QueryStockInfoForRealTrayAsync(string areaCode, List<string> roadways)
    {
        // TODO时间根据MOM系统配置的出库时间来获取,暂时不知道MOM返回的时间是什么所以这里测试时候在改
        //return _stockInfoRepository.QueryFirstNavAsync(x => x.AreaCode == areaCode && Convert.ToDateTime(x.LinedProcessFeedbackTime).AddHours(Convert.ToDouble(x.SpecialParameterDuration)) < DateTime.Now
        //                        && x.LocationInfo.LocationStatus == (int)LocationEnum.InStock && roadways.Contains(x.LocationInfo.RoadwayNo) && x.StockInfoDetails.Any(x => x.Status == (int)StockStateEmun.已入库) && x.LocationInfo.LocationStatus == (int)LocationEnum.InStock).Result;
        var area = await _areaInfoRepository.QueryFirstAsync(x => x.AreaCode == areaCode);

        var result = await _stockInfoRepository.Db.Queryable<DtStockInfo>().Where(x =>
            x.AreaCode == areaCode &&
            Convert.ToDateTime(x.LinedProcessFeedbackTime).AddHours(Convert.ToDouble(x.SpecialParameterDuration)) < DateTime.Now)
            .Includes(x => x.LocationInfo)
            .Where(x => x.LocationInfo.LocationStatus == (int)LocationEnum.InStock && roadways.Contains(x.LocationInfo.RoadwayNo))
            .Includes(x => x.StockInfoDetails)
            .Where(x => x.StockInfoDetails.Any(detail => detail.Status == (int)StockStateEmun.已入库))
            .OrderBy(x => x.CreateDate)
            .FirstAsync();
        var result = await _stockInfoRepository.Db.Queryable<DtStockInfo>()
            .Includes(x => x.LocationInfo) // é¢„加载LocationInfo
            .Includes(x => x.StockInfoDetails) // é¢„加载StockInfoDetails
            .Where(x => x.AreaCode == areaCode && x.OutboundTime < DateTime.Now && x.IsFull == true) // è¿‡æ»¤æ¡ä»¶
            .Where(x => x.LocationInfo.LocationStatus == (int)LocationEnum.InStock && x.LocationInfo.AreaId == area.AreaID) // è¿‡æ»¤æ¡ä»¶
            .OrderBy(x => x.OutboundTime) // æŽ’序
            .FirstAsync(); // èŽ·å–第一个元素

        //var firstOrDefault = result.FirstOrDefault(x => roadways.Contains(x.LocationInfo.RoadwayNo)); // æŸ¥æ‰¾ç¬¬ä¸€ä¸ªåŒ¹é…çš„元素
        //var firstOrDefault = result[0]; // æŸ¥æ‰¾ç¬¬ä¸€ä¸ªåŒ¹é…çš„元素
        //return firstOrDefault;
        return result;
    }

@@ -824,14 +747,19 @@
    /// </summary>
    private async Task<DtStockInfo> QueryStockInfoForEmptyTrayAsync(string areaCode, List<string> roadways)
    {
        //return _stockInfoRepository.QueryFirstNavAsync(x => x.StockInfoDetails.Any(x => x.MaterielCode == "空托盘") && roadways.Contains(x.LocationInfo.RoadwayNo) && x.StockInfoDetails.Any(x => x.Status == (int)StockStateEmun.已入库) && x.LocationInfo.LocationStatus == (int)LocationEnum.InStock).Result;
        var area = await _areaInfoRepository.QueryFirstAsync(x => x.AreaCode == areaCode);

        var result = await _stockInfoRepository.Db.Queryable<DtStockInfo>()
            .Includes(x => x.LocationInfo)
            .Where(x => x.LocationInfo.LocationStatus == (int)LocationEnum.InStock && roadways.Contains(x.LocationInfo.RoadwayNo))
            .Includes(x => x.StockInfoDetails)
            .Where(x => x.StockInfoDetails.Any(detail => detail.Status == (int)StockStateEmun.已入库 && detail.MaterielCode == "空托盘"))
            .OrderBy(x => x.CreateDate)
            .FirstAsync();
            .Includes(x => x.LocationInfo) // é¢„加载LocationInfo
            .Includes(x => x.StockInfoDetails) // é¢„加载StockInfoDetails
            .Where(x => x.AreaCode == areaCode && x.IsFull == false)
            .Where(x => x.StockInfoDetails.Any(y => y.MaterielCode == "空托盘"))
            .Where(x => x.LocationInfo.LocationStatus == (int)LocationEnum.InStock && x.LocationInfo.AreaId == area.AreaID) // è¿‡æ»¤æ¡ä»¶
            .OrderBy(x => x.CreateDate) // æŽ’序
            .FirstAsync(); // è½¬æ¢ä¸ºåˆ—表

        //var firstOrDefault = result[0]; // æŸ¥æ‰¾ç¬¬ä¸€ä¸ªåŒ¹é…çš„元素
        //return firstOrDefault;
        return result;
    }

@@ -897,7 +825,7 @@
            if (task == null)
                return content.Error("未找到任务");

            if (taskState == (int)TaskOutStatusEnum.Line_OutFinish)
            if (taskState == (int)TaskOutStatusEnum.Line_OutFinish || taskState == (int)TaskOutStatusEnum.SC_OutFinish)
            {
                var taskHty = CreateHistoricalTask(task);
                await _unitOfWorkManage.UseTranAsync(async () =>
@@ -1058,7 +986,7 @@
    /// <returns>是否更新成功</returns>
    public async Task<bool> Update(Dt_Task model)
    {
        return await BaseDal.Update(model);
        return await BaseDal.UpdateDataAsync(model);
    }

    /// <summary>
@@ -1068,7 +996,7 @@
    /// <returns>是否更新成功</returns>
    public async Task<bool> Update(List<Dt_Task> models)
    {
        return await BaseDal.Update(models);
        return await BaseDal.UpdateDataAsync(models);
    }

    /// <summary>
@@ -1088,7 +1016,7 @@
    /// <returns></returns>
    public async Task<Dt_Task> GetByLocation(string locationID)
    {
        return await Db.Queryable<Dt_Task>().Where(x => x.SourceAddress == locationID).FirstAsync();
        return await BaseDal.QueryFirstAsync(x => x.SourceAddress == locationID);
    }

    /// <summary>
@@ -1098,7 +1026,7 @@
    /// <returns></returns>
    public async Task<Dt_Task> GetByTaskNum(int taskNum)
    {
        return await Db.Queryable<Dt_Task>().Where(x => x.TaskNum == taskNum).FirstAsync();
        return await BaseDal.QueryFirstAsync(x => x.TaskNum == taskNum);
    }

    #endregion å†…部调用方法
@@ -1383,7 +1311,7 @@
    /// <summary>
    /// æŸ¥æ‰¾è´§ä½
    /// </summary>
    /// <param name="areaId">区域主键</param>
    /// <param name="IsFull">区域主键</param>
    /// <param name="roadWay">巷道</param>
    /// <returns></returns>
    public async Task<DtLocationInfo> GetLocationDistributeAsync(string roadWay, bool IsFull = true)
@@ -1429,7 +1357,7 @@
    public async Task<string> GetRoadWayAsync(RequestTaskDto input, List<string> process)
    {
        var minGroup = _locationRepository.QueryData(x => process.Contains(x.RoadwayNo) && x.LocationStatus == (int)LocationEnum.Free)
            .GroupBy(x => x.RoadwayNo)
             .GroupBy(x => x.RoadwayNo)
             .OrderByDescending(g => g.Count()) // æ ¹æ®æ¯ä¸ªç»„的元素数量排序
             .First(); // å–出数量最多的组