提交

pan

2025-12-01 74ab8260224fd69add7b0b7c98ad139b28136334

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

@@ -10,9 +10,12 @@
using WIDESEA_Common.CommonEnum;
using WIDESEA_Common.OrderEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_DTO.Basic;
using WIDESEA_DTO.Outbound;
using WIDESEA_IAllocateService;
using WIDESEA_IBasicService;
@@ -217,7 +220,7 @@
                .Where(x => x.OrderNo == orderNo &&
                           x.PalletCode == palletCode &&
                           x.CurrentBarcode == barcode
                        //&& x.Status == (int)OutLockStockStatusEnum.出库中
                          //&& x.Status == (int)OutLockStockStatusEnum.出库中
                          )
                .FirstAsync();

@@ -241,166 +244,6 @@

        #endregion

        #region å–走空箱逻辑

        

        /// <summary>
        /// å–走空箱 - æ¸…理已完成拣选的托盘数据
        /// </summary>
        public async Task<WebResponseContent> RemoveEmptyPallet(string orderNo, string palletCode)
        {
            try
            {
                _unitOfWorkManage.BeginTran();

                // éªŒè¯æ‰˜ç›˜æ˜¯å¦å¯ä»¥å–走（必须全部完成拣选）
                var validationResult = await ValidateEmptyPalletRemoval(orderNo, palletCode);
                if (!validationResult.IsValid)
                    return WebResponseContent.Instance.Error(validationResult.ErrorMessage);

                var completedLocks = validationResult.Data;

                // æ¸…理锁定记录（标记为已完成）
                await CleanupCompletedLocks(completedLocks);

                // æ›´æ–°ç›¸å…³è®¢å•çŠ¶æ€
                await UpdateOrderStatusAfterPalletRemoval(orderNo);

                // è®°å½•æ“ä½œåŽ†å²
               // await RecordEmptyPalletRemoval(orderNo, palletCode, completedLocks);

                _unitOfWorkManage.CommitTran();

                return WebResponseContent.Instance.OK("取走空箱成功");
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                _logger.LogError($"取走空箱失败 - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
                return WebResponseContent.Instance.Error($"取走空箱失败：{ex.Message}");
            }
        }

        /// <summary>
        /// éªŒè¯ç©ºç®±å–走条件
        /// </summary>
        private async Task<ValidationResult<List<Dt_OutStockLockInfo>>> ValidateEmptyPalletRemoval(string orderNo, string palletCode)
        {
            // èŽ·å–托盘的所有锁定记录
            var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
                .ToListAsync();

            if (!lockInfos.Any())
                return ValidationResult<List<Dt_OutStockLockInfo>>.Error("该托盘没有锁定记录");

            // æ£€æŸ¥æ˜¯å¦æœ‰æœªå®Œæˆçš„锁定记录
            var unfinishedLocks = lockInfos.Where(x =>
                x.Status == (int)OutLockStockStatusEnum.出库中 ||
                x.Status == (int)OutLockStockStatusEnum.回库中).ToList();

            if (unfinishedLocks.Any())
            {
                var unfinishedCount = unfinishedLocks.Count;
                var unfinishedQty = unfinishedLocks.Sum(x => x.AssignQuantity - x.PickedQty);
                return ValidationResult<List<Dt_OutStockLockInfo>>.Error(
                    $"托盘还有{unfinishedCount}条未完成记录，剩余数量{unfinishedQty}，不能取走空箱");
            }

            // èŽ·å–已完成的锁定记录
            var completedLocks = lockInfos.Where(x =>
                x.Status == (int)OutLockStockStatusEnum.拣选完成).ToList();

            if (!completedLocks.Any())
                return ValidationResult<List<Dt_OutStockLockInfo>>.Error("该托盘没有已完成拣选的记录");

            return ValidationResult<List<Dt_OutStockLockInfo>>.Success(completedLocks);
        }

        /// <summary>
        /// æ¸…理已完成的锁定记录
        /// </summary>
        private async Task CleanupCompletedLocks(List<Dt_OutStockLockInfo> completedLocks)
        {
            foreach (var lockInfo in completedLocks)
            {
                // æ ‡è®°é”å®šè®°å½•ä¸ºå·²å–èµ°
                lockInfo.Status = (int)OutLockStockStatusEnum.已取走;
                lockInfo.Operator = App.User.UserName;
                await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

                // æ¸…理对应的库存记录状态
                await CleanupStockInfo(lockInfo);
            }
        }

        /// <summary>
        /// æ¸…理库存信息
        /// </summary>
        private async Task CleanupStockInfo(Dt_OutStockLockInfo lockInfo)
        {
            var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

            if (stockDetail != null && stockDetail.Status == (int)StockStatusEmun.出库完成)
            {
                stockDetail.Status = (int)StockStatusEmun.已清理;
                await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
            }
        }
 

        /// <summary>
        /// æ›´æ–°è®¢å•çŠ¶æ€
        /// </summary>
        private async Task UpdateOrderStatusAfterPalletRemoval(string orderNo)
        {
            // æ£€æŸ¥è®¢å•æ˜¯å¦æ‰€æœ‰æ‰˜ç›˜éƒ½å·²å®Œæˆ
            var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderNo == orderNo)
                .ToListAsync();

            var unfinishedPallets = allLocks
                .GroupBy(x => x.PalletCode)
                .Where(g => g.Any(x => x.Status == (int)OutLockStockStatusEnum.出库中 ||
                                      x.Status == (int)OutLockStockStatusEnum.回库中))
                .ToList();

            // å¦‚果没有未完成的托盘，更新订单状态为出库完成
            if (!unfinishedPallets.Any())
            {
                await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
                    .SetColumns(x => new Dt_OutboundOrder
                    {
                        OrderStatus = (int)OutOrderStatusEnum.出库完成,
                    })
                    .Where(x => x.OrderNo == orderNo)
                    .ExecuteCommandAsync();
            }
        }

        /// <summary>
        /// è®°å½•ç©ºç®±å–走历史
        /// </summary>
        private async Task RecordEmptyPalletRemoval(string orderNo, string palletCode, List<Dt_OutStockLockInfo> completedLocks)
        {
            var removalRecord = new Dt_EmptyPalletRemoval
            {
                OrderNo = orderNo,
                PalletCode = palletCode,
                RemovalTime = DateTime.Now,
                Operator = App.User.UserName,
                CompletedItemsCount = completedLocks.Count,
                TotalPickedQuantity = completedLocks.Sum(x => x.PickedQty)
            };

            await Db.Insertable(removalRecord).ExecuteCommandAsync();
        }

        #endregion

  
        #region åˆ†æ‰¹åˆ†æ‹£

        /// <summary>
@@ -433,7 +276,7 @@

                    (lockInfo, orderDetail, stockDetail, batch) = refreshedValidation.Data;

                    // é‡è¦ä¿®å¤ï¼šè‡ªåŠ¨æ‹†åŒ…后，立即执行原条码的分拣

                    var actualPickedQty = lockInfo.AssignQuantity;
                    var pickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, actualPickedQty);

@@ -445,15 +288,7 @@

                    _unitOfWorkManage.CommitTran();

                    return WebResponseContent.Instance.OK("自动拆包并分拣成功", new
                    {
                        AutoSplitted = true,
                        NewBarcode = autoSplitResult.NewBarcode,
                        OriginalBarcode = barcode,
                        SplitQuantity = autoSplitResult.SplitQuantity,
                        PickedQuantity = actualPickedQty,
                        MaterialCode = lockInfo.MaterielCode
                    });
                    return WebResponseContent.Instance.OK("自动拆包并分拣成功", autoSplitResult);
                }

                // æ­£å¸¸åˆ†æ‹£æµç¨‹ï¼ˆä¸éœ€è¦è‡ªåŠ¨æ‹†åŒ…）
