提交

pan

2025-12-02 1527b89f90c48e5791c740a877aec305a2065064

 ÏîÄ¿´úÂë/WMSÎÞ²Ö´¢°æ/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService.cs

@@ -27,6 +27,7 @@
using System.Reflection.Emit;
using System.Threading.Tasks;
using System.Xml.Linq;
using WIDESEA_BasicService;
using WIDESEA_Common.AllocateEnum;
using WIDESEA_Common.CommonEnum;
using WIDESEA_Common.LocationEnum;
@@ -68,12 +69,15 @@
        private readonly IInboundOrderService _inboundOrderService;
        private readonly IInboundOrderDetailService _inboundOrderDetailService;

        private readonly IRepository<Dt_AllocateOrderDetail> _allocateOrderDetailRepository;
        private readonly IRepository<Dt_AllocateOrder> _allocateOrderRepository;
        private readonly IRepository<Dt_ReCheckOrder> _reCheckOrderRepository;
        private readonly IRepository<Dt_OutboundBatch> _OutboundBatchRepository;
        private readonly IOutboundOrderService _outboundOrderService;
        private readonly IOutboundOrderDetailService _outboundOrderDetailService;
        private readonly IOutStockLockInfoService _outStockLockInfoService;
        private readonly ILocationStatusChangeRecordService _locationStatusChangeRecordService;
        private readonly IMaterialUnitService _materialUnitService;
        private readonly IESSApiService _eSSApiService;
        private readonly IStockService _stockService;
        private readonly IRecordService _recordService;
@@ -98,7 +102,7 @@

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

        public TaskService(IRepository<Dt_Task> BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IRepository<Dt_StockInfo> stockRepository, ILocationInfoService locationInfoService, IInboundOrderService inboundOrderService, ILocationStatusChangeRecordService locationStatusChangeRecordService, IESSApiService eSSApiService, ILogger<TaskService> logger, IStockService stockService, IRecordService recordService, IInboundOrderDetailService inboundOrderDetailService, IOutboundOrderService outboundOrderService, IOutboundOrderDetailService outboundOrderDetailService, IInvokeMESService invokeMESService, IOutStockLockInfoService outStockLockInfoService, IAllocateService allocateService, IRepository<Dt_OutboundBatch> outboundBatchRepository,IRepository<Dt_ReCheckOrder> reCheckOrderRepository) : base(BaseDal)
        public TaskService(IRepository<Dt_Task> BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IRepository<Dt_StockInfo> stockRepository, ILocationInfoService locationInfoService, IInboundOrderService inboundOrderService, ILocationStatusChangeRecordService locationStatusChangeRecordService, IESSApiService eSSApiService, ILogger<TaskService> logger, IStockService stockService, IRecordService recordService, IInboundOrderDetailService inboundOrderDetailService, IOutboundOrderService outboundOrderService, IOutboundOrderDetailService outboundOrderDetailService, IInvokeMESService invokeMESService, IOutStockLockInfoService outStockLockInfoService, IAllocateService allocateService, IRepository<Dt_OutboundBatch> outboundBatchRepository, IRepository<Dt_ReCheckOrder> reCheckOrderRepository, IRepository<Dt_AllocateOrderDetail> allocateOrderDetailRepository, IRepository<Dt_AllocateOrder> allocateOrderRepository, IMaterialUnitService materialUnitService) : base(BaseDal)
        {
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
@@ -118,6 +122,9 @@
            _allocateService = allocateService;
            _OutboundBatchRepository = outboundBatchRepository;
            _reCheckOrderRepository = reCheckOrderRepository;
            _allocateOrderDetailRepository = allocateOrderDetailRepository;
            _allocateOrderRepository = allocateOrderRepository;
            _materialUnitService = materialUnitService;
        }