@@ -529,9 +364,159 @@
        }
        #endregion

        #region æ‰‹åŠ¨æ‹†åŒ…

        #region æ‰‹åŠ¨æ‹†åŒ…相关方法
        #region å–走空箱逻辑



        /// <summary>
        /// éªŒè¯ç©ºç®±å–走条件
        /// </summary>
        private async Task<ValidationResult<List<Dt_OutStockLockInfo>>> ValidateEmptyPalletRemoval(string orderNo, string palletCode)
        {
            // èŽ·å–托盘的所有锁定记录
            var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
                .ToListAsync();

            if (!lockInfos.Any())
                return ValidationResult<List<Dt_OutStockLockInfo>>.Error("该托盘没有锁定记录");

            // æ£€æŸ¥æ˜¯å¦æœ‰æœªå®Œæˆçš„锁定记录
            var unfinishedLocks = lockInfos.Where(x =>
                x.Status == (int)OutLockStockStatusEnum.出库中 ||
                x.Status == (int)OutLockStockStatusEnum.回库中).ToList();

            if (unfinishedLocks.Any())
            {
                var unfinishedCount = unfinishedLocks.Count;
                var unfinishedQty = unfinishedLocks.Sum(x => x.AssignQuantity - x.PickedQty);
                return ValidationResult<List<Dt_OutStockLockInfo>>.Error(
                    $"托盘还有{unfinishedCount}条未完成记录，剩余数量{unfinishedQty}，不能取走空箱");
            }

            // èŽ·å–已完成的锁定记录
            var completedLocks = lockInfos.Where(x =>
                x.Status == (int)OutLockStockStatusEnum.拣选完成).ToList();

            if (!completedLocks.Any())
                return ValidationResult<List<Dt_OutStockLockInfo>>.Error("该托盘没有已完成拣选的记录");

            return ValidationResult<List<Dt_OutStockLockInfo>>.Success(completedLocks);
        }

        /// <summary>
        /// æ¸…理已完成的锁定记录
        /// </summary>
        private async Task CleanupCompletedLocks(List<Dt_OutStockLockInfo> completedLocks)
        {
            foreach (var lockInfo in completedLocks)
            {
                // æ ‡è®°é”å®šè®°å½•ä¸ºå·²å–èµ°
                lockInfo.Status = (int)OutLockStockStatusEnum.已取走;
                lockInfo.Operator = App.User.UserName;
                await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

                // æ¸…理对应的库存记录状态
                await CleanupStockInfo(lockInfo);
            }
        }

        /// <summary>
        /// æ¸…理库存信息
        /// </summary>
        private async Task CleanupStockInfo(Dt_OutStockLockInfo lockInfo)
        {
            var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

            if (stockDetail != null && stockDetail.Status == (int)StockStatusEmun.出库完成)
            {
                stockDetail.Status = (int)StockStatusEmun.已清理;
                await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
            }
        }


        /// <summary>
        /// æ›´æ–°è®¢å•çŠ¶æ€
        /// </summary>
        private async Task UpdateOrderStatusAfterPalletRemoval(string orderNo)
        {
            // æ£€æŸ¥è®¢å•æ˜¯å¦æ‰€æœ‰æ‰˜ç›˜éƒ½å·²å®Œæˆ
            var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderNo == orderNo)
                .ToListAsync();

            var unfinishedPallets = allLocks
                .GroupBy(x => x.PalletCode)
                .Where(g => g.Any(x => x.Status == (int)OutLockStockStatusEnum.出库中 ||
                                      x.Status == (int)OutLockStockStatusEnum.回库中))
                .ToList();

            // å¦‚果没有未完成的托盘，更新订单状态为出库完成
            if (!unfinishedPallets.Any())
            {
                await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
                    .SetColumns(x => new Dt_OutboundOrder
                    {
                        OrderStatus = (int)OutOrderStatusEnum.出库完成,
                    })
                    .Where(x => x.OrderNo == orderNo)
                    .ExecuteCommandAsync();
            }
        }

        /// <summary>
        /// è®°å½•ç©ºç®±å–走历史
        /// </summary>
        private async Task RecordEmptyPalletRemoval(string orderNo, string palletCode, List<Dt_OutStockLockInfo> completedLocks)
        {
            var removalRecord = new Dt_EmptyPalletRemoval
            {
                OrderNo = orderNo,
                PalletCode = palletCode,
                RemovalTime = DateTime.Now,
                Operator = App.User.UserName,
                CompletedItemsCount = completedLocks.Count,
                TotalPickedQuantity = completedLocks.Sum(x => x.PickedQty)
            };

            await Db.Insertable(removalRecord).ExecuteCommandAsync();
        }

        #endregion

        private List<SplitResult> CreateSplitResults(Dt_OutStockLockInfo lockInfo, decimal splitQty, decimal remainQty, string newBarcode, string originalBarcode)
        {
            return new List<SplitResult>
        {
            new SplitResult
            {
                materialCode = lockInfo.MaterielCode,
                supplierCode = lockInfo.SupplyCode,
                quantityTotal = splitQty.ToString("F2"),
                batchNumber = newBarcode,
                batch = lockInfo.BatchNo,
                factory = lockInfo.FactoryArea,
                date = DateTime.Now.ToString("yyyy-MM-dd"),
            },
            new SplitResult
            {
                materialCode = lockInfo.MaterielCode,
                supplierCode = lockInfo.SupplyCode,
                quantityTotal = remainQty.ToString("F2"),
                batchNumber = originalBarcode,
                batch = lockInfo.BatchNo,
                factory = lockInfo.FactoryArea,
                date = DateTime.Now.ToString("yyyy-MM-dd"),
            }
        };
        }
      
    

        #region æ‰‹åŠ¨æ‹†åŒ…   

        /// <summary>
        /// æ‰‹åŠ¨æ‹†åŒ…
@@ -554,12 +539,7 @@

                _unitOfWorkManage.CommitTran();

                return WebResponseContent.Instance.OK("手动拆包成功", new
                {
                    NewBarcode = splitResult.NewBarcode,
                    OriginalBarcode = originalBarcode,
                    SplitQuantity = splitQuantity
                });
                return WebResponseContent.Instance.OK("手动拆包成功", splitResult);
            }
            catch (Exception ex)
            {
@@ -676,7 +656,7 @@
        /// <summary>
        /// æ‰§è¡Œæ‰‹åŠ¨æ‹†åŒ…逻辑 - å¢žå¼ºåˆ†é…æ•°é‡æŽ§åˆ¶
        /// </summary>
        private async Task<SplitResultDto> ExecuteManualSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
        private async Task<List<SplitResult>> ExecuteManualSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
            decimal splitQuantity, string palletCode)
        {
            _logger.LogInformation($"开始执行手动拆包逻辑 - åŽŸæ¡ç : {stockDetail.Barcode}, æ‹†åŒ…数量: {splitQuantity}");
@@ -700,8 +680,12 @@
            // è®°å½•æ‹†åŒ…前的分配数量
            decimal originalAssignQtyBefore = lockInfo.AssignQuantity;
            decimal originalOrderQtyBefore = lockInfo.OrderQuantity;

            // 1. åˆ›å»ºæ–°åº“存明细
            decimal remainQty = originalAssignQtyBefore - splitQuantity;
            if (remainQty < 0)
            {
                throw new InvalidOperationException($"拆包后剩余数量为负数，原分配数量: {originalAssignQtyBefore}, æ‹†åŒ…数量: {splitQuantity}");
            }
            //  åˆ›å»ºæ–°åº“存明细
            var newStockDetail = new Dt_StockInfoDetail
            {
                StockId = stockDetail.StockId,
@@ -717,18 +701,23 @@
                BarcodeQty = stockDetail.BarcodeQty,
                BarcodeUnit = stockDetail.BarcodeUnit,
                BusinessType = stockDetail.BusinessType,
                InboundOrderRowNo = stockDetail.InboundOrderRowNo, 
                InboundOrderRowNo = stockDetail.InboundOrderRowNo,
            };
            await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
            _logger.LogInformation($"创建新库存明细 - æ¡ç : {newBarcode}, åº“存数量: {splitQuantity}");

            // 2. æ›´æ–°åŽŸåº“存明细
            //  æ›´æ–°åŽŸåº“存明细
            decimal originalStockQtyBefore = stockDetail.StockQuantity;
            stockDetail.StockQuantity -= splitQuantity;
            if (stockDetail.StockQuantity < 0)
            {
                stockDetail.StockQuantity = 0;
                _logger.LogWarning($"原库存数量出现负数，重置为0");
            }
            await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
            _logger.LogInformation($"更新原库存明细 - åº“存数量从 {originalStockQtyBefore} å‡å°‘到 {stockDetail.StockQuantity}");

            // 3. åˆ›å»ºæ–°é”å®šä¿¡æ¯
            //   åˆ›å»ºæ–°é”å®šä¿¡æ¯
            var newLockInfo = new Dt_OutStockLockInfo
            {
                OrderNo = lockInfo.OrderNo,
@@ -755,35 +744,35 @@
                lineNo = lockInfo.lineNo,
                WarehouseCode = lockInfo.WarehouseCode,
                BarcodeQty = lockInfo.BarcodeQty,
                BarcodeUnit = lockInfo.BarcodeUnit, 
                BarcodeUnit = lockInfo.BarcodeUnit,
            };

            await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();
            _logger.LogInformation($"创建新锁定信息 - æ¡ç : {newBarcode}, åˆ†é…æ•°é‡: {splitQuantity}");

            // 4. æ›´æ–°åŽŸé”å®šä¿¡æ¯
            lockInfo.AssignQuantity -= splitQuantity;
            lockInfo.OrderQuantity -= splitQuantity;
            //  æ›´æ–°åŽŸé”å®šä¿¡æ¯
            lockInfo.AssignQuantity = remainQty;
            lockInfo.OrderQuantity = remainQty;

            _logger.LogInformation($"更新原锁定信息 - åˆ†é…æ•°é‡ä»Ž {originalAssignQtyBefore} å‡å°‘到 {lockInfo.AssignQuantity}");
            _logger.LogInformation($"更新原锁定信息 - è®¢å•æ•°é‡ä»Ž {originalOrderQtyBefore} å‡å°‘到 {lockInfo.OrderQuantity}");

            await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

            // é‡è¦ä¿®å¤ï¼šæ‰‹åŠ¨æ‹†åŒ…不会改变订单明细的分配数量，因为总分配数量不变
            // åªæ˜¯ä»Žä¸€ä¸ªé”å®šä¿¡æ¯è½¬ç§»åˆ°å¦ä¸€ä¸ªé”å®šä¿¡æ¯
          
            _logger.LogInformation($"订单明细分配数量保持不变 - å·²åˆ†é…æ•°é‡: {orderDetail.AllocatedQuantity}");

            // 5. è®°å½•æ‹†åŒ…历史
            //   è®°å½•æ‹†åŒ…历史
            await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode, false);

            //  åˆ›å»ºæ‹†åŒ…结果列表
            var splitResults = CreateSplitResults(lockInfo, splitQuantity, remainQty, newBarcode, stockDetail.Barcode);

            _logger.LogInformation($"手动拆包逻辑执行完成");

            return new SplitResultDto { NewBarcode = newBarcode };
            return splitResults;
        }

        #endregion

 
        #endregion


@@ -848,7 +837,7 @@
            decimal originalAssignQtyBefore = originalLockInfo.AssignQuantity;
            decimal originalOrderQtyBefore = originalLockInfo.OrderQuantity;

            // é‡è¦ä¿®å¤ï¼šæ¢å¤åˆ†é…æ•°é‡å’Œè®¢å•æ•°é‡
 
            originalLockInfo.AssignQuantity += splitRecord.SplitQty;
            originalLockInfo.OrderQuantity += splitRecord.SplitQty;

@@ -885,17 +874,20 @@
                await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
            }

            // åˆ é™¤æ–°é”å®šä¿¡æ¯
            _logger.LogInformation($"删除新锁定信息 - æ¡ç : {newLockInfo.CurrentBarcode}, åˆ†é…æ•°é‡: {newLockInfo.AssignQuantity}");
            await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
                .Where(x => x.Id == newLockInfo.Id)
                .ExecuteCommandAsync();
            if (newLockInfo != null)
            {
                // åˆ é™¤æ–°é”å®šä¿¡æ¯
                _logger.LogInformation($"删除新锁定信息 - æ¡ç : {newLockInfo?.CurrentBarcode}, åˆ†é…æ•°é‡: {newLockInfo?.AssignQuantity}");
                await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
                    .Where(x => x.Id == newLockInfo.Id)
                    .ExecuteCommandAsync();

            //  åˆ é™¤æ–°åº“存明细
            _logger.LogInformation($"删除新库存明细 - æ¡ç : {newStockDetail.Barcode}, åº“存数量: {newStockDetail.StockQuantity}");
            await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
                .Where(x => x.Barcode == newLockInfo.CurrentBarcode)
                .ExecuteCommandAsync();
                //  åˆ é™¤æ–°åº“存明细
                _logger.LogInformation($"删除新库存明细 - æ¡ç : {newStockDetail.Barcode}, åº“存数量: {newStockDetail.StockQuantity}");
                await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
                    .Where(x => x.Barcode == newLockInfo.CurrentBarcode)
                    .ExecuteCommandAsync();
            }

            // æ ‡è®°æ‹†åŒ…记录为已撤销
            splitRecord.IsReverted = true;
@@ -1108,7 +1100,7 @@
                return WebResponseContent.Instance.Error("获取条码状态失败");
            }
        }
         /// <summary>
        /// <summary>
        /// èŽ·å–操作建议
        /// </summary>
        private List<string> GetOperationSuggestions(BarcodeStatusInfoDto statusInfo)
@@ -1284,7 +1276,7 @@
                        NewBarcode = x.NewBarcode,
                        SplitQuantity = x.SplitQty,
                        Operator = x.Operator,
                        IsReverted = x.IsReverted ,
                        IsReverted = x.IsReverted,
                        IsAutoSplit = x.IsAutoSplit
                    }).ToList()
                };