@@ -297,7 +304,7 @@

                            };

                            var groupedData = inboundOrder.Details.GroupBy(item => new { item.MaterielCode, item.SupplyCode, item.BatchNo, item.lineNo, item.BarcodeUnit, item.WarehouseCode })
                            var groupedData = inboundOrder.Details.GroupBy(item => new { item.MaterielCode, item.lineNo, item.BarcodeUnit, item.WarehouseCode })
                               .Select(group => new AllocateDtoDetail
                               {
                                   MaterialCode = group.Key.MaterielCode,
@@ -333,7 +340,7 @@
                    }
                    else if (inboundOrder.OrderType == InOrderTypeEnum.InternalAllocat.ObjToInt()) //智仓调智仓
                    {
                        _logger.LogInformation($"InboundTaskCompleted å›žå†™MES  : {inboundOrder.InboundOrderNo }  ,ordertype: {InOrderTypeEnum.InternalAllocat.ObjToInt()} "  );
                        _logger.LogInformation($"InboundTaskCompleted å›žå†™MES  : {inboundOrder.InboundOrderNo}  ,ordertype: {InOrderTypeEnum.InternalAllocat.ObjToInt()} ");
                        // BusinessTypeEnum.智仓调智仓
                        if (inboundOrder != null && inboundOrder.OrderStatus == InOrderStatusEnum.入库完成.ObjToInt())
                        {
@@ -353,7 +360,7 @@

                            };

                            var groupedData = inboundOrder.Details.GroupBy(item => new { item.MaterielCode, item.SupplyCode, item.BatchNo, item.lineNo, item.BarcodeUnit, item.WarehouseCode })
                            var groupedData = inboundOrder.Details.GroupBy(item => new { item.MaterielCode, item.lineNo, item.BarcodeUnit, item.WarehouseCode })
                               .Select(group => new AllocateDtoDetail
                               {
                                   MaterialCode = group.Key.MaterielCode,
@@ -447,7 +454,7 @@
        {
            _logger.LogInformation($"TaskService  OutAllocateTaskCompleted: {task.TaskNum}");

           return  await OutboundTaskCompleted(task);          
            return await OutboundTaskCompleted(task);
        }
        public async Task<WebResponseContent> OutboundTaskCompleted(Dt_Task task)
        {
@@ -550,60 +557,84 @@
            }
        }


        public async Task<WebResponseContent> InPickTaskCompleted(Dt_Task task)
        {
            _logger.LogInformation($"TaskService  InPickTaskCompleted: {task.TaskNum}");
            _logger.LogInformation($"TaskService InPickTaskCompleted: {task.TaskNum}");

            try
            {
                //查库存
                Dt_StockInfo stockInfo = await _stockRepository.Db.Queryable<Dt_StockInfo>().Includes(x => x.Details).Where(x => x.PalletCode == task.PalletCode).FirstAsync();
                _unitOfWorkManage.BeginTran(); // æ·»åŠ äº‹åŠ¡ç®¡ç†

                // æŸ¥åº“å­˜
                Dt_StockInfo stockInfo = await _stockRepository.Db.Queryable<Dt_StockInfo>()
                    .Includes(x => x.Details)
                    .Where(x => x.PalletCode == task.PalletCode)
                    .FirstAsync();

                if (stockInfo == null)
                {
                    _logger.LogInformation($"TaskService  InPickTaskCompleted: æœªæ‰¾åˆ°æ‰˜ç›˜å¯¹åº”的组盘信息.{task.TaskNum}");
                    _logger.LogInformation($"TaskService InPickTaskCompleted: æœªæ‰¾åˆ°æ‰˜ç›˜å¯¹åº”的组盘信息.{task.TaskNum}");
                    return WebResponseContent.Instance.Error($"未找到托盘对应的组盘信息");
                }

                if (stockInfo.Details.Count == 0 && stockInfo.PalletType != PalletTypeEnum.Empty.ObjToInt())
                {
                    _logger.LogInformation($"TaskService  InPickTaskCompleted: æœªæ‰¾åˆ°è¯¥æ‰˜ç›˜åº“存明细信息.{task.TaskNum}");
                    _logger.LogInformation($"TaskService InPickTaskCompleted: æœªæ‰¾åˆ°è¯¥æ‰˜ç›˜åº“存明细信息.{task.TaskNum}");
                    return WebResponseContent.Instance.Error($"未找到该托盘库存明细信息");
                }
                //查货位

                // æŸ¥è´§ä½
                Dt_LocationInfo locationInfo = _locationInfoService.Repository.QueryFirst(x => x.LocationCode == task.TargetAddress);
                if (locationInfo == null)
                {
                    _logger.LogInformation($"TaskService  InPickTaskCompleted:  æœªæ‰¾åˆ°å¯¹åº”的终点货位信息 {task.TaskNum}.");
                    _logger.LogInformation($"TaskService InPickTaskCompleted: æœªæ‰¾åˆ°å¯¹åº”的终点货位信息 {task.TaskNum}.");
                    return WebResponseContent.Instance.Error($"未找到对应的终点货位信息");
                }

                var beforelocationStatus = locationInfo.LocationStatus;

                // èŽ·å–所有回库中的出库锁定记录
                var returnLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(it => it.OrderNo == task.OrderNo && it.PalletCode == task.PalletCode && it.Status == (int)OutLockStockStatusEnum.回库中)
                    .Where(it => it.OrderNo == task.OrderNo &&
                               it.PalletCode == task.PalletCode &&
                               it.Status == (int)OutLockStockStatusEnum.回库中)
                    .ToListAsync();

                // æ›´æ–°å‡ºåº“锁定记录状态为回库完成
                foreach (var lockInfo in returnLocks)
                {
                    lockInfo.Status = (int)OutLockStockStatusEnum.已回库;
                    lockInfo.Operator = App.User.UserName;
                }
                _outStockLockInfoService.Db.Updateable(returnLocks).ExecuteCommand();

                if (returnLocks.Any())
                {
                    await _outStockLockInfoService.Db.Updateable(returnLocks).ExecuteCommandAsync();
                    _logger.LogInformation($"更新{returnLocks.Count}条锁定记录为已回库状态");
                }

                // æ›´æ–°åº“存信息
                stockInfo.LocationCode = task.TargetAddress;
                stockInfo.StockStatus = StockStatusEmun.入库完成.ObjToInt();

                // æ›´æ–°åº“存明细状态
                if (stockInfo.Details != null && stockInfo.Details.Any())
                {
                    stockInfo.Details.ForEach(x =>
                    foreach (var detail in stockInfo.Details)
                    {
                        x.Status = StockStatusEmun.入库完成.ObjToInt();
                    });
                        detail.Status = StockStatusEmun.入库完成.ObjToInt();
                        detail.OutboundQuantity = 0; // å…¥åº“完成时出库数量清零
                    }
                    _stockService.StockInfoDetailService.Repository.UpdateData(stockInfo.Details);
                }

                _stockService.StockInfoService.Repository.UpdateData(stockInfo);

                await ProcessStockDetailsForReturn(task, stockInfo.Id);

                // åˆ é™¤é›¶åº“存数据
                await DeleteZeroQuantityStockDetails(stockInfo.Id);

                await UpdateAffectedOrderDetails(task.OrderNo, returnLocks);
                // æ›´æ–°è´§ä½çŠ¶æ€
                if (stockInfo.PalletType == PalletTypeEnum.Empty.ObjToInt())
                {
                    locationInfo.LocationStatus = LocationStatusEnum.Pallet.ObjToInt();
@@ -612,30 +643,342 @@
                {
                    locationInfo.LocationStatus = LocationStatusEnum.InStock.ObjToInt();
                }
                _locationInfoService.Repository.UpdateData(locationInfo);
                var outboundOrder = _outboundOrderService.Db.Queryable<Dt_OutboundOrder>().First(x => x.OrderNo == task.OrderNo);

                _locationInfoService.Repository.UpdateData(locationInfo);                       

                task.TaskStatus = TaskStatusEnum.Finish.ObjToInt();

                // åˆ é™¤ä»»åŠ¡è®°å½•
                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                BaseDal.DeleteData(task);
                _locationStatusChangeRecordService.AddLocationStatusChangeRecord(locationInfo, beforelocationStatus, StockChangeType.Inbound.ObjToInt(), "", task.TaskNum);

                if (outboundOrder != null)
                // è®°å½•è´§ä½çŠ¶æ€å˜æ›´
                _locationStatusChangeRecordService.AddLocationStatusChangeRecord(
                    locationInfo,
                    beforelocationStatus,
                    StockChangeType.Inbound.ObjToInt(),
                    "",
                    task.TaskNum
                );
                await RecalculateOrderStatus(task.OrderNo);

                _unitOfWorkManage.CommitTran(); // æäº¤äº‹åŠ¡
                _logger.LogInformation($"托盘回库完成处理成功 - ä»»åŠ¡å·: {task.TaskNum}, æ‰˜ç›˜: {task.PalletCode}, è®¢å•: {task.OrderNo}");
                _ = Task.Run(async () =>
                {
                    await HandleOutboundOrderToMESCompletion(outboundOrder, outboundOrder.OrderNo);
                    try
                    {
                        var outboundOrder = await _outboundOrderService.Db.Queryable<Dt_OutboundOrder>()
                            .FirstAsync(x => x.OrderNo == task.OrderNo);

                        if (outboundOrder != null)
                        {
                            // æ£€æŸ¥è®¢å•æ˜¯å¦å·²å®Œæˆï¼Œåªæœ‰å®Œæˆæ—¶æ‰å‘MES反馈
                            if (outboundOrder.OrderStatus == (int)OutOrderStatusEnum.出库完成)
                            {
                                await HandleOutboundOrderToMESCompletion(outboundOrder, outboundOrder.OrderNo);
                            }
                            else
                            {
                                _logger.LogInformation($"订单{task.OrderNo}状态为{outboundOrder.OrderStatus}，暂不向MES反馈");
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.LogError($"异步MES反馈处理失败 - OrderNo: {task.OrderNo}, Error: {ex.Message}");
                    }
                });
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran(); // å›žæ»šäº‹åŠ¡
                _logger.LogError($"TaskService InPickTaskCompleted失败 - TaskNum: {task.TaskNum}, Error: {ex.Message}");
                return WebResponseContent.Instance.Error($"回库任务完成处理失败: {ex.Message}");
            }

            return WebResponseContent.Instance.OK();
        }
        // <summary>
        /// æ›´æ–°å—影响的订单明细锁定数量
        /// </summary>
        private async Task UpdateAffectedOrderDetails(string orderNo, List<Dt_OutStockLockInfo> returnLocks)
        {
            try
            {
                // èŽ·å–受影响的订单明细ID（去重）
                var affectedDetailIds = returnLocks
                    .Select(x => x.OrderDetailId)
                    .Distinct()
                    .ToList();

                if (!affectedDetailIds.Any())
                {
                    _logger.LogInformation($"没有受影响的订单明细 - OrderNo: {orderNo}");
                    return;
                }
                else

                _logger.LogInformation($"更新{affectedDetailIds.Count}个受影响的订单明细 - OrderNo: {orderNo}");

                foreach (var detailId in affectedDetailIds)
                {
                    _logger.LogInformation($"TaskService  InPickTaskCompleted: {task.TaskNum} ,未找到出库单。  ");
                    // é‡æ–°è®¡ç®—该订单明细的锁定数量
                    decimal currentLockQty = await CalculateOrderDetailLockQuantity(detailId);

                    // æ£€æŸ¥æ•°æ®ä¸€è‡´æ€§
                    if (currentLockQty < 0)
                    {
                        _logger.LogWarning($"锁定数量计算为负值 - OrderDetailId: {detailId}, å½“前值: {currentLockQty}，重置为0");
                        currentLockQty = 0;
                    }

                    // èŽ·å–订单明细
                    var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                        .FirstAsync(x => x.Id == detailId);

                    if (orderDetail == null)
                    {
                        _logger.LogWarning($"未找到订单明细 - OrderDetailId: {detailId}");
                        continue;
                    }

                    // æ›´æ–°é”å®šæ•°é‡
                    if (orderDetail.LockQuantity != currentLockQty)
                    {
                        await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
                            .SetColumns(it => new Dt_OutboundOrderDetail
                            {
                                LockQuantity = currentLockQty, 
                            })
                            .Where(it => it.Id == detailId)
                            .ExecuteCommandAsync();

                        _logger.LogInformation($"更新订单明细锁定数量 - OrderDetailId: {detailId}, " +
                                              $"旧值: {orderDetail.LockQuantity}, æ–°å€¼: {currentLockQty}");
                    }

                    // æ›´æ–°è®¢å•æ˜Žç»†çŠ¶æ€
                    await UpdateOrderDetailStatus(orderDetail);
                }
            }
            catch (Exception ex)
            {
                _logger.LogInformation($"TaskService  InPickTaskCompleted: {task.TaskNum} , {ex.Message}");
                _logger.LogError($"UpdateAffectedOrderDetails失败 - OrderNo: {orderNo}, Error: {ex.Message}");
                throw;
            }
            return await Task.FromResult(WebResponseContent.Instance.OK());
        }

        /// <summary>
        /// é‡æ–°è®¡ç®—订单明细锁定数量
        /// </summary>
        private async Task<decimal> CalculateOrderDetailLockQuantity(int orderDetailId)
        {
            try
            {
                // æŸ¥æ‰¾è¯¥è®¢å•æ˜Žç»†ä¸‹æ‰€æœ‰çŠ¶æ€ä¸º"出库中"的锁定记录
                var activeLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderDetailId == orderDetailId &&
                               x.Status == (int)OutLockStockStatusEnum.出库中)
                    .ToListAsync();

                // è¿‡æ»¤æ‹†åŒ…记录
                var filteredLocks = new List<Dt_OutStockLockInfo>();

                foreach (var lockInfo in activeLocks)
                {
                    // å¦‚果是拆包记录，需要特殊处理
                    if (lockInfo.IsSplitted == 1 && lockInfo.ParentLockId.HasValue)
                    {
                        // æŸ¥æ‰¾çˆ¶é”å®šè®°å½•
                        var parentLock = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                            .Where(x => x.Id == lockInfo.ParentLockId.Value)
                            .FirstAsync();

                        // å¦‚果父记录存在且状态也是出库中，则只计算父记录
                        if (parentLock != null && parentLock.Status == (int)OutLockStockStatusEnum.出库中)
                        {
                            // çˆ¶è®°å½•å·²ç»åœ¨åˆ—表中，跳过当前拆包记录
                            continue;
                        }
                    }

                    filteredLocks.Add(lockInfo);
                }

                decimal totalLockQty = filteredLocks.Sum(x => x.AssignQuantity - x.PickedQty);

                _logger.LogDebug($"计算锁定数量 - OrderDetailId: {orderDetailId}, " +
                               $"找到{filteredLocks.Count}个有效锁定记录, " +
                               $"总锁定数量: {totalLockQty}");

                return totalLockQty;
            }
            catch (Exception ex)
            {
                _logger.LogError($"CalculateOrderDetailLockQuantity失败 - OrderDetailId: {orderDetailId}, Error: {ex.Message}");
                return 0;
            }
        }

        /// <summary>
        /// æ›´æ–°è®¢å•æ˜Žç»†çŠ¶æ€
        /// </summary>
        private async Task UpdateOrderDetailStatus(Dt_OutboundOrderDetail orderDetail)
        {
            try
            {
                int newStatus = orderDetail.OrderDetailStatus;

                // æ ¹æ®å®žé™…枚举值调整
                // 1. æ£€æŸ¥æ˜¯å¦å·²å®Œæˆï¼ˆå·²å‡ºåº“数量 >= éœ€æ±‚数量）
                if (orderDetail.OverOutQuantity >= orderDetail.NeedOutQuantity)
                {
                    newStatus = (int)OrderDetailStatusEnum.Over; // å·²å®Œæˆ
                }
                // 2. æ£€æŸ¥æ˜¯å¦æœ‰éƒ¨åˆ†å‡ºåº“或有锁定数量
                else if (orderDetail.OverOutQuantity > 0 || orderDetail.LockQuantity > 0)
                {
                    newStatus = (int)OrderDetailStatusEnum.Outbound; // éƒ¨åˆ†å®Œæˆ/进行中
                }
                // 3. å¦åˆ™ä¸ºæ–°è®¢å•
                else
                {
                    newStatus = (int)OrderDetailStatusEnum.New; // æ–°å»º
                }

                // åªæœ‰çŠ¶æ€å˜åŒ–时才更新
                if (orderDetail.OrderDetailStatus != newStatus)
                {
                    await _outboundOrderDetailService.Db.Updateable<Dt_OutboundOrderDetail>()
                        .SetColumns(it => new Dt_OutboundOrderDetail
                        {
                            OrderDetailStatus = newStatus, 
                        })
                        .Where(it => it.Id == orderDetail.Id)
                        .ExecuteCommandAsync();

                    _logger.LogInformation($"更新订单明细状态 - OrderDetailId: {orderDetail.Id}, " +
                                          $"旧状态: {orderDetail.OrderDetailStatus}, æ–°çŠ¶æ€: {newStatus}, " +
                                          $"已出库: {orderDetail.OverOutQuantity}/{orderDetail.NeedOutQuantity}, " +
                                          $"锁定数量: {orderDetail.LockQuantity}");
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"UpdateOrderDetailStatus失败 - OrderDetailId: {orderDetail.Id}, Error: {ex.Message}");
                throw;
            }
        }

        /// <summary>
        /// é‡æ–°è®¡ç®—并更新订单状态
        /// </summary>
        private async Task RecalculateOrderStatus(string orderNo)
        {
            try
            {
                // èŽ·å–订单的所有明细
                var orderDetails = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                    .LeftJoin<Dt_OutboundOrder>((o, item) => o.OrderId == item.Id)
                    .Where((o, item) => item.OrderNo == orderNo)
                    .Select((o, item) => o)
                    .ToListAsync();

                if (!orderDetails.Any())
                {
                    _logger.LogWarning($"未找到订单明细 - OrderNo: {orderNo}");
                    return;
                }

                // æ£€æŸ¥çŠ¶æ€
                bool allCompleted = true;
                bool hasInProgress = false;

                foreach (var detail in orderDetails)
                {
                    // æ£€æŸ¥æ˜¯å¦å®Œæˆ
                    if (detail.OverOutQuantity < detail.NeedOutQuantity)
                    {
                        allCompleted = false;
                    }

                    // æ£€æŸ¥æ˜¯å¦æœ‰è¿›è¡Œä¸­çš„任务（锁定或部分拣选）
                    if (detail.LockQuantity > 0 ||
                        detail.OrderDetailStatus == (int)OrderDetailStatusEnum.Outbound)
                    {
                        hasInProgress = true;
                    }
                }

                var outboundOrder = await _outboundOrderService.Db.Queryable<Dt_OutboundOrder>()
                    .FirstAsync(x => x.OrderNo == orderNo);

                if (outboundOrder == null)
                {
                    _logger.LogWarning($"未找到出库订单 - OrderNo: {orderNo}");
                    return;
                }

                int newStatus;
                if (allCompleted)
                {
                    newStatus = (int)OutOrderStatusEnum.出库完成;
                }
                else if (hasInProgress)
                {
                    newStatus = (int)OutOrderStatusEnum.出库中;
                }
                else
                {
                    newStatus = (int)OutOrderStatusEnum.未开始;
                }

                if (outboundOrder.OrderStatus != newStatus)
                {
                    await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
                        .SetColumns(x => new Dt_OutboundOrder
                        {
                            OrderStatus = newStatus,
                            Operator = App.User.UserName, 
                        })
                        .Where(x => x.OrderNo == orderNo)
                        .ExecuteCommandAsync();

                    _logger.LogInformation($"更新订单状态 - OrderNo: {orderNo}, æ—§çŠ¶æ€: {outboundOrder.OrderStatus}, æ–°çŠ¶æ€: {newStatus}");
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"RecalculateOrderStatus失败 - OrderNo: {orderNo}, Error: {ex.Message}");
                throw;
            }
        }


        /// <summary>
        /// åˆ é™¤é›¶åº“存数据（增强版）
        /// </summary>
        private async Task DeleteZeroQuantityStockDetails(int stockId)
        {
            try
            {
                // æŸ¥æ‰¾åº“存数量为0的记录
                var zeroStockDetails = await _stockService.StockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockId && x.StockQuantity <= 0)
                    .ToListAsync();

                if (zeroStockDetails.Any())
                {
                    await _stockService.StockInfoDetailService.Db.Deleteable(zeroStockDetails).ExecuteCommandAsync();
                    _logger.LogInformation($"删除{zeroStockDetails.Count}条零库存记录 - StockId: {stockId}");
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"DeleteZeroQuantityStockDetails失败 - StockId: {stockId}, Error: {ex.Message}");
                throw;
            }
        }

        private async Task HandleOutboundOrderToMESCompletion(Dt_OutboundOrder outboundOrder, string orderNo)
        {
@@ -697,29 +1040,44 @@
                            var detailLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                                .Where(x => x.OrderNo == orderNo &&
                                           x.OrderDetailId == detail.Id &&
                                           x.Status == (int)OutLockStockStatusEnum.拣选完成)
                                           (x.Status == (int)OutLockStockStatusEnum.拣选完成 || x.Status == (int)OutLockStockStatusEnum.已回库))
                                .ToListAsync();

                            var detailModel = new AllocateDtoDetail
                            {
                                MaterialCode = detail.MaterielCode,
                                LineNo = detail.lineNo, // æ³¨æ„ï¼šè¿™é‡Œå¯èƒ½éœ€è¦è°ƒæ•´å­—段名
                                LineNo = detail.lineNo,
                                WarehouseCode = detail.WarehouseCode,
                                Qty = detail.OverOutQuantity, // ä½¿ç”¨è®¢å•æ˜Žç»†çš„已出库数量
                                //currentDeliveryQty = detail.OverOutQuantity,
                                Unit = detail.Unit,
                                Barcodes = detailLocks.Select(lockInfo => new BarcodeInfo
                                {
                                    Barcode = lockInfo.CurrentBarcode,
                                    SupplyCode = lockInfo.SupplyCode,
                                    BatchNo = lockInfo.BatchNo,
                                    Unit = lockInfo.BarcodeUnit,
                                    Qty = lockInfo.BarcodeQty // æ¡ç çº§åˆ«çš„数量仍用锁定记录
                                }).ToList()
                                Qty =0,
                                Unit = detail.BarcodeUnit,
                                Barcodes = new List<BarcodeInfo>()
                            };
                            foreach (var item in detailLocks)
                            {
                                var barModel = new BarcodeInfo
                                {
                                    Barcode = item.CurrentBarcode,
                                    SupplyCode = item.SupplyCode,
                                    BatchNo = item.BatchNo,
                                    Unit = item.BarcodeUnit,
                                    Qty = 0
                                };
                                // å•ä½ä¸ä¸€è‡´æ—¶è½¬æ¢
                                if (item.BarcodeUnit != item.Unit)
                                {
                                    var convertResult = await _materialUnitService.ConvertAsync(item.MaterielCode, item.PickedQty, item.Unit, item.BarcodeUnit);
                                    barModel.Unit = convertResult.Unit;
                                    barModel.Qty = convertResult.Quantity;
                                }

                                detailModel.Qty += barModel.Qty;
                                detailModel.Barcodes.Add(barModel);
                            }


                            allocatefeedmodel.Details.Add(detailModel);
                        }

                        var result = await _invokeMESService.FeedbackAllocate(allocatefeedmodel);
                        if (result != null && result.code == 200)
                        {
@@ -762,7 +1120,7 @@
                            var detailLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                                .Where(x => x.OrderNo == orderNo &&
                                           x.OrderDetailId == detail.Id &&
                                           x.Status == (int)OutLockStockStatusEnum.拣选完成)
                                           (x.Status == (int)OutLockStockStatusEnum.拣选完成 || x.Status == (int)OutLockStockStatusEnum.已回库))
                                .ToListAsync();

                            var detailModel = new FeedbackOutboundDetailsModel
@@ -770,19 +1128,33 @@
                                materialCode = detail.MaterielCode,
                                lineNo = detail.lineNo, // æ³¨æ„ï¼šè¿™é‡Œå¯èƒ½éœ€è¦è°ƒæ•´å­—段名
                                warehouseCode = detail.WarehouseCode,
                                qty = detail.BarcodeQty,  
                                currentDeliveryQty = detail.BarcodeQty,
                                qty = 0,
                                currentDeliveryQty =0,
                                unit = detail.Unit,
                                barcodes = detailLocks.Select(lockInfo => new WIDESEA_DTO.Outbound.BarcodesModel
                                {
                                    barcode = lockInfo.CurrentBarcode,
                                    supplyCode = lockInfo.SupplyCode,
                                    batchNo = lockInfo.BatchNo,
                                    unit = lockInfo.BarcodeUnit,
                                    qty = lockInfo.BarcodeQty // æ¡ç çº§åˆ«çš„数量仍用锁定记录
                                }).ToList()
                                barcodes = new List<WIDESEA_DTO.Outbound.BarcodesModel>()
                            };
                            foreach (var item in detailLocks)
                            {
                                var barModel = new WIDESEA_DTO.Outbound.BarcodesModel
                                {
                                    barcode = item.CurrentBarcode,
                                    supplyCode = item.SupplyCode,
                                    batchNo = item.BatchNo,
                                    unit = item.BarcodeUnit,
                                    qty = item.PickedQty
                                };
                                // å•ä½ä¸ä¸€è‡´æ—¶è½¬æ¢
                                if (item.BarcodeUnit != item.Unit)
                                {
                                    var convertResult = await _materialUnitService.ConvertAsync(item.MaterielCode, item.PickedQty, item.Unit, item.BarcodeUnit);
                                    barModel.unit = convertResult.Unit;
                                    barModel.qty = convertResult.Quantity;
                                }

                                detailModel.qty += barModel.qty;
                                detailModel.currentDeliveryQty += barModel.qty;
                                detailModel.barcodes.Add(barModel);
                            }
                            feedmodel.details.Add(detailModel);
                        }
                        var result = await _invokeMESService.FeedbackOutbound(feedmodel);