@@ -1374,61 +1366,708 @@

        #endregion

       
        #region åˆ†æ‰¹å›žåº“
         #region ç»Ÿä¸€å›žåº“逻辑
        private async Task<Dt_Task> GetCurrentTask(string orderNo, string palletCode)
        {
            // å…ˆå°è¯•é€šè¿‡è®¢å•å·å’Œæ‰˜ç›˜å·æŸ¥æ‰¾ä»»åŠ¡
            var task = await _taskRepository.Db.Queryable<Dt_Task>()
                .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
                .FirstAsync();

            if (task == null)
            {
                // å¦‚果找不到，再通过托盘号查找
                task = await _taskRepository.Db.Queryable<Dt_Task>()
                    .Where(x => x.PalletCode == palletCode)
                    .FirstAsync();
            }

            return task;
        }
        private async Task<PalletStatusAnalysis> AnalyzePalletStatus(string orderNo, string palletCode, int stockId)
        {
            var result = new PalletStatusAnalysis
            {
                OrderNo = orderNo,
                PalletCode = palletCode,
                StockId = stockId
            };

            // åˆ†æžæœªåˆ†æ‹£çš„出库锁定记录
            var remainingLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(it => it.OrderNo == orderNo &&
                           it.PalletCode == palletCode &&
                           it.Status == (int)OutLockStockStatusEnum.出库中)
                .ToListAsync();

            if (remainingLocks.Any())
            {
                result.HasRemainingLocks = true;
                result.RemainingLocks = remainingLocks;
                result.RemainingLocksReturnQty = remainingLocks.Sum(x => x.AssignQuantity - x.PickedQty);
                _logger.LogInformation($"发现{remainingLocks.Count}条未分拣锁定记录，总数量: {result.RemainingLocksReturnQty}");
            }

            // åˆ†æžæ‰˜ç›˜ä¸Šçš„库存货物
            var palletStockGoods = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                .Where(it => it.StockId == stockId &&
                     (it.Status == StockStatusEmun.入库确认.ObjToInt() ||
                      it.Status == StockStatusEmun.入库完成.ObjToInt() ||
                      it.Status == StockStatusEmun.出库锁定.ObjToInt()))
                .Where(it => it.StockQuantity > 0)
                .ToListAsync();

            if (palletStockGoods.Any())
            {
                result.HasPalletStockGoods = true;
                result.PalletStockGoods = palletStockGoods;
                result.PalletStockReturnQty = palletStockGoods.Sum(x => x.StockQuantity);
                _logger.LogInformation($"发现{palletStockGoods.Count}个库存货物，总数量: {result.PalletStockReturnQty}");

                // è®°å½•è¯¦ç»†çŠ¶æ€åˆ†å¸ƒ
                var statusGroups = palletStockGoods.GroupBy(x => x.Status);
                foreach (var group in statusGroups)
                {
                    _logger.LogInformation($"库存状态{group.Key}: {group.Count()}个货物，数量: {group.Sum(x => x.StockQuantity)}");
                }
            }

            //分析拆包记录
            var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
                .Where(it => it.OrderNo == orderNo &&
                           it.PalletCode == palletCode &&
                           !it.IsReverted && it.Status != (int)SplitPackageStatusEnum.已拣选 &&
                           it.Status != (int)SplitPackageStatusEnum.已回库)
                .ToListAsync();

            if (splitRecords.Any())
            {
                result.HasSplitRecords = true;
                result.SplitRecords = splitRecords;
                result.SplitReturnQty = await CalculateSplitReturnQuantity(splitRecords, stockId);

                _logger.LogInformation($"发现{splitRecords.Count}条未拣选拆包记录，总数量: {result.SplitReturnQty}");
            }

            // 4. è®¡ç®—总回库数量和空托盘状态
            result.TotalReturnQty = result.RemainingLocksReturnQty + result.PalletStockReturnQty + result.SplitReturnQty;
            result.HasItemsToReturn = result.TotalReturnQty > 0;
            result.IsEmptyPallet = !result.HasItemsToReturn;

            // 5. æ£€æŸ¥æ˜¯å¦æœ‰è¿›è¡Œä¸­çš„任务
            result.HasActiveTasks = await _taskRepository.Db.Queryable<Dt_Task>()
                .Where(x => x.OrderNo == orderNo && x.TaskType == TaskTypeEnum.InPick.ObjToInt() &&
                           x.PalletCode == palletCode &&
                           x.TaskStatus == (int)TaskStatusEnum.New)
                .AnyAsync();

            _logger.LogInformation($"托盘状态分析完成 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}, " +
                                  $"总回库数量: {result.TotalReturnQty}, æ˜¯å¦ç©ºæ‰˜ç›˜: {result.IsEmptyPallet}, " +
                                  $"有进行中任务: {result.HasActiveTasks}");

            return result;
        }
        private async Task<decimal> CalculateSplitReturnQuantity(List<Dt_SplitPackageRecord> splitRecords, int stockId)
        {
            decimal totalQty = 0;
            var processedBarcodes = new HashSet<string>();

            foreach (var splitRecord in splitRecords)
            {
                if (splitRecord.Status != (int)SplitPackageStatusEnum.已撤销)
                    continue;
                // æ£€æŸ¥åŽŸæ¡ç 
                if (!processedBarcodes.Contains(splitRecord.OriginalBarcode))
                {
                    var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                        .Where(it => it.Barcode == splitRecord.OriginalBarcode && it.StockId == stockId &&
                           it.Status != StockStatusEmun.出库完成.ObjToInt())
                        .FirstAsync();

                    if (originalStock != null && originalStock.StockQuantity > 0)
                    {
                        totalQty += originalStock.StockQuantity;
                        processedBarcodes.Add(splitRecord.OriginalBarcode);
                    }
                }

                // æ£€æŸ¥æ–°æ¡ç 
                if (!processedBarcodes.Contains(splitRecord.NewBarcode))
                {
                    var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                        .Where(it => it.Barcode == splitRecord.NewBarcode && it.StockId == stockId && it.Status != StockStatusEmun.出库完成.ObjToInt())
                        .FirstAsync();

                    if (newStock != null && newStock.StockQuantity > 0)
                    {
                        totalQty += newStock.StockQuantity;
                        processedBarcodes.Add(splitRecord.NewBarcode);
                    }
                }
            }

            return totalQty;
        }

        /// <summary>
        /// åˆ†æ‰¹å›žåº“ - é‡Šæ”¾æœªæ‹£é€‰çš„库存
        /// ç»Ÿä¸€å›žåº“方法 - å¤„理托盘上所有剩余货物
        /// </summary>
        public async Task<WebResponseContent> BatchReturnStock(string orderNo, string palletCode)
        public async Task<WebResponseContent> ExecutePalletReturn(string orderNo, string palletCode, string returnReason = "分批回库")
        {
            try
            {
                _unitOfWorkManage.BeginTran();

                // æŸ¥æ‰¾æ‰˜ç›˜ä¸Šæœªå®Œæˆçš„锁定记录（只处理出库中的记录）
                var unfinishedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderNo == orderNo &&
                               x.PalletCode == palletCode &&
                               x.Status == (int)OutLockStockStatusEnum.出库中)
                    .ToListAsync();
                if (string.IsNullOrEmpty(orderNo) || string.IsNullOrEmpty(palletCode))
                    return WebResponseContent.Instance.Error("订单号和托盘码不能为空");

                if (!unfinishedLocks.Any())
                    return WebResponseContent.Instance.Error("该托盘没有未完成的锁定记录");
                // èŽ·å–库存信息
                var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>().FirstAsync(x => x.PalletCode == palletCode);
                if (stockInfo == null)
                    return WebResponseContent.Instance.Error($"未找到托盘 {palletCode} å¯¹åº”的库存信息");

                // æŒ‰å‡ºåº“批次分组处理
                var batchGroups = unfinishedLocks.GroupBy(x => x.OutboundBatchNo); // ä½¿ç”¨ OutboundBatchNo
                var task = await GetCurrentTask(orderNo, palletCode);
                if (task == null)
                    return WebResponseContent.Instance.Error("未找到对应的任务信息");

                foreach (var batchGroup in batchGroups)
                // åˆ†æžæ‰˜ç›˜çŠ¶æ€
                var statusAnalysis = await AnalyzePalletStatus(orderNo, palletCode, stockInfo.Id);
                if (!statusAnalysis.HasItemsToReturn)
                    return await HandleNoReturnItems(orderNo, palletCode, task, stockInfo.Id);

                // æ£€æŸ¥æ˜¯å¦æœ‰è¿›è¡Œä¸­çš„任务
                if (statusAnalysis.HasActiveTasks)
                {
                    var outboundBatchNo = batchGroup.Key;
                    var batchLocks = batchGroup.ToList();

                    // é‡Šæ”¾åº“存和锁定记录
                    foreach (var lockInfo in batchLocks)
                    {
                        await ReleaseLockAndStock(lockInfo);
                    }

                    // æ›´æ–°æ‰¹æ¬¡çŠ¶æ€
                    await UpdateBatchStatusForReturn(outboundBatchNo, batchLocks);

                    // æ›´æ–°è®¢å•æ˜Žç»†çš„已分配数量
                    await UpdateOrderDetailAfterReturn(batchLocks);
                    return WebResponseContent.Instance.Error($"托盘 {palletCode} æœ‰è¿›è¡Œä¸­çš„任务，不能执行回库操作");
                }

                // æ‰§è¡Œå›žåº“操作
                await ExecuteReturnDataOperations(orderNo, palletCode, stockInfo, task, statusAnalysis);

                // é‡Šæ”¾æ‰€æœ‰é”å®šä»¥ä¾¿é‡æ–°åˆ†é…
                await ReleaseAllLocksForReallocation(orderNo, palletCode, statusAnalysis);

                _unitOfWorkManage.CommitTran();

                return WebResponseContent.Instance.OK("分批回库成功");
                // æ”¶é›†æ‰€æœ‰éœ€è¦å›žåº“的条码
                var returnBarcodes = await CollectReturnBarcodes(statusAnalysis);

                // åˆ›å»ºESS回库任务
                if (returnBarcodes.Any())
                {
                    _logger.LogInformation($"创建回库AGV任务 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}, æ¡ç æ•°é‡: {returnBarcodes.Count}, åŽŸå› : {returnReason}");
                    await CreateReturnTaskAndHandleESS(orderNo, palletCode, task, TaskTypeEnum.InPick, stockInfo.PalletType);
                }

                // æ›´æ–°è®¢å•çŠ¶æ€ï¼ˆä¸è§¦å‘MES回传）
                await UpdateOrderStatusForReturn(orderNo);

                return WebResponseContent.Instance.OK($"回库操作成功，共回库数量：{statusAnalysis.TotalReturnQty}", new
                {
                    ReturnQuantity = statusAnalysis.TotalReturnQty,
                    ReturnBarcodes = returnBarcodes,
                    Reason = returnReason,
                    PalletCode = palletCode,
                    OrderNo = orderNo
                });
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                _logger.LogError($"分批回库失败 - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
                return WebResponseContent.Instance.Error($"分批回库失败：{ex.Message}");
                _logger.LogError($"回库操作失败 - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
                return WebResponseContent.Instance.Error($"回库操作失败: {ex.Message}");
            }
        }
        private async Task ExecuteReturnDataOperations(string orderNo, string palletCode, Dt_StockInfo stockInfo,Dt_Task task, PalletStatusAnalysis statusAnalysis)
        {
            _logger.LogInformation($"开始执行回库数据操作 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");

            // 1. å¤„理未分拣的锁定记录
            if (statusAnalysis.HasRemainingLocks)
            {
                _logger.LogInformation($"处理 {statusAnalysis.RemainingLocks.Count} æ¡æœªåˆ†æ‹£é”å®šè®°å½•");
                await HandleRemainingLocksReturn(statusAnalysis.RemainingLocks);
            }

            // 2. å¤„理托盘上的库存货物
            if (statusAnalysis.HasPalletStockGoods)
            {
                _logger.LogInformation($"处理 {statusAnalysis.PalletStockGoods.Count} ä¸ªåº“存货物");
                await HandlePalletStockGoodsReturn(statusAnalysis.PalletStockGoods, stockInfo.Id);
            }

            // 3. å¤„理拆包记录
            if (statusAnalysis.HasSplitRecords)
            {
                _logger.LogInformation($"处理 {statusAnalysis.SplitRecords.Count} æ¡æ‹†åŒ…记录");
                await HandleSplitRecordsReturn(statusAnalysis.SplitRecords, stockInfo.Id);
            }

            _logger.LogInformation($"回库数据操作完成 - æ€»å›žåº“数量: {statusAnalysis.TotalReturnQty}");
        }
        /// <summary>
        /// åˆ†æ‰¹å›žåº“ - è°ƒç”¨ç»Ÿä¸€å›žåº“方法
        /// </summary>
        public async Task<WebResponseContent> BatchReturnStock(string orderNo, string palletCode)
        {
            return await ExecutePalletReturn(orderNo, palletCode, "分批回库");
        }

        /// <summary>
        /// å‰©ä½™å›žåº“ - è°ƒç”¨ç»Ÿä¸€å›žåº“方法
        /// </summary>
        public async Task<WebResponseContent> ReturnRemaining(string orderNo, string palletCode, string reason)
        {
            return await ExecutePalletReturn(orderNo, palletCode, reason);
        }

        /// <summary>
        /// å–走空箱 - å…ˆæ‰§è¡Œå›žåº“再清理 - å¢žå¼ºç‰ˆæœ¬
        /// </summary>
        public async Task<WebResponseContent> RemoveEmptyPallet(string orderNo, string palletCode)
        {
            try
            {
                _unitOfWorkManage.BeginTran();

                _logger.LogInformation($"开始取走空箱 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");

                // 1. éªŒè¯ç©ºç®±å–走条件（必须全部完成拣选）
                var validationResult = await ValidateEmptyPalletRemoval(orderNo, palletCode);
                if (!validationResult.IsValid)
                {
                    _unitOfWorkManage.RollbackTran();
                    return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
                }

                var completedLocks = validationResult.Data;

                // 2. æ¸…理已完成的锁定记录（标记为已取走）
                await CleanupCompletedLocks(completedLocks);

                // 3. æ¸…理对应的库存记录状态
                foreach (var lockInfo in completedLocks)
                {
                    await CleanupStockInfo(lockInfo);
                }

                // 4. æ›´æ–°ç›¸å…³è®¢å•çŠ¶æ€
                await UpdateOrderStatusAfterPalletRemoval(orderNo);

                // 5. è®°å½•æ“ä½œåŽ†å²
                await RecordEmptyPalletRemoval(orderNo, palletCode, completedLocks);

                _unitOfWorkManage.CommitTran();

                _logger.LogInformation($"取走空箱成功 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");

                return WebResponseContent.Instance.OK("取走空箱成功");
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                _logger.LogError($"取走空箱失败 - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
                return WebResponseContent.Instance.Error($"取走空箱失败：{ex.Message}");
            }
        }
        /// <summary>
        /// æ”¶é›†éœ€è¦å›žåº“的条码
        /// </summary>
        private async Task<List<string>> CollectReturnBarcodes(PalletStatusAnalysis status)
        {
            var returnBarcodes = new HashSet<string>();

            try
            {
                _logger.LogInformation($"开始收集回库条码 - è®¢å•: {status.OrderNo}, æ‰˜ç›˜: {status.PalletCode}");

                // 1. æ”¶é›†æœªåˆ†æ‹£é”å®šè®°å½•çš„条码
                if (status.HasRemainingLocks)
                {
                    foreach (var lockInfo in status.RemainingLocks)
                    {
                        if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
                        {
                            returnBarcodes.Add(lockInfo.CurrentBarcode);
                            _logger.LogInformation($"添加锁定记录条码: {lockInfo.CurrentBarcode}");
                        }
                    }
                }

                // 2. æ”¶é›†æ‰˜ç›˜ä¸Šåº“存货物的条码
                if (status.HasPalletStockGoods)
                {
                    foreach (var stockDetail in status.PalletStockGoods)
                    {
                        if (!string.IsNullOrEmpty(stockDetail.Barcode) && stockDetail.StockQuantity > 0)
                        {
                            returnBarcodes.Add(stockDetail.Barcode);
                            _logger.LogInformation($"添加库存货物条码: {stockDetail.Barcode}, æ•°é‡: {stockDetail.StockQuantity}");
                        }
                    }
                }

                // 3. æ”¶é›†æ‹†åŒ…记录相关的条码
                if (status.HasSplitRecords)
                {
                    foreach (var splitRecord in status.SplitRecords)
                    {
                        // æ·»åŠ åŽŸæ¡ç 
                        if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode))
                        {
                            var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                                .FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == status.StockId);

                            if (originalStock != null && originalStock.StockQuantity > 0)
                            {
                                returnBarcodes.Add(splitRecord.OriginalBarcode);
                                _logger.LogInformation($"添加拆包原条码: {splitRecord.OriginalBarcode}, æ•°é‡: {originalStock.StockQuantity}");
                            }
                        }

                        // æ·»åŠ æ–°æ¡ç 
                        if (!string.IsNullOrEmpty(splitRecord.NewBarcode))
                        {
                            var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                                .FirstAsync(x => x.Barcode == splitRecord.NewBarcode && x.StockId == status.StockId);

                            if (newStock != null && newStock.StockQuantity > 0)
                            {
                                returnBarcodes.Add(splitRecord.NewBarcode);
                                _logger.LogInformation($"添加拆包新条码: {splitRecord.NewBarcode}, æ•°é‡: {newStock.StockQuantity}");
                            }
                        }
                    }
                }

                _logger.LogInformation($"回库条码收集完成 - å…± {returnBarcodes.Count} ä¸ªæ¡ç : {string.Join(", ", returnBarcodes)}");

                return returnBarcodes.ToList();
            }
            catch (Exception ex)
            {
                _logger.LogError($"收集回库条码失败 - Error: {ex.Message}");
                return returnBarcodes.ToList();
            }
        }
        #endregion

        #region å›žåº“操作核心方法

        /// <summary>
        /// æ‰§è¡Œå›žåº“操作 - å¢žå¼ºç‰ˆæœ¬
        /// </summary>
        private async Task ExecuteReturnOperations(string orderNo, string palletCode, Dt_StockInfo stockInfo,
            Dt_Task task, PalletStatusAnalysis statusAnalysis)
        {
            _logger.LogInformation($"开始执行回库操作 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");

            //  å¤„理未分拣的锁定记录
            if (statusAnalysis.HasRemainingLocks)
            {
                _logger.LogInformation($"处理 {statusAnalysis.RemainingLocks.Count} æ¡æœªåˆ†æ‹£é”å®šè®°å½•");
                await HandleRemainingLocksReturn(statusAnalysis.RemainingLocks);
            }

            //处理托盘上的库存货物
            if (statusAnalysis.HasPalletStockGoods)
            {
                _logger.LogInformation($"处理 {statusAnalysis.PalletStockGoods.Count} ä¸ªåº“存货物");
                await HandlePalletStockGoodsReturn(statusAnalysis.PalletStockGoods, stockInfo.Id);
            }

            //处理拆包记录
            if (statusAnalysis.HasSplitRecords)
            {
                _logger.LogInformation($"处理 {statusAnalysis.SplitRecords.Count} æ¡æ‹†åŒ…记录");
                await HandleSplitRecordsReturn(statusAnalysis.SplitRecords, stockInfo.Id);
            }

            _logger.LogInformation($"回库操作完成 - æ€»å›žåº“数量: {statusAnalysis.TotalReturnQty}");
        }  

        /// <summary>
        /// å¤„理未分拣的锁定记录回库
        /// </summary>
        private async Task HandleRemainingLocksReturn(List<Dt_OutStockLockInfo> remainingLocks)
        {
            foreach (var lockInfo in remainingLocks)
            {
                // è®¡ç®—回库数量（未拣选的部分）
                decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

                if (returnQty > 0)
                {
                    // æ¢å¤åº“存状态
                    var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                        .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

                    if (stockDetail != null)
                    {
                        stockDetail.StockQuantity += returnQty;
                        stockDetail.OutboundQuantity -= returnQty;

                        // ç¡®ä¿å‡ºåº“数量不会为负数
                        if (stockDetail.OutboundQuantity < 0)
                        {
                            stockDetail.OutboundQuantity = 0;
                        }

                        // å›žåº“后库存状态恢复为入库完成（可用状态）
                        stockDetail.Status = (int)StockStatusEmun.入库完成;
                        await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

                        _logger.LogInformation($"恢复库存 - æ¡ç : {stockDetail.Barcode}, æ•°é‡: {returnQty}, æ–°åº“å­˜: {stockDetail.StockQuantity}");
                    }

                    // æ›´æ–°é”å®šè®°å½•çŠ¶æ€ä¸ºå·²å›žåº“
                    lockInfo.Status = (int)OutLockStockStatusEnum.已回库;
                    lockInfo.Operator = App.User.UserName;
                    await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

                    _logger.LogInformation($"更新锁定状态 - é”å®šID: {lockInfo.Id}, å›žåº“数量: {returnQty}");
                }
            }
        }

        /// <summary>
        /// å¤„理托盘上的库存货物回库
        /// </summary>
        private async Task HandlePalletStockGoodsReturn(List<Dt_StockInfoDetail> palletStockGoods, int stockId)
        {
            foreach (var stockDetail in palletStockGoods)
            {
                // åªå¤„理出库锁定状态的库存
                if (stockDetail.Status == (int)StockStatusEmun.出库锁定 && stockDetail.StockQuantity > 0)
                {
                    // æ¢å¤åº“存状态为可用状态
                    stockDetail.Status = (int)StockStatusEmun.入库完成;
                    await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

                    _logger.LogInformation($"恢复库存货物 - æ¡ç : {stockDetail.Barcode}, æ•°é‡: {stockDetail.StockQuantity}");
                }
            }
        }

        /// <summary>
        /// å¤„理拆包记录回库
        /// </summary>
        private async Task HandleSplitRecordsReturn(List<Dt_SplitPackageRecord> splitRecords, int stockId)
        {
            foreach (var splitRecord in splitRecords)
            {
                // å¤„理新条码
                var newLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.CurrentBarcode == splitRecord.NewBarcode &&
                               x.Status == (int)OutLockStockStatusEnum.出库中)
                    .FirstAsync();

                if (newLockInfo != null)
                {
                    await HandleSingleLockReturn(newLockInfo);
                }

                // å¤„理原条码
                var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.CurrentBarcode == splitRecord.OriginalBarcode &&
                               x.Status == (int)OutLockStockStatusEnum.出库中)
                    .FirstAsync();

                if (originalLockInfo != null)
                {
                    await HandleSingleLockReturn(originalLockInfo);
                }

                // æ›´æ–°æ‹†åŒ…记录状态为已回库
                splitRecord.Status = (int)SplitPackageStatusEnum.已回库;
                await _splitPackageService.Db.Updateable(splitRecord).ExecuteCommandAsync();
            }
        }

        /// <summary>
        /// å¤„理单个锁定记录回库
        /// </summary>
        private async Task HandleSingleLockReturn(Dt_OutStockLockInfo lockInfo)
        {
            decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

            if (returnQty > 0)
            {
                // æ¢å¤åº“å­˜
                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

                if (stockDetail != null)
                {
                    stockDetail.StockQuantity += returnQty;
                    stockDetail.OutboundQuantity -= returnQty;

                    if (stockDetail.OutboundQuantity < 0)
                    {
                        stockDetail.OutboundQuantity = 0;
                    }

                    stockDetail.Status = (int)StockStatusEmun.入库完成;
                    await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
                }

                // æ›´æ–°é”å®šçŠ¶æ€
                lockInfo.Status = (int)OutLockStockStatusEnum.已回库;
                lockInfo.Operator = App.User.UserName;
                await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

                _logger.LogInformation($"处理拆包相关锁定 - æ¡ç : {lockInfo.CurrentBarcode}, å›žåº“数量: {returnQty}");
            }
        }

        /// <summary>
        /// é‡Šæ”¾æ‰€æœ‰é”å®šä»¥ä¾¿é‡æ–°åˆ†é…
        /// </summary>
        private async Task ReleaseAllLocksForReallocation(string orderNo, string palletCode, PalletStatusAnalysis statusAnalysis)
        {
            // æ›´æ–°è®¢å•æ˜Žç»†çš„已分配数量
            if (statusAnalysis.HasRemainingLocks)
            {
                var orderDetailGroups = statusAnalysis.RemainingLocks.GroupBy(x => x.OrderDetailId);

                foreach (var group in orderDetailGroups)
                {
                    var orderDetailId = group.Key;
                    var returnedQty = group.Sum(x => x.AssignQuantity - x.PickedQty);

                    var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                        .FirstAsync(x => x.Id == orderDetailId);

                    if (orderDetail != null)
                    {
                        orderDetail.AllocatedQuantity -= returnedQty;
                        orderDetail.LockQuantity = orderDetail.AllocatedQuantity;

                        await UpdateBatchAllocateStatus(orderDetail);
                        await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();

                        _logger.LogInformation($"更新订单明细 - OrderDetailId: {orderDetailId}, å‡å°‘分配数量: {returnedQty}");
                    }
                }
            }
        }

        #endregion

        #region è¾…助方法

        /// <summary>
        /// å¤„理没有回库物品的情况
        /// </summary>
        private async Task<WebResponseContent> HandleNoReturnItems(string orderNo, string palletCode, Dt_Task originalTask, int stockId)
        {
            _logger.LogInformation($"托盘 {palletCode} æ²¡æœ‰éœ€è¦å›žåº“的物品");

            // æ£€æŸ¥æ˜¯å¦æ˜¯ç©ºæ‰˜ç›˜
            var statusAnalysis = await AnalyzePalletStatus(orderNo, palletCode, stockId);
            if (statusAnalysis.IsEmptyPallet)
            {
                try
                {
                    var locationtype = 0;
                    var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
                            .Where(x => x.PalletCode == palletCode)
                            .FirstAsync();

                    if (stockInfo == null)
                    {
                        var firstLocation = await _locationInfoService.Db.Queryable<Dt_LocationInfo>().FirstAsync(x => x.LocationCode == originalTask.SourceAddress);
                        locationtype = firstLocation?.LocationType ?? 1;
                    }
                    else
                    {
                        locationtype = stockInfo.LocationType;
                        _stockInfoService.DeleteData(stockInfo);
                    }

                    var targetAddress = originalTask.TargetAddress;

                    await CleanupZeroStockData(stockId);


                    var emptystockInfo = new Dt_StockInfo() { PalletType = PalletTypeEnum.Empty.ObjToInt(), StockStatus = StockStatusEmun.组盘暂存.ObjToInt(), PalletCode = palletCode, LocationType = locationtype };
                    emptystockInfo.Details = new List<Dt_StockInfoDetail>();
                    _stockInfoService.AddMaterielGroup(emptystockInfo);
                    //空托盘如何处理  è¿˜æœ‰ä¸€ä¸ªå‡ºåº“任务要处理。
                    originalTask.PalletType = PalletTypeEnum.Empty.ObjToInt();

                    await CreateReturnTaskAndHandleESS(orderNo, palletCode, originalTask, TaskTypeEnum.InEmpty, PalletTypeEnum.Empty.ObjToInt());

                }
                catch (Exception ex)
                {
                    _logger.LogError($" HandleNoReturnItems  å¤±è´¥: {ex.Message}");
                    return WebResponseContent.Instance.Error($" å›žåº“空托盘失败！");
                }
                return WebResponseContent.Instance.OK("空托盘回库任务创建成功");
            }
            else
            {
                return WebResponseContent.Instance.Error("托盘状态异常：有物品但无法计算回库数量");
            }
        }
        private async Task CleanupZeroStockData(int stockId)
        {
            try
            {
                // 1. åˆ é™¤åº“存数量为0的明细记录
                var deleteDetailCount = await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockId && x.StockQuantity == 0 && (x.Status == StockStatusEmun.出库完成.ObjToInt() || x.Status ==
                                          StockStatusEmun.入库完成.ObjToInt()))
                    .ExecuteCommandAsync();

                await _stockInfoService.Db.Deleteable<Dt_StockInfo>()
                   .Where(x => x.Id == stockId).ExecuteCommandAsync();

                _logger.LogInformation($"清理零库存明细记录 - StockId: {stockId}, åˆ é™¤è®°å½•æ•°: {deleteDetailCount}");



            }
            catch (Exception ex)
            {
                _logger.LogWarning($"清理零库存数据失败 - StockId: {stockId}, Error: {ex.Message}");
                // æ³¨æ„ï¼šæ¸…理失败不应该影响主流程
            }
        }
        /// <summary>
        /// æ›´æ–°è®¢å•çŠ¶æ€ï¼ˆå›žåº“后）
        /// </summary>
        private async Task UpdateOrderStatusForReturn(string orderNo)
        {
            // æ£€æŸ¥è®¢å•æ˜¯å¦æ‰€æœ‰æ‰˜ç›˜éƒ½å·²å®Œæˆæˆ–已回库
            var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderNo == orderNo)
                .ToListAsync();

            var activeLocks = allLocks.Where(x =>
                x.Status == (int)OutLockStockStatusEnum.出库中 ||
                x.Status == (int)OutLockStockStatusEnum.回库中).ToList();

            // å¦‚果没有活跃的锁定记录，更新订单状态
            if (!activeLocks.Any())
            {
                await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
                    .SetColumns(x => new Dt_OutboundOrder
                    {
                        OrderStatus = (int)OutOrderStatusEnum.出库完成,
                    })
                    .Where(x => x.OrderNo == orderNo)
                    .ExecuteCommandAsync();

                _logger.LogInformation($"更新订单状态为出库完成 - è®¢å•: {orderNo}");
            }
        }

        #endregion




        #region éªŒè¯æ–¹æ³•
        private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>> ValidatePickingRequest(
@@ -1510,7 +2149,7 @@
        /// <summary>
        /// æ£€æŸ¥å¹¶æ‰§è¡Œè‡ªåŠ¨æ‹†åŒ…（如果需要）
        /// </summary>
        private async Task<AutoSplitResult> CheckAndAutoSplitIfNeeded(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail, string palletCode)
        private async Task<List<SplitResult>> CheckAndAutoSplitIfNeeded(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail, string palletCode)
        {
            // æ£€æŸ¥æ˜¯å¦éœ€è¦è‡ªåŠ¨æ‹†åŒ…的条件：
            // 1. åº“存数量大于分配数量
@@ -1529,16 +2168,12 @@
            // æ‰§è¡Œè‡ªåŠ¨æ‹†åŒ…
            var splitResult = await ExecuteAutoSplitLogic(lockInfo, stockDetail, splitQuantity, palletCode);

            return new AutoSplitResult
            {
                NewBarcode = splitResult.NewBarcode,
                SplitQuantity = splitQuantity
            };
            return splitResult;
        }
        /// <summary>
        /// æ‰§è¡Œè‡ªåŠ¨æ‹†åŒ…逻辑
        /// </summary>
        private async Task<SplitResultDto> ExecuteAutoSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
        private async Task<List<SplitResult>> ExecuteAutoSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
            decimal splitQuantity, string palletCode)
        {
            _logger.LogInformation($"开始执行自动拆包逻辑 - åŽŸæ¡ç : {stockDetail.Barcode}, æ‹†åŒ…数量: {splitQuantity}");
@@ -1549,8 +2184,9 @@
            // é‡è¦ä¿®å¤ï¼šè®°å½•æ‹†åŒ…前的分配数量
            decimal originalAssignQtyBefore = lockInfo.AssignQuantity;
            decimal originalOrderQtyBefore = lockInfo.OrderQuantity;
            decimal remainQty = originalAssignQtyBefore; // è‡ªåŠ¨æ‹†åŒ…后原条码分配数量保持不变

            // 1. åˆ›å»ºæ–°åº“存明细（剩余部分）
            // åˆ›å»ºæ–°åº“存明细（剩余部分）
            var newStockDetail = new Dt_StockInfoDetail
            {
                StockId = stockDetail.StockId,
@@ -1566,20 +2202,18 @@
                BarcodeQty = stockDetail.BarcodeQty,
                BarcodeUnit = stockDetail.BarcodeUnit,
                BusinessType = stockDetail.BusinessType,
                InboundOrderRowNo = stockDetail.InboundOrderRowNo, 
                InboundOrderRowNo = stockDetail.InboundOrderRowNo,
            };
            await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
            _logger.LogInformation($"创建新库存明细 - æ¡ç : {newBarcode}, åº“存数量: {splitQuantity}");

            // 2. æ›´æ–°åŽŸåº“存明细
            // é‡è¦ä¿®å¤ï¼šåŽŸåº“存数量设置为分配数量（保持不变）
            decimal originalStockQtyBefore = stockDetail.StockQuantity;
            // æ³¨æ„ï¼šè‡ªåŠ¨æ‹†åŒ…时，原库存数量保持不变，因为我们要分拣的就是分配数量
            // æ›´æ–°åŽŸåº“存明细
            // é‡è¦ä¿®å¤ï¼šè‡ªåŠ¨æ‹†åŒ…时，原库存数量保持不变，因为我们要分拣的就是分配数量
            // stockDetail.StockQuantity ä¿æŒä¸å˜

            _logger.LogInformation($"原库存明细保持不变 - åº“存数量: {stockDetail.StockQuantity}");

            // 3. åˆ›å»ºæ–°é”å®šä¿¡æ¯ï¼ˆå‰©ä½™éƒ¨åˆ†ï¼‰
            // åˆ›å»ºæ–°é”å®šä¿¡æ¯ï¼ˆå‰©ä½™éƒ¨åˆ†ï¼‰
            var newLockInfo = new Dt_OutStockLockInfo
            {
                OrderNo = lockInfo.OrderNo,
@@ -1606,25 +2240,28 @@
                lineNo = lockInfo.lineNo,
                WarehouseCode = lockInfo.WarehouseCode,
                BarcodeQty = lockInfo.BarcodeQty,
                BarcodeUnit = lockInfo.BarcodeUnit, 
                BarcodeUnit = lockInfo.BarcodeUnit,
            };

            await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();
            _logger.LogInformation($"创建新锁定信息 - æ¡ç : {newBarcode}, åˆ†é…æ•°é‡: {splitQuantity}");

            // 4. é‡è¦ä¿®å¤ï¼šè‡ªåŠ¨æ‹†åŒ…时，原锁定信息的分配数量保持不变
            // è‡ªåŠ¨æ‹†åŒ…时，原锁定信息的分配数量保持不变
            // å› ä¸ºè‡ªåŠ¨æ‹†åŒ…后，原条码仍然需要被分拣，分配数量不应该改变
            _logger.LogInformation($"原锁定信息保持不变 - åˆ†é…æ•°é‡: {lockInfo.AssignQuantity}, è®¢å•æ•°é‡: {lockInfo.OrderQuantity}");

            // 5. è®°å½•æ‹†åŒ…历史
            await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode, true, originalStockQtyBefore);
            // è®°å½•æ‹†åŒ…历史
            await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode, true, stockDetail.StockQuantity);

            //  åˆ›å»ºæ‹†åŒ…结果列表
            var splitResults = CreateSplitResults(lockInfo, splitQuantity, remainQty, newBarcode, stockDetail.Barcode);

            _logger.LogInformation($"自动拆包逻辑执行完成");

            return new SplitResultDto { NewBarcode = newBarcode };
            return splitResults;
        }

   

        #endregion

        #region æ ¸å¿ƒé€»è¾‘方法
@@ -1635,7 +2272,7 @@
        {
            _logger.LogInformation($"开始执行分拣逻辑 - æ¡ç : {stockDetail.Barcode}, åˆ†é…æ•°é‡: {lockInfo.AssignQuantity}, å®žé™…拣选: {actualPickedQty}");

            // é‡è¦ä¿®å¤ï¼šå†æ¬¡éªŒè¯è®¢å•æ˜Žç»†çš„分配数量（防止并发操作）
            // å†æ¬¡éªŒè¯è®¢å•æ˜Žç»†çš„分配数量（防止并发操作）
            if (orderDetail.AllocatedQuantity < actualPickedQty)
            {
                throw new InvalidOperationException($"订单明细分配数量不足，需要拣选 {actualPickedQty}，可用分配数量 {orderDetail.AllocatedQuantity}");
@@ -1646,7 +2283,7 @@
                throw new InvalidOperationException($"订单明细锁定数量不足，需要拣选 {actualPickedQty}，可用锁定数量 {orderDetail.LockQuantity}");
            }

            // 1. æ›´æ–°é”å®šä¿¡æ¯
            // æ›´æ–°é”å®šä¿¡æ¯
            lockInfo.PickedQty += actualPickedQty;
            _logger.LogInformation($"更新锁定信息 - å·²æ‹£é€‰æ•°é‡ä»Ž {lockInfo.PickedQty - actualPickedQty} å¢žåŠ åˆ° {lockInfo.PickedQty}");

@@ -1665,7 +2302,7 @@
            lockInfo.Operator = App.User.UserName;
            await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

            // 2. æ›´æ–°åº“存信息
            // æ›´æ–°åº“存信息
            decimal originalStockQty = stockDetail.StockQuantity;
            decimal originalOutboundQty = stockDetail.OutboundQuantity;

@@ -1783,7 +2420,7 @@
                StockDetail = stockDetail
            };
        }
 

        #endregion

        #region æ•°æ®æ›´æ–°æ–¹æ³•