@@ -808,60 +1180,7 @@

        }

        /// <summary>
        /// åˆ é™¤åº“存数为0的库存明细记录
        /// </summary>
        private async Task DeleteZeroQuantityStockDetails(int stockId)
        {
            try
            {
                // åˆ é™¤åº“存数量为0的记录
                var deleteCount = await _stockService.StockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockId &&
                               x.StockQuantity == 0 &&
                               (x.Status == StockStatusEmun.出库完成.ObjToInt() || x.Status ==
                                          StockStatusEmun.入库完成.ObjToInt())) // åªåˆ é™¤å·²å®ŒæˆçŠ¶æ€çš„零库存
                    .ExecuteCommandAsync();

                if (deleteCount > 0)
                {
                    _logger.LogInformation($"删除{deleteCount}条零库存明细记录 - StockId: {stockId}");
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning($"删除零库存记录失败 - StockId: {stockId}, Error: {ex.Message}");
                // æ³¨æ„ï¼šåˆ é™¤å¤±è´¥ä¸åº”该影响主流程，记录日志后继续
            }
        }
        /// <summary>
        /// å¤„理回库相关的所有库存明细状态变更
        /// </summary>
        private async Task ProcessStockDetailsForReturn(Dt_Task returnTask, int stockId)
        {
            // èŽ·å–该托盘下所有需要回库的库存明细
            var stockDetails = await _stockService.StockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                .Where(x => x.StockId == stockId &&
                           x.StockQuantity > 0 &&
                          (x.Status == StockStatusEmun.出库锁定.ObjToInt() || x.Status ==
                                      StockStatusEmun.入库确认.ObjToInt()))  // åŒ…括出库锁定和入库确认的
                .ToListAsync();

            foreach (var detail in stockDetails)
            {

                detail.Status = StockStatusEmun.入库完成.ObjToInt();
                detail.OutboundQuantity = 0;  // æ¸…空出库数量       

                _logger.LogInformation($"更新库存明细状态 - æ¡ç : {detail.Barcode}, æ•°é‡: {detail.StockQuantity}");
            }

            if (stockDetails.Any())
            {
                await _stockService.StockInfoDetailService.Db.Updateable(stockDetails).ExecuteCommandAsync();
                _logger.LogInformation($"共更新{stockDetails.Count}个库存明细状态为入库完成");
            }
        }
        public async Task<WebResponseContent> OutEmptyTaskCompleted(Dt_Task task)
        {
            WebResponseContent content = new WebResponseContent();