@@ -1791,16 +2428,25 @@
        private async Task UpdateBatchAndOrderData(Dt_OutboundBatch batch, Dt_OutboundOrderDetail orderDetail, decimal pickedQty, string orderNo)
        {
            _logger.LogInformation($"开始更新批次和订单数据 - æ‹£é€‰æ•°é‡: {pickedQty}");
            var latestOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().FirstAsync(x => x.Id == orderDetail.Id);

            if (latestOrderDetail == null)
                throw new InvalidOperationException("未找到订单明细");

            orderDetail = latestOrderDetail;
            // é‡è¦ä¿®å¤ï¼šéªŒè¯åˆ†é…æ•°é‡ä¸ä¼šå˜æˆè´Ÿæ•°
            if (orderDetail.AllocatedQuantity < pickedQty)
            {
                throw new InvalidOperationException($"更新订单数据时分配数量不足，需要减少 {pickedQty}，当前分配数量 {orderDetail.AllocatedQuantity}");
                decimal actualPickedQty = orderDetail.AllocatedQuantity;
                _logger.LogWarning($"分配数量不足，调整拣选数量 - åŽŸéœ€è¦: {pickedQty}, å®žé™…可用: {actualPickedQty}");
                pickedQty = actualPickedQty;
            }

            if (orderDetail.LockQuantity < pickedQty)
            {
                throw new InvalidOperationException($"更新订单数据时锁定数量不足，需要减少 {pickedQty}，当前锁定数量 {orderDetail.LockQuantity}");
                decimal actualPickedQty = orderDetail.LockQuantity;
                _logger.LogWarning($"锁定数量不足，调整拣选数量 - åŽŸéœ€è¦: {pickedQty}, å®žé™…可用: {actualPickedQty}");
                pickedQty = actualPickedQty;
            }

            // 1. æ›´æ–°æ‰¹æ¬¡å®Œæˆæ•°é‡
@@ -1816,7 +2462,7 @@
            }
            await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();

            // 2. æ›´æ–°è®¢å•æ˜Žç»†
            // æ›´æ–°è®¢å•æ˜Žç»†
            decimal originalOverOutQty = orderDetail.OverOutQuantity;
            decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
            decimal originalLockQty = orderDetail.LockQuantity;
@@ -1825,14 +2471,15 @@
            orderDetail.AllocatedQuantity -= pickedQty;
            // LockQuantity åŒæ­¥å‡å°‘
            orderDetail.LockQuantity = orderDetail.AllocatedQuantity;

            if (orderDetail.AllocatedQuantity < 0) orderDetail.AllocatedQuantity = 0;
            if (orderDetail.LockQuantity < 0) orderDetail.LockQuantity = 0;
            _logger.LogInformation($"更新订单明细 - å·²å‡ºåº“数量从 {originalOverOutQty} å¢žåŠ åˆ° {orderDetail.OverOutQuantity}");
            _logger.LogInformation($"更新订单明细 - å·²åˆ†é…æ•°é‡ä»Ž {originalAllocatedQty} å‡å°‘到 {orderDetail.AllocatedQuantity}");
            _logger.LogInformation($"更新订单明细 - é”å®šæ•°é‡ä»Ž {originalLockQty} å‡å°‘到 {orderDetail.LockQuantity}");

            await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();

            // 3. æ£€æŸ¥è®¢å•çŠ¶æ€
            // æ£€æŸ¥è®¢å•çŠ¶æ€
            await CheckAndUpdateOrderStatus(orderNo);

            _logger.LogInformation($"批次和订单数据更新完成");
@@ -1842,7 +2489,7 @@
        {
            _logger.LogInformation($"开始恢复批次和订单数据");

            // 1. æ¢å¤æ‰¹æ¬¡å®Œæˆæ•°é‡
            //   æ¢å¤æ‰¹æ¬¡å®Œæˆæ•°é‡
            var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
                .FirstAsync(x => x.BatchNo == revertResult.LockInfo.OutboundBatchNo);

@@ -1850,7 +2497,11 @@
            {
                decimal originalCompletedQty = batch.CompletedQuantity;
                batch.CompletedQuantity -= pickingRecord.PickQuantity;

                if (batch.CompletedQuantity < 0)
                {
                    batch.CompletedQuantity = 0;
                    _logger.LogWarning($"批次完成数量出现负数，重置为0");
                }
                _logger.LogInformation($"恢复批次完成数量 - ä»Ž {originalCompletedQty} å‡å°‘到 {batch.CompletedQuantity}");

                // é‡æ–°è®¡ç®—批次状态
@@ -1868,7 +2519,7 @@
                await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
            }

            // 2. æ¢å¤è®¢å•æ˜Žç»†
            //   æ¢å¤è®¢å•æ˜Žç»†
            var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                .FirstAsync(x => x.Id == pickingRecord.OrderDetailId);

@@ -1880,7 +2531,11 @@

                // é‡è¦ä¿®å¤ï¼šåªæ¢å¤ç›¸å…³æ•°é‡ï¼Œåˆ†é…æ•°é‡ä¿æŒä¸å˜
                orderDetail.OverOutQuantity -= pickingRecord.PickQuantity;
                // æ³¨æ„ï¼šAllocatedQuantity å’Œ LockQuantity åœ¨å–消分拣时不应该改变
                orderDetail.AllocatedQuantity += pickingRecord.PickQuantity;   
                orderDetail.LockQuantity += pickingRecord.PickQuantity;
                if (orderDetail.OverOutQuantity < 0) orderDetail.OverOutQuantity = 0;
                if (orderDetail.AllocatedQuantity < 0) orderDetail.AllocatedQuantity = 0;
                if (orderDetail.LockQuantity < 0) orderDetail.LockQuantity = 0;

                _logger.LogInformation($"恢复订单明细 - å·²å‡ºåº“数量从 {originalOverOutQty} å‡å°‘到 {orderDetail.OverOutQuantity}");
                _logger.LogInformation($"订单明细分配数量保持不变: {originalAllocatedQty}");
@@ -1992,6 +2647,99 @@
        }
        #endregion

        private async Task CreateReturnTaskAndHandleESS(string orderNo, string palletCode, Dt_Task originalTask, TaskTypeEnum taskTypeEnum, int palletType)
        {
            var firstLocation = await _locationInfoService.Db.Queryable<Dt_LocationInfo>()
                .FirstAsync(x => x.LocationCode == originalTask.SourceAddress);

            // åˆ†é…æ–°è´§ä½
            var newLocation = _locationInfoService.AssignLocation(firstLocation.LocationType);

            Dt_Task returnTask = new()
            {
                CurrentAddress = stations[originalTask.TargetAddress],
                Grade = 0,
                PalletCode = palletCode,
                NextAddress = "",
                // OrderNo = originalTask.OrderNo,
                OrderNo = orderNo,
                Roadway = newLocation.RoadwayNo,
                SourceAddress = stations[originalTask.TargetAddress],
                TargetAddress = newLocation.LocationCode,
                TaskStatus = TaskStatusEnum.New.ObjToInt(),
                TaskType = taskTypeEnum.ObjToInt(),
                PalletType = palletType,
                WarehouseId = originalTask.WarehouseId

            };
            // ä¿å­˜å›žåº“任务
            await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();
            var targetAddress = originalTask.TargetAddress;

            // åˆ é™¤åŽŸå§‹å‡ºåº“任务
            _taskRepository.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.自动完成);
            // await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();



            // ç»™ ESS å‘送流动信号和创建任务
            await SendESSCommands(palletCode, targetAddress, returnTask);
        }
        /// <summary>
        /// ç»™ESS下任务
        /// </summary>
        /// <param name="palletCode"></param>
        /// <param name="targetAddress"></param>
        /// <param name="returnTask"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        private async Task SendESSCommands(string palletCode, string targetAddress, Dt_Task returnTask)
        {
            try
            {
                // 1. å‘送流动信号
                var moveResult = await _eSSApiService.MoveContainerAsync(new WIDESEA_DTO.Basic.MoveContainerRequest
                {
                    slotCode = movestations[targetAddress],
                    containerCode = palletCode
                });

                //if (moveResult)
                //{
                // 2. åˆ›å»ºå›žåº“任务
                var essTask = new TaskModel()
                {
                    taskType = "putaway",
                    taskGroupCode = "",
                    groupPriority = 0,
                    tasks = new List<TasksType>{  new() {
                            taskCode = returnTask.TaskNum.ToString(),
                            taskPriority = 0,
                            taskDescribe = new TaskDescribeType
                            {
                                containerCode = palletCode,
                                containerType = "CT_KUBOT_STANDARD",
                                fromLocationCode = stations.GetValueOrDefault(targetAddress) ?? "",
                                toStationCode = "",
                                toLocationCode = returnTask.TargetAddress,
                                deadline = 0,
                                storageTag = ""
                            }
                        } }
                };

                var resultTask = await _eSSApiService.CreateTaskAsync(essTask);
                _logger.LogInformation($"ReturnRemaining åˆ›å»ºä»»åŠ¡æˆåŠŸ: {resultTask}");
                //}
            }
            catch (Exception ex)
            {
                _logger.LogError($"ReturnRemaining ESS命令发送失败: {ex.Message}");
                throw new Exception($"ESS系统通信失败: {ex.Message}");
            }
        }


        #region è¾…助方法

        private async Task<string> GenerateNewBarcode()
@@ -2013,7 +2761,7 @@
                SplitQty = splitQty,
                SplitTime = DateTime.Now,
                Status = (int)SplitPackageStatusEnum.已拆包,
                IsAutoSplit = isAutoSplit  ,
                IsAutoSplit = isAutoSplit,
                // SplitType = isAutoSplit ? "自动拆包" : "手动拆包"
                OriginalStockQuantity = originalStockQuantity ?? stockDetail.StockQuantity,
                //RemainingStockQuantity = stockDetail.StockQuantity - splitQty
@@ -2145,12 +2893,5 @@
        }

        #endregion
    }


    // æ”¯æŒç±»
    public class SplitResultDto
    {
        public string NewBarcode { get; set; }
    }
}