提交

pan

7 天以前 42cb7e13165395327f2f9de6c1def858a18424b2

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

@@ -261,7 +261,10 @@
                // éªŒè¯åˆ†æ‹£è¯·æ±‚
                var validationResult = await ValidatePickingRequest(orderNo, palletCode, barcode);
                if (!validationResult.IsValid)
                {
                    _unitOfWorkManage.RollbackTran();
                    return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
                }

                var (lockInfo, orderDetail, stockDetail, batch) = validationResult.Data;

@@ -371,12 +374,13 @@
        #region å–走空箱逻辑



        /// <summary>
        /// éªŒè¯ç©ºç®±å–走条件
        /// éªŒè¯ç©ºç®±å–走条件 
        /// </summary>
        private async Task<ValidationResult<List<Dt_OutStockLockInfo>>> ValidateEmptyPalletRemoval(string orderNo, string palletCode)
        {
            _logger.LogInformation($"开始验证空托盘取走 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");

            // èŽ·å–托盘的所有锁定记录
            var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
@@ -385,7 +389,33 @@
            if (!lockInfos.Any())
                return ValidationResult<List<Dt_OutStockLockInfo>>.Error("该托盘没有锁定记录");

            // æ£€æŸ¥æ˜¯å¦æœ‰æœªå®Œæˆçš„锁定记录
            // èŽ·å–库存信息
            var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
                .FirstAsync(x => x.PalletCode == palletCode);

            if (stockInfo == null)
            {
                _logger.LogWarning($"未找到托盘的库存信息，可能已被清理");
                // å¦‚果找不到库存信息，只检查锁定记录
            }
            else
            {
                // æ£€æŸ¥æ‰˜ç›˜ä¸Šæ˜¯å¦è¿˜æœ‰åº“存货物
                var remainingStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockInfo.Id &&
                               x.StockQuantity > 0)  // åªæ£€æŸ¥æ•°é‡å¤§äºŽ0的库存
                    .ToListAsync();

                if (remainingStock.Any())
                {
                    var remainingQty = remainingStock.Sum(x => x.StockQuantity);
                    var barcodes = string.Join(", ", remainingStock.Select(x => x.Barcode).Take(5)); // åªæ˜¾ç¤ºå‰5个
                    return ValidationResult<List<Dt_OutStockLockInfo>>.Error(
                        $"托盘上还有库存货物，数量{remainingQty}，条码: {barcodes}，不能取走空箱");
                }
            }

            // æ£€æŸ¥æ˜¯å¦æœ‰æœªå®Œæˆçš„锁定记录（状态为出库中或回库中）
            var unfinishedLocks = lockInfos.Where(x =>
                x.Status == (int)OutLockStockStatusEnum.出库中 ||
                x.Status == (int)OutLockStockStatusEnum.回库中).ToList();
@@ -398,35 +428,19 @@
                    $"托盘还有{unfinishedCount}条未完成记录，剩余数量{unfinishedQty}，不能取走空箱");
            }

            // æ£€æŸ¥æ‰˜ç›˜ä¸Šæ˜¯å¦è¿˜æœ‰åº“存货物
            var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
                .FirstAsync(x => x.PalletCode == palletCode);

            if (stockInfo != null)
            {
                var remainingStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockInfo.Id &&
                               x.Status == (int)StockStatusEmun.出库锁定 &&
                               x.StockQuantity > 0)
                    .ToListAsync();

                if (remainingStock.Any())
                {
                    var remainingQty = remainingStock.Sum(x => x.StockQuantity);
                    return ValidationResult<List<Dt_OutStockLockInfo>>.Error(
                        $"托盘上还有库存货物，数量{remainingQty}，不能取走空箱");
                }
            }

            // èŽ·å–已完成的锁定记录
            // èŽ·å–已完成的锁定记录（状态为拣选完成或已取走）
            var completedLocks = lockInfos.Where(x =>
                x.Status == (int)OutLockStockStatusEnum.拣选完成).ToList();
                x.Status == (int)OutLockStockStatusEnum.拣选完成 ||
                x.Status == (int)OutLockStockStatusEnum.已取走).ToList();

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

            _logger.LogInformation($"空托盘验证通过 - æ‰¾åˆ° {completedLocks.Count} æ¡å·²å®Œæˆè®°å½•");

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


        /// <summary>
        /// æ¸…理已完成的锁定记录
@@ -446,17 +460,64 @@
        }

        /// <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.出库完成)
            try
            {
                stockDetail.Status = (int)StockStatusEmun.已清理;
                await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
                // æŸ¥æ‰¾é”å®šçš„库存明细
                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

                if (stockDetail != null)
                {
                    // è®°å½•æ¸…理前的状态
                    decimal originalQty = stockDetail.StockQuantity;
                    int originalStatus = stockDetail.Status;

                    // å¦‚果库存数量大于0，需要先清零
                    if (stockDetail.StockQuantity > 0)
                    {
                        _logger.LogWarning($"取走空托盘时发现条码 {lockInfo.CurrentBarcode} è¿˜æœ‰åº“å­˜ {stockDetail.StockQuantity}，自动清零");
                        stockDetail.StockQuantity = 0;
                        stockDetail.OutboundQuantity = 0;
                    }

                    // æ ‡è®°ä¸ºå·²æ¸…理状态
                    stockDetail.Status = (int)StockStatusEmun.已清理;

                    await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

                    _logger.LogInformation($"清理库存明细 - æ¡ç : {stockDetail.Barcode}, åŽŸçŠ¶æ€: {originalStatus} -> å·²æ¸…理, åŽŸæ•°é‡: {originalQty} -> 0");
                }
                else
                {
                    _logger.LogWarning($"未找到条码对应的库存明细: {lockInfo.CurrentBarcode}");
                }

                // åŒæ—¶æ¸…理该托盘上的所有库存（避免遗漏）
                var allStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == lockInfo.StockId && x.StockQuantity > 0)
                    .ToListAsync();

                if (allStockDetails.Any())
                {
                    foreach (var stock in allStockDetails)
                    {
                        stock.StockQuantity = 0;
                        stock.OutboundQuantity = 0;
                        stock.Status = (int)StockStatusEmun.已清理;

                        await _stockInfoDetailService.Db.Updateable(stock).ExecuteCommandAsync();
                        _logger.LogWarning($"清理遗漏库存 - æ¡ç : {stock.Barcode}, æ•°é‡: {stock.StockQuantity} -> 0");
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"清理库存信息失败 - é”å®šID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, Error: {ex.Message}");
                // ä¸æŠ›å‡ºå¼‚常，继续处理其他记录
            }
        }

@@ -677,100 +738,193 @@
        }

        /// <summary>
        /// æ‰§è¡Œæ‰‹åŠ¨æ‹†åŒ…逻辑 - å¢žå¼ºåˆ†é…æ•°é‡æŽ§åˆ¶
        /// æ‰§è¡Œæ‰‹åŠ¨æ‹†åŒ…逻辑 - å®Œæ•´ç‰ˆæœ¬
        /// </summary>
        private async Task<List<SplitResult>> ExecuteManualSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
            decimal splitQuantity, string palletCode)
        {
            _logger.LogInformation($"开始执行手动拆包逻辑 - åŽŸæ¡ç : {stockDetail.Barcode}, æ‹†åŒ…数量: {splitQuantity}");

            // éªŒè¯æ‹†åŒ…数量
            if (lockInfo.AssignQuantity < splitQuantity)
            try
            {
                throw new InvalidOperationException($"拆包数量超过锁定信息分配数量，拆包数量: {splitQuantity}, åˆ†é…æ•°é‡: {lockInfo.AssignQuantity}");
                // éªŒè¯åº“存数量是否足够
                decimal availableStock = stockDetail.StockQuantity;
                if (availableStock < splitQuantity)
                {
                    throw new InvalidOperationException($"库存不足，当前库存: {availableStock}, éœ€è¦æ‹†åŒ…: {splitQuantity}");
                }

                // éªŒè¯æ‹†åŒ…数量不能等于或大于原锁定信息分配数量
                if (splitQuantity >= lockInfo.AssignQuantity)
                {
                    throw new InvalidOperationException($"拆包数量不能等于或大于原锁定信息分配数量，拆包数量: {splitQuantity}, åŽŸåˆ†é…æ•°é‡: {lockInfo.AssignQuantity}");
                }

                // è®¡ç®—剩余数量
                decimal remainQty = lockInfo.AssignQuantity - splitQuantity;

                // éªŒè¯å‰©ä½™æ•°é‡æ˜¯å¦åˆç†
                if (remainQty <= 0)
                {
                    throw new InvalidOperationException($"拆包后剩余数量必须大于0，当前剩余: {remainQty}");
                }

                _logger.LogInformation($"拆包计算 - åŽŸåˆ†é…æ•°é‡: {lockInfo.AssignQuantity}, æ‹†åŒ…数量: {splitQuantity}, å‰©ä½™æ•°é‡: {remainQty}");
                _logger.LogInformation($"原库存信息 - åº“存数量: {stockDetail.StockQuantity}, å‡ºåº“数量: {stockDetail.OutboundQuantity}");

                // ç”Ÿæˆæ–°æ¡ç 
                string newBarcode = await GenerateNewBarcode();
                _logger.LogInformation($"生成新条码: {newBarcode}");

                // è®°å½•æ‹†åŒ…前的关键数据
                decimal originalLockAssignQty = lockInfo.AssignQuantity;
                decimal originalLockOrderQty = lockInfo.OrderQuantity;
                decimal originalStockQty = stockDetail.StockQuantity;
                decimal originalOutboundQty = stockDetail.OutboundQuantity;

                // åˆ›å»ºæ–°åº“存明细
                var newStockDetail = new Dt_StockInfoDetail
                {
                    StockId = stockDetail.StockId,
                    MaterielCode = stockDetail.MaterielCode,
                    OrderNo = stockDetail.OrderNo,
                    BatchNo = stockDetail.BatchNo,
                    StockQuantity = splitQuantity,
                    OutboundQuantity = 0,
                    Barcode = newBarcode,
                    Status = (int)StockStatusEmun.出库锁定,
                    SupplyCode = stockDetail.SupplyCode,
                    Unit = stockDetail.Unit,
                    BarcodeQty = stockDetail.BarcodeQty,
                    BarcodeUnit = stockDetail.BarcodeUnit,
                    BusinessType = stockDetail.BusinessType,
                    InboundOrderRowNo = stockDetail.InboundOrderRowNo,
                };

                await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
                _logger.LogInformation($"创建新库存明细成功 - æ¡ç : {newBarcode}, åº“存数量: {splitQuantity}");

                // ä¿®æ­£ï¼šæ›´æ–°åŽŸåº“存明细 - ç¡®ä¿æ•°æ®ä¸€è‡´æ€§
                // åŽŸåº“存减少拆包数量，但出库数量保持不变（因为是手动拆包，不涉及实际出库）
                stockDetail.StockQuantity -= splitQuantity;

                // ç¡®ä¿ä¸ä¼šä¸ºè´Ÿæ•°
                if (stockDetail.StockQuantity < 0)
                {
                    _logger.LogWarning($"原库存数量出现负数，重置为0");
                    stockDetail.StockQuantity = 0;
                }

                // å‡ºåº“数量保持不变
                // stockDetail.OutboundQuantity = stockDetail.OutboundQuantity; // ä¿æŒä¸å˜

                await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
                _logger.LogInformation($"更新原库存明细 - æ¡ç : {stockDetail.Barcode}, " +
                                     $"库存数量: {originalStockQty} -> {stockDetail.StockQuantity}, " +
                                     $"出库数量: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");

                // åˆ›å»ºæ–°é”å®šä¿¡æ¯
                var newLockInfo = new Dt_OutStockLockInfo
                {
                    OrderNo = lockInfo.OrderNo,
                    OrderDetailId = lockInfo.OrderDetailId, // ç»‘定到同一个订单明细
                    OutboundBatchNo = lockInfo.OutboundBatchNo,
                    MaterielCode = lockInfo.MaterielCode,
                    MaterielName = lockInfo.MaterielName,
                    StockId = lockInfo.StockId,
                    OrderQuantity = splitQuantity,
                    AssignQuantity = splitQuantity,
                    PickedQty = 0,
                    LocationCode = lockInfo.LocationCode,
                    PalletCode = lockInfo.PalletCode,
                    TaskNum = lockInfo.TaskNum,
                    Status = (int)OutLockStockStatusEnum.出库中,
                    Unit = lockInfo.Unit,
                    SupplyCode = lockInfo.SupplyCode,
                    OrderType = lockInfo.OrderType,
                    CurrentBarcode = newBarcode,
                    IsSplitted = 1,
                    ParentLockId = lockInfo.Id,
                    Operator = App.User.UserName,
                    FactoryArea = lockInfo.FactoryArea,
                    lineNo = lockInfo.lineNo,
                    WarehouseCode = lockInfo.WarehouseCode,
                    BarcodeQty = lockInfo.BarcodeQty,
                    BarcodeUnit = lockInfo.BarcodeUnit,
                };

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

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

                await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
                _logger.LogInformation($"更新原锁定信息 - åˆ†é…æ•°é‡: {originalLockAssignQty} -> {lockInfo.AssignQuantity}, " +
                                     $"订单数量: {originalLockOrderQty} -> {lockInfo.OrderQuantity}");

                // é‡è¦ï¼šæ‰‹åŠ¨æ‹†åŒ…不改变订单明细的总分配数量
                // éªŒè¯è®¢å•æ˜Žç»†çš„总分配数量是否保持不变
                await ValidateOrderDetailAllocationAfterSplit(lockInfo.OrderDetailId, originalLockAssignQty);

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

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

                // éªŒè¯æ‹†åŒ…后数据一致性
                await ValidateDataConsistencyAfterSplit(lockInfo.OrderDetailId, originalLockAssignQty, originalLockOrderQty);

                _logger.LogInformation($"手动拆包逻辑执行完成 - åŽŸæ¡ç : {stockDetail.Barcode}, æ–°æ¡ç : {newBarcode}, æ‹†åŒ…数量: {splitQuantity}");

                return splitResults;
            }

            // ç”Ÿæˆæ–°æ¡ç 
            string newBarcode = await GenerateNewBarcode();

            // è®¡ç®—剩余数量
            decimal remainQty = lockInfo.AssignQuantity - splitQuantity;

            // åˆ›å»ºæ–°åº“存明细
            var newStockDetail = new Dt_StockInfoDetail
            catch (Exception ex)
            {
                StockId = stockDetail.StockId,
                MaterielCode = stockDetail.MaterielCode,
                OrderNo = stockDetail.OrderNo,
                BatchNo = stockDetail.BatchNo,
                StockQuantity = splitQuantity,
                OutboundQuantity = 0,
                Barcode = newBarcode,
                Status = (int)StockStatusEmun.出库锁定,
                SupplyCode = stockDetail.SupplyCode,
                Unit = stockDetail.Unit,
                BarcodeQty = stockDetail.BarcodeQty,
                BarcodeUnit = stockDetail.BarcodeUnit,
                BusinessType = stockDetail.BusinessType,
                InboundOrderRowNo = stockDetail.InboundOrderRowNo,
            };
            await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();

            // æ›´æ–°åŽŸåº“存明细
            stockDetail.StockQuantity -= splitQuantity;
            if (stockDetail.StockQuantity < 0) stockDetail.StockQuantity = 0;
            await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

            // åˆ›å»ºæ–°é”å®šä¿¡æ¯
            var newLockInfo = new Dt_OutStockLockInfo
                _logger.LogError($"手动拆包逻辑执行失败 - åŽŸæ¡ç : {stockDetail.Barcode}, æ‹†åŒ…数量: {splitQuantity}, Error: {ex.Message}");
                throw;
            }
        }
        /// <summary>
        /// éªŒè¯æ‹†åŒ…后订单明细的分配数量是否保持不变
        /// </summary>
        private async Task ValidateOrderDetailAllocationAfterSplit(long orderDetailId, decimal originalTotalAssignQty)
        {
            try
            {
                OrderNo = lockInfo.OrderNo,
                OrderDetailId = lockInfo.OrderDetailId, // ç»‘定到同一个订单明细
                OutboundBatchNo = lockInfo.OutboundBatchNo,
                MaterielCode = lockInfo.MaterielCode,
                MaterielName = lockInfo.MaterielName,
                StockId = lockInfo.StockId,
                OrderQuantity = splitQuantity,
                AssignQuantity = splitQuantity,
                PickedQty = 0,
                LocationCode = lockInfo.LocationCode,
                PalletCode = lockInfo.PalletCode,
                TaskNum = lockInfo.TaskNum,
                Status = (int)OutLockStockStatusEnum.出库中,
                Unit = lockInfo.Unit,
                SupplyCode = lockInfo.SupplyCode,
                OrderType = lockInfo.OrderType,
                CurrentBarcode = newBarcode,
                IsSplitted = 1,
                ParentLockId = lockInfo.Id,
                Operator = App.User.UserName,
                FactoryArea = lockInfo.FactoryArea,
                lineNo = lockInfo.lineNo,
                WarehouseCode = lockInfo.WarehouseCode,
                BarcodeQty = lockInfo.BarcodeQty,
                BarcodeUnit = lockInfo.BarcodeUnit,
            };
                // èŽ·å–订单明细的所有锁定信息的总分配数量
                var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderDetailId == orderDetailId)
                    .ToListAsync();

            await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();
                decimal totalLockAssignQty = allLocks.Sum(x => x.AssignQuantity);

            // æ›´æ–°åŽŸé”å®šä¿¡æ¯
            lockInfo.AssignQuantity = remainQty;
            lockInfo.OrderQuantity = remainQty;
            await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
                _logger.LogInformation($"拆包后分配数量验证 - è®¢å•æ˜Žç»†ID: {orderDetailId}");
                _logger.LogInformation($"原始总分配数量: {originalTotalAssignQty}, å½“前总分配数量: {totalLockAssignQty}");

            // é‡è¦ï¼šæ‰‹åŠ¨æ‹†åŒ…不改变订单明细的总分配数量
            // å› ä¸ºåˆ†é…æ•°é‡åªæ˜¯ä»Žä¸€ä¸ªé”å®šä¿¡æ¯è½¬ç§»åˆ°å¦ä¸€ä¸ªé”å®šä¿¡æ¯
            _logger.LogInformation($"手动拆包 - è®¢å•æ˜Žç»†æ€»åˆ†é…æ•°é‡ä¿æŒä¸å˜");
                // æ‰‹åŠ¨æ‹†åŒ…后总分配数量应该保持不变
                if (Math.Abs(originalTotalAssignQty - totalLockAssignQty) > 0.01m)
                {
                    _logger.LogWarning($"拆包后总分配数量发生变化 - æœŸæœ›: {originalTotalAssignQty}, å®žé™…: {totalLockAssignQty}");

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

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

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

            return splitResults;
                    // å¦‚果变化很小，可能是精度问题，记录但不抛出异常
                    if (Math.Abs(originalTotalAssignQty - totalLockAssignQty) > 1.0m)
                    {
                        throw new InvalidOperationException($"拆包后总分配数量异常变化，期望: {originalTotalAssignQty}, å®žé™…: {totalLockAssignQty}");
                    }
                }
                else
                {
                    _logger.LogInformation($"拆包后分配数量验证通过 - æ€»åˆ†é…æ•°é‡ä¿æŒä¸å˜");
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"验证拆包后分配数量失败 - OrderDetailId: {orderDetailId}, Error: {ex.Message}");
                throw;
            }
        }
        /// <summary>
        /// éªŒè¯æ‹†åŒ…后数据一致性
@@ -870,6 +1024,45 @@
        {
            _logger.LogInformation($"开始执行取消拆包逻辑 - åŽŸæ¡ç : {splitRecord.OriginalBarcode}, æ–°æ¡ç : {splitRecord.NewBarcode}, æ‹†åŒ…数量: {splitRecord.SplitQty}");

            try
            {
                // æ ¹æ®æ‹†åŒ…类型调用不同的处理方法
                if (splitRecord.IsAutoSplit)
                {
                    await HandleAutoSplitCancel(splitRecord, originalLockInfo, newLockInfo, newStockDetail);
                }
                else
                {
                    await HandleManualSplitCancel(splitRecord, originalLockInfo, newLockInfo, newStockDetail);
                }

                // éªŒè¯å–消拆包后数据一致性
                await ValidateDataConsistencyAfterCancelSplit(originalLockInfo.OrderDetailId,
                    originalLockInfo.AssignQuantity, originalLockInfo.OrderQuantity,
                    splitRecord.IsAutoSplit, splitRecord.SplitQty);

                // æ£€æŸ¥å¹¶æ›´æ–°æ‰¹æ¬¡å’Œè®¢å•çŠ¶æ€
                await CheckAndUpdateBatchStatus(originalLockInfo.BatchNo);
                await CheckAndUpdateOrderStatus(originalLockInfo.OrderNo);

                _logger.LogInformation($"取消拆包逻辑执行完成");
            }
            catch (Exception ex)
            {
                _logger.LogError($"取消拆包逻辑执行失败: {ex.Message}");
                throw;
            }
        }

        /// <summary>
        /// å¤„理自动拆包取消
        /// </summary>
        private async Task HandleAutoSplitCancel(Dt_SplitPackageRecord splitRecord,
            Dt_OutStockLockInfo originalLockInfo, Dt_OutStockLockInfo newLockInfo,
            Dt_StockInfoDetail newStockDetail)
        {
            _logger.LogInformation($"处理自动拆包取消 - åŽŸæ¡ç : {splitRecord.OriginalBarcode}, æ–°æ¡ç : {splitRecord.NewBarcode}");

            // èŽ·å–订单明细
            var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                .FirstAsync(x => x.Id == originalLockInfo.OrderDetailId);
@@ -877,124 +1070,113 @@
            if (orderDetail == null)
                throw new InvalidOperationException("未找到订单明细");

            // è®°å½•å–消拆包前的关键数据
            decimal originalOrderDetailAllocatedQty = orderDetail.AllocatedQuantity;
            decimal originalOrderDetailLockQty = orderDetail.LockQuantity;
            // 1. æ¢å¤è®¢å•æ˜Žç»†çš„分配数量（自动拆包会增加分配数量）
            decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
            decimal originalLockQty = orderDetail.LockQuantity;

            _logger.LogInformation($"取消拆包前数据 - è®¢å•æ˜Žç»†åˆ†é…æ•°é‡: {originalOrderDetailAllocatedQty}, é”å®šæ•°é‡: {originalOrderDetailLockQty}");
            orderDetail.AllocatedQuantity -= splitRecord.SplitQty;
            orderDetail.LockQuantity -= splitRecord.SplitQty;

            // æ¢å¤åŽŸé”å®šä¿¡æ¯
            decimal originalAssignQtyBefore = originalLockInfo.AssignQuantity;
            decimal originalOrderQtyBefore = originalLockInfo.OrderQuantity;
            // è¾¹ç•Œæ£€æŸ¥
            if (orderDetail.AllocatedQuantity < 0) orderDetail.AllocatedQuantity = 0;
            if (orderDetail.LockQuantity < 0) orderDetail.LockQuantity = 0;

            // æ ¹æ®æ‹†åŒ…类型决定如何恢复
            if (splitRecord.IsAutoSplit)
            {
                // è‡ªåŠ¨æ‹†åŒ…：原锁定信息保持不变，只需要删除新锁定信息
                _logger.LogInformation($"取消自动拆包 - åŽŸé”å®šä¿¡æ¯ä¿æŒä¸å˜");
            }
            else
            {
                // æ‰‹åŠ¨æ‹†åŒ…：恢复原锁定信息的分配数量
                originalLockInfo.AssignQuantity += splitRecord.SplitQty;
                originalLockInfo.OrderQuantity += splitRecord.SplitQty;
            await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
            _logger.LogInformation($"自动拆包取消恢复订单明细 - åˆ†é…æ•°é‡: {originalAllocatedQty} -> {orderDetail.AllocatedQuantity}");

                _logger.LogInformation($"取消手动拆包 - æ¢å¤åŽŸé”å®šä¿¡æ¯åˆ†é…æ•°é‡ä»Ž {originalAssignQtyBefore} å¢žåŠ åˆ° {originalLockInfo.AssignQuantity}");
            }

            // å¦‚果原锁定信息的状态是拣选完成，需要重新设置为出库中
            if (originalLockInfo.Status == (int)OutLockStockStatusEnum.拣选完成)
            {
                originalLockInfo.Status = (int)OutLockStockStatusEnum.出库中;
                _logger.LogInformation($"原锁定信息状态从拣选完成恢复为出库中");
            }

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

            // æ¢å¤åŽŸåº“存明细
            // 2. æ¢å¤åŽŸåº“存（将拆包的数量加回原库存）
            var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                .FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == splitRecord.StockId);

            if (originalStock != null)
            {
                if (splitRecord.IsAutoSplit)
                decimal originalStockQty = originalStock.StockQuantity;
                originalStock.StockQuantity += splitRecord.SplitQty;

                // å¦‚果原库存状态是出库完成，恢复为出库锁定
                if (originalStock.Status == (int)StockStatusEmun.出库完成)
                {
                    // è‡ªåŠ¨æ‹†åŒ…：原库存明细保持不变
                    _logger.LogInformation($"取消自动拆包 - åŽŸåº“存明细保持不变");
                    originalStock.Status = (int)StockStatusEmun.出库锁定;
                }
                else
                {
                    // æ‰‹åŠ¨æ‹†åŒ…：恢复原库存数量
                    decimal originalStockQtyBefore = originalStock.StockQuantity;
                    originalStock.StockQuantity += splitRecord.SplitQty;

                    _logger.LogInformation($"取消手动拆包 - æ¢å¤åŽŸåº“存明细数量从 {originalStockQtyBefore} å¢žåŠ åˆ° {originalStock.StockQuantity}");

                    // å¦‚果原库存状态是出库完成，需要重新设置为出库锁定
                    if (originalStock.Status == (int)StockStatusEmun.出库完成)
                    {
                        originalStock.Status = (int)StockStatusEmun.出库锁定;
                        _logger.LogInformation($"原库存状态从出库完成恢复为出库锁定");
                    }

                    await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
                }
                await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
                _logger.LogInformation($"自动拆包取消恢复原库存 - æ¡ç : {originalStock.Barcode}, æ•°é‡: {originalStockQty} -> {originalStock.StockQuantity}");
            }

            // 3. åˆ é™¤æ–°é”å®šä¿¡æ¯å’Œåº“存明细
            await DeleteNewSplitRecords(newLockInfo, newStockDetail);
        }

        /// <summary>
        /// å¤„理手动拆包取消
        /// </summary>
        private async Task HandleManualSplitCancel(Dt_SplitPackageRecord splitRecord,
            Dt_OutStockLockInfo originalLockInfo, Dt_OutStockLockInfo newLockInfo,
            Dt_StockInfoDetail newStockDetail)
        {
            _logger.LogInformation($"处理手动拆包取消 - åŽŸæ¡ç : {splitRecord.OriginalBarcode}, æ–°æ¡ç : {splitRecord.NewBarcode}");

            // 1. æ¢å¤åŽŸé”å®šä¿¡æ¯çš„分配数量
            decimal originalAssignQty = originalLockInfo.AssignQuantity;
            decimal originalOrderQty = originalLockInfo.OrderQuantity;

            originalLockInfo.AssignQuantity += splitRecord.SplitQty;
            originalLockInfo.OrderQuantity += splitRecord.SplitQty;

            // æ¢å¤çŠ¶æ€
            if (originalLockInfo.Status == (int)OutLockStockStatusEnum.拣选完成)
            {
                originalLockInfo.Status = (int)OutLockStockStatusEnum.出库中;
            }

            await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();
            _logger.LogInformation($"手动拆包取消恢复原锁定信息 - åˆ†é…æ•°é‡: {originalAssignQty} -> {originalLockInfo.AssignQuantity}");

            // 2. æ¢å¤åŽŸåº“存明细
            var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                .FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == splitRecord.StockId);

            if (originalStock != null)
            {
                decimal originalStockQty = originalStock.StockQuantity;
                originalStock.StockQuantity += splitRecord.SplitQty;

                // æ¢å¤åº“存状态
                if (originalStock.Status == (int)StockStatusEmun.出库完成)
                {
                    originalStock.Status = (int)StockStatusEmun.出库锁定;
                }

                await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
                _logger.LogInformation($"手动拆包取消恢复原库存 - æ¡ç : {originalStock.Barcode}, æ•°é‡: {originalStockQty} -> {originalStock.StockQuantity}");
            }

            // 3. åˆ é™¤æ–°é”å®šä¿¡æ¯å’Œåº“存明细
            await DeleteNewSplitRecords(newLockInfo, newStockDetail);
        }

        /// <summary>
        /// åˆ é™¤æ–°æ‹†åŒ…记录相关的数据
        /// </summary>
        private async Task DeleteNewSplitRecords(Dt_OutStockLockInfo newLockInfo, Dt_StockInfoDetail newStockDetail)
        {
            // åˆ é™¤æ–°é”å®šä¿¡æ¯
            _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();

            // å¦‚果是自动拆包，需要减少订单明细的分配数量和锁定数量
            if (splitRecord.IsAutoSplit)
            if (newStockDetail != null)
            {
                decimal originalAllocatedBefore = orderDetail.AllocatedQuantity;
                decimal originalLockBefore = orderDetail.LockQuantity;

                orderDetail.AllocatedQuantity -= splitRecord.SplitQty;
                orderDetail.LockQuantity -= splitRecord.SplitQty;

                // è¾¹ç•Œæ£€æŸ¥ï¼šç¡®ä¿æ•°é‡ä¸ä¼šä¸ºè´Ÿæ•°
                if (orderDetail.AllocatedQuantity < 0)
                {
                    _logger.LogWarning($"分配数量出现负数，重置为0。原值: {orderDetail.AllocatedQuantity + splitRecord.SplitQty}, å‡å°‘: {splitRecord.SplitQty}");
                    orderDetail.AllocatedQuantity = 0;
                }
                if (orderDetail.LockQuantity < 0)
                {
                    _logger.LogWarning($"锁定数量出现负数，重置为0。原值: {orderDetail.LockQuantity + splitRecord.SplitQty}, å‡å°‘: {splitRecord.SplitQty}");
                    orderDetail.LockQuantity = 0;
                }

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

                _logger.LogInformation($"取消自动拆包减少订单明细数量 - åˆ†é…æ•°é‡ä»Ž {originalAllocatedBefore} å‡å°‘到 {orderDetail.AllocatedQuantity}");
                _logger.LogInformation($"取消自动拆包减少订单明细数量 - é”å®šæ•°é‡ä»Ž {originalLockBefore} å‡å°‘到 {orderDetail.LockQuantity}");
                _logger.LogInformation($"删除新库存明细 - æ¡ç : {newStockDetail.Barcode}, åº“存数量: {newStockDetail.StockQuantity}");
                await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
                    .Where(x => x.Barcode == newStockDetail.Barcode)
                    .ExecuteCommandAsync();
            }

            // æ ‡è®°æ‹†åŒ…记录为已撤销
            splitRecord.IsReverted = true;
            splitRecord.RevertTime = DateTime.Now;
            splitRecord.RevertOperator = App.User.UserName;
            await _splitPackageService.Db.Updateable(splitRecord).ExecuteCommandAsync();
            _logger.LogInformation($"标记拆包记录为已撤销");

            // éªŒè¯å–消拆包后数据一致性
            await ValidateDataConsistencyAfterCancelSplit(orderDetail.Id, originalOrderDetailAllocatedQty, originalOrderDetailLockQty, splitRecord.IsAutoSplit, splitRecord.SplitQty);

            // æ£€æŸ¥å¹¶æ›´æ–°æ‰¹æ¬¡å’Œè®¢å•çŠ¶æ€
            await CheckAndUpdateBatchStatus(originalLockInfo.BatchNo);
            await CheckAndUpdateOrderStatus(originalLockInfo.OrderNo);

            _logger.LogInformation($"取消拆包逻辑执行完成");
        }
        /// <summary>
        /// éªŒè¯å–消拆包后数据一致性 - æœ€æ–°ç‰ˆæœ¬
@@ -1686,41 +1868,218 @@
        /// <summary>
        /// ç»Ÿä¸€å›žåº“方法 - å¤„理托盘上所有剩余货物
        /// </summary>
        //public async Task<WebResponseContent> ExecutePalletReturn(string orderNo, string palletCode, string returnReason = "分批回库")
        //{
        //    try
        //    {
        //        int stockId = 0;
        //        Dt_StockInfo stockInfo = null;
        //        PalletStatusAnalysis statusAnalysis = null;
        //        _unitOfWorkManage.BeginTran();

        //        if (string.IsNullOrEmpty(orderNo) || string.IsNullOrEmpty(palletCode))
        //            return WebResponseContent.Instance.Error("订单号和托盘码不能为空");

        //        // èŽ·å–库存信息
        //        stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
        //            .FirstAsync(x => x.PalletCode == palletCode);
        //        if (stockInfo == null)
        //            return WebResponseContent.Instance.Error($"未找到托盘 {palletCode} å¯¹åº”的库存信息");

        //        stockId = stockInfo.Id;

        //        var beforeValidationResult = await ValidateReturnData(orderNo, palletCode, stockId, true);
        //        if (!beforeValidationResult)
        //        {
        //            _logger.LogWarning("回库前数据验证发现问题，但继续执行回库操作");
        //        }
        //        _logger.LogInformation($"步骤4完成: å›žåº“前数据验证{(beforeValidationResult ? "通过" : "发现问题")}");


        //        // åˆ†æžæ‰˜ç›˜çŠ¶æ€
        //        statusAnalysis = await AnalyzePalletStatusForReturn(orderNo, palletCode, stockInfo.Id);
        //        _logger.LogInformation($"【步骤6】托盘状态分析完成");
        //        _logger.LogInformation($"  - æ˜¯å¦æœ‰å›žåº“物品: {statusAnalysis.HasItemsToReturn}");
        //        _logger.LogInformation($"  - æ˜¯å¦ç©ºæ‰˜ç›˜: {statusAnalysis.IsEmptyPallet}");
        //        _logger.LogInformation($"  - æ€»å›žåº“数量: {statusAnalysis.TotalReturnQty}");
        //        _logger.LogInformation($"  - æ¡ç æ•°é‡: {statusAnalysis.AllBarcodes.Count}");

        //        if (!statusAnalysis.HasItemsToReturn)
        //        {
        //            _logger.LogInformation($"【步骤7】无回库物品，处理空托盘");
        //            var result = await HandleEmptyPalletReturn(orderNo, palletCode, stockInfo);
        //            if (result.Status)
        //            {
        //                _unitOfWorkManage.CommitTran();
        //                _logger.LogInformation($"【空托盘回库成功】订单: {orderNo}, æ‰˜ç›˜: {palletCode}");
        //            }
        //            else
        //            {
        //                _unitOfWorkManage.RollbackTran();
        //                _logger.LogError($"【空托盘回库失败】原因: {result.Message}");
        //            }
        //            return result;
        //        }

        //        _logger.LogInformation($"开始回库操作 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}, å›žåº“数量: {statusAnalysis.TotalReturnQty}");

        //        try
        //        {
        //            // æ‰§è¡Œå›žåº“数据操作
        //            await ExecuteReturnDataOperations(statusAnalysis);
        //        }
        //        catch (Exception ex)
        //        {
        //            _logger.LogError($"回库数据操作失败: {ex.Message}");
        //            try
        //            {
        //                await ExecuteSimpleReturnDataOperations(statusAnalysis);
        //                _logger.LogInformation($"简化回库数据操作成功");
        //            }
        //            catch (Exception simpleEx)
        //            {
        //                _logger.LogError($"简化回库数据操作也失败 - {simpleEx.Message}");
        //                throw new InvalidOperationException($"回库数据操作失败，主方法: {ex.Message}, ç®€åŒ–方法: {simpleEx.Message}", ex);
        //            }
        //        }

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

        //        _unitOfWorkManage.CommitTran();

        //        _logger.LogInformation($"步骤10: å¼€å§‹å›žåº“后数据验证");
        //        var afterValidationResult = await ValidateReturnData(orderNo, palletCode, stockId, false);
        //        if (!afterValidationResult)
        //        {
        //            _logger.LogWarning("回库后数据验证发现问题，建议检查数据一致性");
        //        }
        //        _logger.LogInformation($"步骤10完成: å›žåº“后数据验证{(afterValidationResult ? "通过" : "发现问题")}");

        //        try
        //        {
        //            await CreateReturnTask(orderNo, palletCode, stockInfo);
        //            _logger.LogInformation($"步骤11成功: å›žåº“任务创建成功");
        //        }
        //        catch (Exception taskEx)
        //        {
        //            // ä»»åŠ¡åˆ›å»ºå¤±è´¥ä¸å½±å“å›žåº“数据操作的成功，只记录错误
        //            _logger.LogError($"步骤11警告: å›žåº“任务创建失败 - {taskEx.Message}");
        //            _logger.LogError($"回库数据操作已成功，但任务创建失败，可能需要手动处理");
        //        }

        //        _logger.LogInformation($"【回库成功】订单: {orderNo}, æ‰˜ç›˜: {palletCode}, å›žåº“数量: {statusAnalysis.TotalReturnQty}");

        //        return WebResponseContent.Instance.OK($"回库操作成功，共回库数量：{statusAnalysis.TotalReturnQty}", new
        //        {
        //            ReturnQuantity = statusAnalysis.TotalReturnQty,
        //            ReturnBarcodes = statusAnalysis.AllBarcodes,
        //            Reason = returnReason,
        //            PalletCode = palletCode,
        //            OrderNo = orderNo
        //        });
        //    }
        //    catch (Exception ex)
        //    {
        //        _unitOfWorkManage.RollbackTran();
        //        _logger.LogError($"【回库失败】订单: {orderNo}, æ‰˜ç›˜: {palletCode}, é”™è¯¯ç±»åž‹: {ex.GetType().Name}");
        //        _logger.LogError($"【错误信息】{ex.Message}");
        //        _logger.LogError($"【堆栈信息】{ex.StackTrace}");

        //        if (ex.InnerException != null)
        //        {
        //            _logger.LogError($"【内部错误】{ex.InnerException.Message}");
        //        }
        //        return WebResponseContent.Instance.Error($"回库操作失败: {ex.Message}");
        //    }
        //}

        /// <summary>
        /// ç»Ÿä¸€å›žåº“方法
        /// </summary>
        public async Task<WebResponseContent> ExecutePalletReturn(string orderNo, string palletCode, string returnReason = "分批回库")
        {
            try
            {
                _logger.LogInformation($"【增强回库开始】订单: {orderNo}, æ‰˜ç›˜: {palletCode}");

                _unitOfWorkManage.BeginTran();

                // 1. åŸºç¡€éªŒè¯
                if (string.IsNullOrEmpty(orderNo) || string.IsNullOrEmpty(palletCode))
                    return WebResponseContent.Instance.Error("订单号和托盘码不能为空");

                // èŽ·å–库存信息
                // 2. èŽ·å–库存信息
                var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
                    .FirstAsync(x => x.PalletCode == palletCode);

                if (stockInfo == null)
                    return WebResponseContent.Instance.Error($"未找到托盘 {palletCode} å¯¹åº”的库存信息");

                // åˆ†æžæ‰˜ç›˜çŠ¶æ€
                int stockId = stockInfo.Id;

                // 3. æ‰§è¡Œå›žåº“前数据验证
                var validationResult = await ValidateDataBeforeReturn(orderNo, palletCode, stockId);
                if (!validationResult.IsValid)
                {
                    _logger.LogWarning($"回库前数据验证失败: {validationResult.ErrorMessage}");
                    // å¯ä»¥æ ¹æ®å®žé™…情况决定是否继续
                }

                // 4. åˆ†æžæ‰˜ç›˜çŠ¶æ€
                var statusAnalysis = await AnalyzePalletStatusForReturn(orderNo, palletCode, stockInfo.Id);

                if (!statusAnalysis.HasItemsToReturn)
                    return await HandleEmptyPalletReturn(orderNo, palletCode, stockInfo);
                {
                    try
                    {
                        _logger.LogInformation($"【无回库物品】处理空托盘");
                        var result = await HandleEmptyPalletReturn(orderNo, palletCode, stockInfo);
                        _unitOfWorkManage.CommitTran();
                        return result;
                    }
                    catch (Exception ex)
                    {
                        _unitOfWorkManage.RollbackTran();
                        _logger.LogError($"空箱回库失败: {ex.Message}");
                        return WebResponseContent.Instance.Error($"空箱回库失败：{ex.Message}");
                    }
                }

                _logger.LogInformation($"开始回库操作 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}, å›žåº“数量: {statusAnalysis.TotalReturnQty}");
                _logger.LogInformation($"【开始回库】总回库数量: {statusAnalysis.TotalReturnQty}, æ¡ç æ•°: {statusAnalysis.AllBarcodes.Count}");

                // æ‰§è¡Œå›žåº“数据操作
                await ExecuteReturnDataOperations(statusAnalysis);
                // 5. æ‰§è¡Œå›žåº“操作
                try
                {
                    await ExecuteEnhancedReturnOperations(statusAnalysis);
                }
                catch (Exception ex)
                {
                    _logger.LogError($"主回库方法失败: {ex.Message}");
                    // å°è¯•ç®€åŒ–方法
                    await ExecuteSimpleReturnDataOperations(statusAnalysis);
                }

                // æ›´æ–°è®¢å•çŠ¶æ€
                // 6. æ›´æ–°è®¢å•çŠ¶æ€
                await UpdateOrderStatusAfterReturn(orderNo);

                _unitOfWorkManage.CommitTran();

                // åˆ›å»ºå›žåº“任务（AGV）
                await CreateReturnTask(orderNo, palletCode, stockInfo);
                // 7. åˆ›å»ºå›žåº“任务
                try
                {
                    await CreateReturnTask(orderNo, palletCode, stockInfo);
                }
                catch (Exception taskEx)
                {
                    _logger.LogError($"回库任务创建失败: {taskEx.Message}");
                    // ä»»åŠ¡åˆ›å»ºå¤±è´¥ä¸å½±å“æ•°æ®å›žåº“
                }
                _unitOfWorkManage.CommitTran();
                // 8. å›žåº“后验证
                await ValidateDataAfterReturn(orderNo, palletCode, stockId);

                return WebResponseContent.Instance.OK($"回库操作成功，共回库数量：{statusAnalysis.TotalReturnQty}", new
                return WebResponseContent.Instance.OK($"回库成功，回库数量：{statusAnalysis.TotalReturnQty}", new
                {
                    ReturnQuantity = statusAnalysis.TotalReturnQty,
                    ReturnBarcodes = statusAnalysis.AllBarcodes,
@@ -1732,13 +2091,306 @@
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                _logger.LogError($"回库操作失败 - OrderNo: {orderNo}, PalletCode: {palletCode}, Error: {ex.Message}");
                return WebResponseContent.Instance.Error($"回库操作失败: {ex.Message}");
                _logger.LogError($"回库失败: {ex.Message}");
                return WebResponseContent.Instance.Error($"回库失败：{ex.Message}");
            }
        }

        /// <summary>
        /// å¢žå¼ºçš„回库前数据验证
        /// </summary>
        private async Task<ValidationResult<bool>> ValidateDataBeforeReturn(string orderNo, string palletCode, int stockId)
        {
            var errors = new List<string>();

            try
            {
                // 1. éªŒè¯åº“存数据
                var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockId)
                    .ToListAsync();

                // æ£€æŸ¥åº“存数量是否为负数
                var negativeStocks = stockDetails.Where(x => x.StockQuantity < 0).ToList();
                if (negativeStocks.Any())
                {
                    errors.Add($"发现负数库存: {string.Join(", ", negativeStocks.Select(x => $"{x.Barcode}:{x.StockQuantity}"))}");
                }

                // 2. éªŒè¯é”å®šè®°å½•
                var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
                    .ToListAsync();

                // æ£€æŸ¥å·²æ‹£é€‰æ•°é‡æ˜¯å¦å¤§äºŽåˆ†é…æ•°é‡
                var invalidLocks = lockInfos.Where(x => x.PickedQty > x.AssignQuantity).ToList();
                if (invalidLocks.Any())
                {
                    errors.Add($"发现已拣选数量大于分配数量的锁定记录");
                }

                // 3. éªŒè¯æ‹†åŒ…记录
                var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
                    .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
                    .ToListAsync();

                // æ£€æŸ¥å¾ªçŽ¯æ‹†åŒ…
                var barcodeMap = new Dictionary<string, string>();
                foreach (var record in splitRecords.Where(x => !x.IsReverted))
                {
                    if (!barcodeMap.ContainsKey(record.OriginalBarcode))
                        barcodeMap[record.OriginalBarcode] = record.NewBarcode;
                }

                // æ£€æŸ¥å¾ªçŽ¯å¼•ç”¨
                foreach (var record in splitRecords)
                {
                    var current = record.OriginalBarcode;
                    var visited = new HashSet<string>();

                    while (barcodeMap.ContainsKey(current))
                    {
                        if (visited.Contains(current))
                        {
                            errors.Add($"发现循环拆包引用: {record.OriginalBarcode}");
                            break;
                        }
                        visited.Add(current);
                        current = barcodeMap[current];
                    }
                }

                if (errors.Any())
                {
                    return ValidationResult<bool>.Error($"回库前数据验证发现问题: {string.Join("; ", errors)}");
                }

                return ValidationResult<bool>.Success(true);
            }
            catch (Exception ex)
            {
                _logger.LogError($"数据验证失败: {ex.Message}");
                return ValidationResult<bool>.Error($"数据验证异常: {ex.Message}");
            }
        }

        /// <summary>
        /// æ‰§è¡Œå¢žå¼ºçš„回库操作
        /// </summary>
        private async Task ExecuteEnhancedReturnOperations(PalletStatusAnalysis statusAnalysis)
        {
            _logger.LogInformation($"执行增强回库操作 - è®¢å•: {statusAnalysis.OrderNo}, æ‰˜ç›˜: {statusAnalysis.PalletCode}");

            // å¤„理已分配的锁定记录
            if (statusAnalysis.HasRemainingLocks)
            {
                await HandleAllocatedLocksReturn(statusAnalysis.RemainingLocks);
            }

            // å¤„理未分配的锁定记录
            if (statusAnalysis.HasUnallocatedLocks)
            {
                await HandleUnallocatedLocksReturn(statusAnalysis.UnallocatedLocks);
            }

            // å¤„理未分配的库存货物
            if (statusAnalysis.HasPalletStockGoods)
            {
                await HandleUnallocatedStockReturn(statusAnalysis.PalletStockGoods);
            }

            // å¤„理拆包记录
            if (statusAnalysis.HasSplitRecords)
            {
                await HandleSplitRecordsReturn(statusAnalysis.SplitRecords, statusAnalysis.StockId);
            }
        }

        /// <summary>
        /// å›žåº“后数据验证
        /// </summary>
        private async Task ValidateDataAfterReturn(string orderNo, string palletCode, int stockId)
        {
            try
            {
                _logger.LogInformation($"开始回库后数据验证");

                // 1. éªŒè¯åº“存状态
                var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockId)
                    .ToListAsync();

                var stillOutboundLocked = stockDetails.Where(x =>
                    x.Status == (int)StockStatusEmun.出库锁定 && x.StockQuantity > 0).ToList();

                if (stillOutboundLocked.Any())
                {
                    _logger.LogWarning($"回库后仍有出库锁定状态的库存: {stillOutboundLocked.Count}个");
                }

                // 2. éªŒè¯é”å®šè®°å½•çŠ¶æ€
                var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
                    .ToListAsync();

                var notReturnedLocks = lockInfos.Where(x =>
                    x.Status != (int)OutLockStockStatusEnum.已回库 &&
                    x.Status != (int)OutLockStockStatusEnum.已取走).ToList();

                if (notReturnedLocks.Any())
                {
                    _logger.LogWarning($"回库后仍有未回库状态的锁定记录: {notReturnedLocks.Count}条");
                }

                // 3. æ•°æ®ä¸€è‡´æ€§éªŒè¯
                decimal totalStock = stockDetails.Sum(x => x.StockQuantity);
                _logger.LogInformation($"回库后库存总量: {totalStock}");

                _logger.LogInformation($"回库后数据验证完成");
            }
            catch (Exception ex)
            {
                _logger.LogError($"回库后验证失败: {ex.Message}");
            }
        }


        /// <summary>
        /// éªŒè¯å›žåº“前后数据一致性
        /// </summary>
        private async Task<bool> ValidateReturnData(string orderNo, string palletCode, int stockId, bool isBefore = true)
        {
            string phase = isBefore ? "回库前" : "回库后";
            try
            {

                _logger.LogInformation($"【{phase}数据验证】开始 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");

                // 1. æ£€æŸ¥åº“存明细
                var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockId)
                    .ToListAsync();

                decimal totalStockQty = stockDetails.Sum(x => x.StockQuantity);
                _logger.LogInformation($"{phase}库存总量: {totalStockQty}");

                // 2. æ£€æŸ¥é”å®šè®°å½•
                var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
                    .ToListAsync();

                // æ£€æŸ¥é”å®šè®°å½•çŠ¶æ€åˆ†å¸ƒ
                var statusGroups = lockInfos.GroupBy(x => x.Status)
                    .Select(g => new { Status = g.Key, Count = g.Count() })
                    .ToList();

                foreach (var group in statusGroups)
                {
                    _logger.LogInformation($"{phase}锁定状态 {GetLockStatusName(group.Status)}: {group.Count} æ¡");
                }

                // 3. åŸºæœ¬éªŒè¯
                bool isValid = true;

                // éªŒè¯1: å¦‚果锁定记录状态为"拣选完成"，对应库存应该为0
                var completedLocks = lockInfos.Where(x => x.Status == (int)OutLockStockStatusEnum.拣选完成).ToList();
                foreach (var lockInfo in completedLocks)
                {
                    if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
                    {
                        var stock = stockDetails.FirstOrDefault(x => x.Barcode == lockInfo.CurrentBarcode);
                        if (stock != null && stock.StockQuantity > 0)
                        {
                            _logger.LogWarning($"{phase}验证警告 - é”å®šID {lockInfo.Id} æ‹£é€‰å®Œæˆä½†åº“存不为0: {stock.StockQuantity}");
                        }
                    }
                }

                // éªŒè¯2: åº“存状态一致性
                foreach (var stock in stockDetails)
                {
                    if (stock.Status == (int)StockStatusEmun.出库锁定 && stock.StockQuantity == 0)
                    {
                        _logger.LogWarning($"{phase}验证警告 - æ¡ç  {stock.Barcode} çŠ¶æ€ä¸ºå‡ºåº“锁定但库存为0");
                    }
                }

                _logger.LogInformation($"【{phase}数据验证】完成 - çŠ¶æ€: {(isValid ? "通过" : "有警告")}");
                return isValid;
            }
            catch (Exception ex)
            {
                _logger.LogError($"{phase} æ•°æ®éªŒè¯å¤±è´¥: {ex.Message}");
                return false;
            }
        }

        private string GetLockStatusName(int status)
        {
            return status switch
            {
                1 => "出库中",
                2 => "拣选完成",
                3 => "已回库",
                4 => "已取走",
                _ => $"未知({status})"
            };
        }
        /// <summary>
        /// ç®€åŒ–回库数据操作（当主方法失败时使用）
        /// </summary>
        private async Task ExecuteSimpleReturnDataOperations(PalletStatusAnalysis statusAnalysis)
        {
            _logger.LogInformation($"【简化回库】开始执行简化回库操作");

            try
            {
                // èŽ·å–该托盘的所有条码
                var allStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == statusAnalysis.StockId && x.StockQuantity > 0)
                    .ToListAsync();

                _logger.LogInformation($"找到 {allStockDetails.Count} ä¸ªæœ‰åº“存的条码");

                foreach (var stockDetail in allStockDetails)
                {
                    // æ¢å¤æ‰€æœ‰åº“存状态为入库完成
                    if (stockDetail.Status == (int)StockStatusEmun.出库锁定)
                    {
                        stockDetail.Status = (int)StockStatusEmun.入库完成;

                        await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
                        _logger.LogInformation($"简化回库 - æ¡ç : {stockDetail.Barcode}, æ•°é‡: {stockDetail.StockQuantity}");
                    }
                }

                // æ›´æ–°æ‰€æœ‰é”å®šè®°å½•ä¸ºå·²å›žåº“
                var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderNo == statusAnalysis.OrderNo &&
                               x.PalletCode == statusAnalysis.PalletCode &&
                               (x.Status == (int)OutLockStockStatusEnum.出库中 ||
                                x.Status == (int)OutLockStockStatusEnum.拣选完成))
                    .ToListAsync();

                foreach (var lockInfo in allLocks)
                {
                    lockInfo.Status = (int)OutLockStockStatusEnum.已回库;
                    lockInfo.Operator = App.User.UserName;

                    await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
                    _logger.LogInformation($"简化回库 - é”å®šè®°å½•: {lockInfo.Id}");
                }

                _logger.LogInformation($"【简化回库】完成 - å¤„理 {allStockDetails.Count} ä¸ªæ¡ç , {allLocks.Count} æ¡é”å®šè®°å½•");
            }
            catch (Exception ex)
            {
                _logger.LogError($"简化回库失败: {ex.Message}");
                throw;
            }
        }
        /// <summary>
        /// æ‰§è¡Œå›žåº“数据操作
        /// ç¡®ä¿ä¸ä¼šå°†ç”Ÿæˆçš„条码数量错误绑定到锁定数量
        /// æ‰§è¡Œå›žåº“数据操作 - ç®€åŒ–版本
        /// </summary>
        private async Task ExecuteReturnDataOperations(PalletStatusAnalysis statusAnalysis)
        {
@@ -1746,28 +2398,142 @@

            try
            {
                // ä½¿ç”¨ HashSet é¿å…é‡å¤å¤„理条码
                var processedBarcodes = new HashSet<string>();
                decimal totalReturnedQty = 0;

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

                    foreach (var lockInfo in statusAnalysis.RemainingLocks)
                    {
                        if (string.IsNullOrEmpty(lockInfo.CurrentBarcode) || processedBarcodes.Contains(lockInfo.CurrentBarcode))
                        {
                            _logger.LogInformation($"跳过重复或空条码的锁定记录 - ID: {lockInfo.Id}");
                            continue;
                        }

                        // è®¡ç®—回库数量（未拣选的部分）
                        decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

                        if (returnQty > 0)
                        {
                            _logger.LogInformation($"处理锁定记录回库 - ID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, å›žåº“数量: {returnQty}");

                            // å¤„理库存
                            await ProcessStockForReturn(lockInfo.CurrentBarcode, statusAnalysis.StockId, returnQty);

                            // æ ‡è®°ä¸ºå·²å›žåº“
                            lockInfo.Status = (int)OutLockStockStatusEnum.已回库;
                            lockInfo.Operator = App.User.UserName;


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

                            // å‡å°‘订单明细的分配数量
                            if (lockInfo.OrderDetailId > 0)
                            {
                                var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().FirstAsync(x => x.Id == lockInfo.OrderDetailId);
                                await ReduceOrderDetailAllocation(orderDetail, returnQty);
                            }

                            processedBarcodes.Add(lockInfo.CurrentBarcode);
                            totalReturnedQty += returnQty;

                            _logger.LogInformation($"锁定记录回库完成 - ID: {lockInfo.Id}, å›žåº“数量: {returnQty}");
                        }
                        else
                        {
                            _logger.LogInformation($"锁定记录无需回库 - ID: {lockInfo.Id}, å·²æ‹£é€‰å®Œæˆ");
                        }
                    }
                }

                // 2. å¤„理未分配的锁定记录（如自动拆包产生的）
                if (statusAnalysis.HasUnallocatedLocks)
                {
                    _logger.LogInformation($"处理 {statusAnalysis.UnallocatedLocks.Count} æ¡æœªåˆ†é…é”å®šè®°å½•");
                    await HandleUnallocatedLocksReturn(statusAnalysis.UnallocatedLocks);
                }

                // 3. å¤„理未分配的库存货物
                // 2. å¤„理未分配的库存货物
                if (statusAnalysis.HasPalletStockGoods)
                {
                    _logger.LogInformation($"处理 {statusAnalysis.PalletStockGoods.Count} ä¸ªæœªåˆ†é…åº“存货物");
                    await HandleUnallocatedStockReturn(statusAnalysis.PalletStockGoods);

                    foreach (var stockDetail in statusAnalysis.PalletStockGoods)
                    {
                        if (string.IsNullOrEmpty(stockDetail.Barcode) || processedBarcodes.Contains(stockDetail.Barcode))
                        {
                            _logger.LogInformation($"跳过重复或空条码的库存 - åº“å­˜ID: {stockDetail.Id}");
                            continue;
                        }

                        if (stockDetail.StockQuantity > 0)
                        {
                            decimal returnQty = stockDetail.StockQuantity;
                            _logger.LogInformation($"处理未分配库存回库 - æ¡ç : {stockDetail.Barcode}, å›žåº“数量: {returnQty}");

                            // ç›´æŽ¥æ¢å¤åº“存状态
                            stockDetail.Status = (int)StockStatusEmun.入库完成;

                            await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

                            processedBarcodes.Add(stockDetail.Barcode);
                            totalReturnedQty += returnQty;

                            _logger.LogInformation($"未分配库存回库完成 - æ¡ç : {stockDetail.Barcode}, æ•°é‡: {returnQty}");
                        }
                    }
                }

                _logger.LogInformation($"回库数据操作完成 - æ€»å›žåº“数量: {statusAnalysis.TotalReturnQty}");
                // 3. å¤„理拆包记录相关的条码
                if (statusAnalysis.HasSplitRecords)
                {
                    _logger.LogInformation($"处理 {statusAnalysis.SplitRecords.Count} æ¡æ‹†åŒ…记录");

                    // æ”¶é›†æ‹†åŒ…相关的所有条码
                    var splitBarcodes = new List<string>();
                    foreach (var splitRecord in statusAnalysis.SplitRecords)
                    {
                        if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode))
                            splitBarcodes.Add(splitRecord.OriginalBarcode);
                        if (!string.IsNullOrEmpty(splitRecord.NewBarcode))
                            splitBarcodes.Add(splitRecord.NewBarcode);
                    }

                    // åŽ»é‡
                    splitBarcodes = splitBarcodes.Distinct().ToList();

                    foreach (var barcode in splitBarcodes)
                    {
                        if (processedBarcodes.Contains(barcode))
                        {
                            _logger.LogInformation($"拆包条码已处理: {barcode}");
                            continue;
                        }

                        // æŸ¥æ‰¾åº“å­˜
                        var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                            .FirstAsync(x => x.Barcode == barcode && x.StockId == statusAnalysis.StockId);

                        if (stockDetail != null && stockDetail.StockQuantity > 0)
                        {
                            decimal returnQty = stockDetail.StockQuantity;
                            _logger.LogInformation($"处理拆包相关库存回库 - æ¡ç : {barcode}, å›žåº“数量: {returnQty}");

                            // æ¢å¤åº“存状态
                            if (stockDetail.Status == (int)StockStatusEmun.出库锁定)
                            {
                                stockDetail.Status = (int)StockStatusEmun.入库完成;

                                await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

                                processedBarcodes.Add(barcode);
                                totalReturnedQty += returnQty;

                                _logger.LogInformation($"拆包库存回库完成 - æ¡ç : {barcode}, æ•°é‡: {returnQty}");
                            }
                        }
                    }
                }

                _logger.LogInformation($"回库数据操作完成 - æ€»å›žåº“数量: {totalReturnedQty}, å¤„理条码数: {processedBarcodes.Count}");
            }
            catch (Exception ex)
            {
@@ -1775,7 +2541,103 @@
                throw;
            }
        }
        // <summary>
        /// <summary>
        /// å¤„理库存回库 - ç®€åŒ–逻辑
        /// </summary>
        private async Task ProcessStockForReturn(string barcode, int stockId, decimal returnQty)
        {
            try
            {
                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .FirstAsync(x => x.Barcode == barcode && x.StockId == stockId);

                if (stockDetail == null)
                {
                    _logger.LogWarning($"未找到库存明细 - æ¡ç : {barcode}");
                    return;
                }

                // è®°å½•åŽŸå§‹å€¼
                decimal originalStockQty = stockDetail.StockQuantity;
                decimal originalOutboundQty = stockDetail.OutboundQuantity;
                int originalStatus = stockDetail.Status;

                // ç®€åŒ–处理：如果库存数量大于0，恢复为入库完成状态
                if (stockDetail.StockQuantity > 0)
                {
                    stockDetail.Status = (int)StockStatusEmun.入库完成;
                }

                // è°ƒæ•´å‡ºåº“数量（避免出现负数）
                if (stockDetail.OutboundQuantity > 0)
                {
                    stockDetail.OutboundQuantity = Math.Max(0, stockDetail.OutboundQuantity - returnQty);
                }
                await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

                _logger.LogInformation($"库存回库处理 - æ¡ç : {barcode}, çŠ¶æ€: {originalStatus} -> {stockDetail.Status}, " +
                                     $"库存: {originalStockQty} -> {stockDetail.StockQuantity}, " +
                                     $"出库: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
            }
            catch (Exception ex)
            {
                _logger.LogError($"处理库存回库失败 - æ¡ç : {barcode}, Error: {ex.Message}");
                throw;
            }
        }
        /// <summary>
        /// ä¸ºé”å®šè®°å½•å‡å°‘订单明细的分配数量
        /// </summary>
        private async Task ReduceOrderDetailAllocationForLock(long orderDetailId, decimal reduceQty)
        {
            if (orderDetailId <= 0)
                return;

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

            if (orderDetail == null)
                return;

            decimal originalAllocated = orderDetail.AllocatedQuantity;
            decimal originalLock = orderDetail.LockQuantity;

            // éªŒè¯å‡å°‘数量不会导致负数
            if (orderDetail.AllocatedQuantity < reduceQty)
            {
                _logger.LogWarning($"分配数量不足，调整减少数量 - åŽŸè®¡åˆ’减少: {reduceQty}, å®žé™…可用: {orderDetail.AllocatedQuantity}");
                reduceQty = orderDetail.AllocatedQuantity;
            }

            // å‡å°‘分配数量和锁定数量
            orderDetail.AllocatedQuantity -= reduceQty;
            orderDetail.LockQuantity -= reduceQty;

            // ç¡®ä¿æ•°é‡ä¸ä¼šä¸ºè´Ÿæ•°
            if (orderDetail.AllocatedQuantity < 0)
            {
                _logger.LogWarning($"分配数量出现负数，重置为0。原值: {orderDetail.AllocatedQuantity + reduceQty}, å‡å°‘: {reduceQty}");
                orderDetail.AllocatedQuantity = 0;
            }

            if (orderDetail.LockQuantity < 0)
            {
                _logger.LogWarning($"锁定数量出现负数，重置为0。原值: {orderDetail.LockQuantity + reduceQty}, å‡å°‘: {reduceQty}");
                orderDetail.LockQuantity = 0;
            }

            // æ›´æ–°æ‰¹æ¬¡åˆ†é…çŠ¶æ€
            await UpdateBatchAllocateStatus(orderDetail);

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

            _logger.LogInformation($"减少订单明细分配 - OrderDetailId: {orderDetail.Id}, " +
                                  $"分配数量: {originalAllocated} -> {orderDetail.AllocatedQuantity}, " +
                                  $"锁定数量: {originalLock} -> {orderDetail.LockQuantity}, " +
                                  $"减少数量: {reduceQty}");
        }

        /// <summary>
        /// å¤„理未分配的锁定记录回库
        /// ä¸éœ€è¦å‡å°‘订单明细的分配数量
        /// </summary>
@@ -1797,7 +2659,28 @@
                _logger.LogInformation($"处理未分配锁定记录回库 - é”å®šID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, å›žåº“数量: {returnQty}");

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

                if (stockDetail != null)
                {
                    // æ¢å¤åº“存数量
                    decimal originalStockQty = stockDetail.StockQuantity;
                    stockDetail.StockQuantity += returnQty;

                    // æ¢å¤åº“存状态
                    if (stockDetail.Status == (int)StockStatusEmun.出库完成)
                    {
                        stockDetail.Status = (int)StockStatusEmun.入库完成;
                    }
                    else if (stockDetail.Status == (int)StockStatusEmun.出库锁定)
                    {
                        stockDetail.Status = (int)StockStatusEmun.入库完成;
                    }

                    await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
                    _logger.LogInformation($"恢复库存 - æ¡ç : {stockDetail.Barcode}, åº“存数量: {originalStockQty} -> {stockDetail.StockQuantity}");
                }

                // æ›´æ–°é”å®šè®°å½•çŠ¶æ€ä¸ºå·²å›žåº“
                lockInfo.Status = (int)OutLockStockStatusEnum.已回库;
@@ -1806,13 +2689,11 @@
                await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

                _logger.LogInformation($"更新未分配锁定状态 - é”å®šID: {lockInfo.Id}, çŠ¶æ€: å‡ºåº“中 -> å·²å›žåº“");

                // é‡è¦ï¼šæœªåˆ†é…é”å®šè®°å½•ä¸éœ€è¦å‡å°‘订单明细的分配数量
                _logger.LogInformation($"未分配锁定记录回库完成 - é”å®šID: {lockInfo.Id}, å›žåº“数量: {returnQty}, æ— éœ€æ›´æ–°è®¢å•æ˜Žç»†");
            }

            _logger.LogInformation($"未分配锁定记录回库处理完成 - å…±å¤„理 {unallocatedLocks.Count} æ¡è®°å½•");
        }

        private async Task HandleAllocatedLocksReturn(List<Dt_OutStockLockInfo> allocatedLocks)
        {
            _logger.LogInformation($"开始处理已分配锁定记录回库 - å…± {allocatedLocks.Count} æ¡è®°å½•");
@@ -1953,7 +2834,7 @@
                try
                {
                    await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();
                 

                    _logger.LogInformation($"CreateReturnTaskAndHandleESS  åˆ†æ‰¹åˆ é™¤åŽ†å²ä»»åŠ¡: {orderNo} ï¼Œ {currentTask.TaskNum}");
                    // åˆ é™¤åŽŸå§‹å‡ºåº“任务
                    //_taskRepository.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.自动完成);
@@ -1971,7 +2852,7 @@
                {
                    _logger.LogInformation($"创建回库任务失败 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");
                    throw new Exception($"创建回库任务失败 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");
                  

                }
                // å‘送ESS命令
                await SendESSCommands(palletCode, targetAddress, returnTask);
@@ -2044,114 +2925,324 @@
        /// åˆ†æžæ‰˜ç›˜çŠ¶æ€ç”¨äºŽå›žåº“
        /// ç¡®ä¿ä¸ä¼šé”™è¯¯è¯†åˆ«éœ€è¦å›žåº“的物品
        /// </summary>

        /// <summary>
        /// åˆ†æžæ‰˜ç›˜çŠ¶æ€ç”¨äºŽå›žåº“ - å®Œæ•´ç‰ˆæœ¬
        /// ç¡®ä¿ä¸ä¼šé”™è¯¯è¯†åˆ«éœ€è¦å›žåº“的物品，避免重复计算
        /// </summary>
        private async Task<PalletStatusAnalysis> AnalyzePalletStatusForReturn(string orderNo, string palletCode, int stockId)
        {
            var result = new PalletStatusAnalysis
            {
                OrderNo = orderNo,
                PalletCode = palletCode,
                StockId = stockId
                StockId = stockId,
                AllBarcodes = new List<string>(),
                RemainingLocks = new List<Dt_OutStockLockInfo>(),
                UnallocatedLocks = new List<Dt_OutStockLockInfo>(),
                PalletStockGoods = new List<Dt_StockInfoDetail>(),
                SplitRecords = new List<Dt_SplitPackageRecord>()
            };

            // 1. åˆ†æžæœªåˆ†æ‹£çš„锁定记录（状态为出库中）
            var unfinishedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderNo == orderNo &&
                           x.PalletCode == palletCode &&
                           x.Status == (int)OutLockStockStatusEnum.出库中)
                .ToListAsync();
            _logger.LogInformation($"开始分析托盘状态用于回库 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}, StockId: {stockId}");

            if (unfinishedLocks.Any())
            try
            {
                //  åŒºåˆ†å·²åˆ†é…å’Œæœªåˆ†é…çš„锁定记录
                var allocatedLocks = unfinishedLocks.Where(x => x.IsUnallocated != 1 && x.OrderDetailId > 0).ToList();
                var unallocatedLocks = unfinishedLocks.Where(x => x.IsUnallocated == 1 || x.OrderDetailId == 0).ToList();

                // å¤„理已分配的锁定记录
                if (allocatedLocks.Any())
                {
                    result.HasRemainingLocks = true;
                    result.RemainingLocks = allocatedLocks;
                    result.RemainingLocksReturnQty = allocatedLocks.Sum(x => x.AssignQuantity - x.PickedQty);

                    foreach (var lockInfo in allocatedLocks)
                    {
                        if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
                        {
                            result.AllBarcodes.Add(lockInfo.CurrentBarcode);
                        }
                    }

                    _logger.LogInformation($"发现{allocatedLocks.Count}条已分配未分拣锁定记录，总数量: {result.RemainingLocksReturnQty}");
                }

                // å¤„理未分配的锁定记录（如自动拆包产生的）
                if (unallocatedLocks.Any())
                {
                    result.HasUnallocatedLocks = true;
                    result.UnallocatedLocks = unallocatedLocks;
                    result.UnallocatedLocksReturnQty = unallocatedLocks.Sum(x => x.AssignQuantity - x.PickedQty);

                    foreach (var lockInfo in unallocatedLocks)
                    {
                        if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
                        {
                            result.AllBarcodes.Add(lockInfo.CurrentBarcode);
                        }
                    }

                    _logger.LogInformation($"发现{unallocatedLocks.Count}条未分配锁定记录，总数量: {result.UnallocatedLocksReturnQty}");
                }
            }

            // 2. åˆ†æžæ‰˜ç›˜ä¸Šçš„剩余库存货物（状态为出库锁定但未分配）
            var palletStockGoods = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                .Where(x => x.StockId == stockId &&
                           x.Status == (int)StockStatusEmun.出库锁定 &&
                           x.StockQuantity > 0)
                .ToListAsync();

            // è¿‡æ»¤æŽ‰å·²ç»è¢«é”å®šè®°å½•å ç”¨çš„库存
            var lockedBarcodes = unfinishedLocks.Select(x => x.CurrentBarcode).ToList();
            var unlockedStockGoods = palletStockGoods.Where(x => !lockedBarcodes.Contains(x.Barcode)).ToList();

            // è¿›ä¸€æ­¥è¿‡æ»¤ï¼šæ£€æŸ¥è¿™äº›åº“存是否有关联的锁定记录
            var trulyUnallocatedGoods = new List<Dt_StockInfoDetail>();
            foreach (var stock in unlockedStockGoods)
            {
                var hasLock = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.CurrentBarcode == stock.Barcode &&
                // 1. åˆ†æžæ‰€æœ‰é”å®šè®°å½•ï¼ˆçŠ¶æ€ä¸ºå‡ºåº“中）
                var allUnfinishedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderNo == orderNo &&
                               x.PalletCode == palletCode &&
                               x.Status == (int)OutLockStockStatusEnum.出库中)
                    .AnyAsync();
                    .ToListAsync();

                if (!hasLock)
                if (allUnfinishedLocks.Any())
                {
                    trulyUnallocatedGoods.Add(stock);
                }
            }
                    _logger.LogInformation($"找到 {allUnfinishedLocks.Count} æ¡å‡ºåº“中状态的锁定记录");

            if (trulyUnallocatedGoods.Any())
                    // åŒºåˆ†å·²åˆ†é…å’Œæœªåˆ†é…çš„锁定记录
                    var allocatedLocks = allUnfinishedLocks
                        .Where(x => x.IsUnallocated != 1 && x.OrderDetailId > 0)
                        .ToList();

                    var unallocatedLocks = allUnfinishedLocks
                        .Where(x => x.IsUnallocated == 1 || x.OrderDetailId == 0)
                        .ToList();

                    // å¤„理已分配的锁定记录
                    if (allocatedLocks.Any())
                    {
                        result.HasRemainingLocks = true;
                        result.RemainingLocks = allocatedLocks;
                        result.RemainingLocksReturnQty = allocatedLocks.Sum(x => x.AssignQuantity - x.PickedQty);

                        foreach (var lockInfo in allocatedLocks)
                        {
                            if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
                            {
                                result.AllBarcodes.Add(lockInfo.CurrentBarcode);
                            }
                        }

                        _logger.LogInformation($"发现{allocatedLocks.Count}条已分配未分拣锁定记录，总数量: {result.RemainingLocksReturnQty}");
                    }

                    // å¤„理未分配的锁定记录（如自动拆包产生的）
                    if (unallocatedLocks.Any())
                    {
                        result.HasUnallocatedLocks = true;
                        result.UnallocatedLocks = unallocatedLocks;
                        result.UnallocatedLocksReturnQty = unallocatedLocks.Sum(x => x.AssignQuantity - x.PickedQty);

                        foreach (var lockInfo in unallocatedLocks)
                        {
                            if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
                            {
                                result.AllBarcodes.Add(lockInfo.CurrentBarcode);
                            }
                        }

                        _logger.LogInformation($"发现{unallocatedLocks.Count}条未分配锁定记录，总数量: {result.UnallocatedLocksReturnQty}");
                    }
                }
                else
                {
                    _logger.LogInformation($"未找到出库中状态的锁定记录");
                }

                // 2. åˆ†æžæ‰˜ç›˜ä¸Šçš„剩余库存货物（状态为出库锁定但未分配）
                var allStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockId &&
                               x.Status == (int)StockStatusEmun.出库锁定 &&
                               x.StockQuantity > 0)
                    .ToListAsync();

                if (allStockDetails.Any())
                {
                    _logger.LogInformation($"找到 {allStockDetails.Count} ä¸ªå‡ºåº“锁定状态的库存货物");

                    // è¿‡æ»¤æŽ‰å·²ç»è¢«é”å®šè®°å½•å ç”¨çš„库存
                    var lockedBarcodes = allUnfinishedLocks.Select(x => x.CurrentBarcode).Where(b => !string.IsNullOrEmpty(b)).ToList();
                    var unlockedStockGoods = allStockDetails
                        .Where(x => !lockedBarcodes.Contains(x.Barcode))
                        .ToList();

                    _logger.LogInformation($"过滤后剩余 {unlockedStockGoods.Count} ä¸ªæœªè¢«é”å®šçš„库存货物");

                    // è¿›ä¸€æ­¥è¿‡æ»¤ï¼šæ£€æŸ¥è¿™äº›åº“存是否有关联的锁定记录（包括状态不是出库中的）
                    var trulyUnallocatedGoods = new List<Dt_StockInfoDetail>();
                    foreach (var stock in unlockedStockGoods)
                    {
                        var hasActiveLock = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                            .Where(x => x.CurrentBarcode == stock.Barcode &&
                                       (x.Status == (int)OutLockStockStatusEnum.出库中 ||
                                        x.Status == (int)OutLockStockStatusEnum.拣选完成))
                            .AnyAsync();

                        if (!hasActiveLock)
                        {
                            trulyUnallocatedGoods.Add(stock);
                        }
                        else
                        {
                            _logger.LogInformation($"条码 {stock.Barcode} æœ‰æ´»è·ƒçš„锁定记录，跳过作为未分配库存");
                        }
                    }

                    if (trulyUnallocatedGoods.Any())
                    {
                        result.HasPalletStockGoods = true;
                        result.PalletStockGoods = trulyUnallocatedGoods;
                        result.PalletStockReturnQty = trulyUnallocatedGoods.Sum(x => x.StockQuantity);

                        foreach (var stock in trulyUnallocatedGoods)
                        {
                            result.AllBarcodes.Add(stock.Barcode);
                        }

                        _logger.LogInformation($"发现{trulyUnallocatedGoods.Count}个真正未分配库存货物，总数量: {result.PalletStockReturnQty}");

                        // è®°å½•æ¯ä¸ªè´§ç‰©çš„详细信息
                        foreach (var stock in trulyUnallocatedGoods)
                        {
                            _logger.LogInformation($"未分配库存 - æ¡ç : {stock.Barcode}, ç‰©æ–™: {stock.MaterielCode}, æ•°é‡: {stock.StockQuantity}");
                        }
                    }
                }
                else
                {
                    _logger.LogInformation($"未找到出库锁定状态的库存货物");
                }

                // 3. åˆ†æžæ‹†åŒ…记录（状态不是已拣选和已回库的）
                var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
                    .Where(x => x.OrderNo == orderNo &&
                               x.PalletCode == palletCode &&
                               !x.IsReverted &&
                               x.Status != (int)SplitPackageStatusEnum.已拣选 &&
                               x.Status != (int)SplitPackageStatusEnum.已回库)
                    .ToListAsync();

                if (splitRecords.Any())
                {
                    result.HasSplitRecords = true;
                    result.SplitRecords = splitRecords;

                    // è®¡ç®—拆包记录相关的回库数量（避免重复计算）
                    var splitBarcodes = new HashSet<string>();
                    decimal splitReturnQty = 0;

                    foreach (var splitRecord in splitRecords)
                    {
                        // åŽŸæ¡ç 
                        if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode) && !splitBarcodes.Contains(splitRecord.OriginalBarcode))
                        {
                            var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                                .FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == stockId);

                            if (originalStock != null && originalStock.StockQuantity > 0)
                            {
                                splitReturnQty += originalStock.StockQuantity;

                                // æ·»åŠ åˆ°æ‰€æœ‰æ¡ç åˆ—表（如果没有重复）
                                if (!result.AllBarcodes.Contains(splitRecord.OriginalBarcode))
                                {
                                    result.AllBarcodes.Add(splitRecord.OriginalBarcode);
                                }

                                splitBarcodes.Add(splitRecord.OriginalBarcode);
                                _logger.LogInformation($"拆包记录 - åŽŸæ¡ç : {splitRecord.OriginalBarcode}, æ•°é‡: {originalStock.StockQuantity}");
                            }
                        }

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

                            if (newStock != null && newStock.StockQuantity > 0)
                            {
                                splitReturnQty += newStock.StockQuantity;

                                // æ·»åŠ åˆ°æ‰€æœ‰æ¡ç åˆ—表（如果没有重复）
                                if (!result.AllBarcodes.Contains(splitRecord.NewBarcode))
                                {
                                    result.AllBarcodes.Add(splitRecord.NewBarcode);
                                }

                                splitBarcodes.Add(splitRecord.NewBarcode);
                                _logger.LogInformation($"拆包记录 - æ–°æ¡ç : {splitRecord.NewBarcode}, æ•°é‡: {newStock.StockQuantity}");
                            }
                        }

                        // è®°å½•æ‹†åŒ…信息
                        _logger.LogInformation($"拆包记录 - ID: {splitRecord.Id}, åŽŸæ¡ç : {splitRecord.OriginalBarcode}, " +
                                             $"新条码: {splitRecord.NewBarcode}, æ‹†åŒ…数量: {splitRecord.SplitQty}, " +
                                             $"是否自动: {splitRecord.IsAutoSplit}, æ˜¯å¦æ’¤é”€: {splitRecord.IsReverted}");
                    }

                    result.SplitReturnQty = splitReturnQty;
                    _logger.LogInformation($"发现{splitRecords.Count}条拆包记录，关联 {splitBarcodes.Count} ä¸ªæ¡ç ï¼Œæ€»æ•°é‡: {splitReturnQty}");
                }
                else
                {
                    _logger.LogInformation($"未找到需要回库的拆包记录");
                }

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

                result.HasItemsToReturn = result.TotalReturnQty > 0;
                result.IsEmptyPallet = !result.HasItemsToReturn;

                // åŽ»é‡æ‰€æœ‰æ¡ç 
                result.AllBarcodes = result.AllBarcodes.Distinct().ToList();

                _logger.LogInformation($"托盘状态分析完成 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");
                _logger.LogInformation($"汇总信息:");
                _logger.LogInformation($"  - å·²åˆ†é…é”å®šè®°å½•: {result.RemainingLocks.Count} æ¡, æ•°é‡: {result.RemainingLocksReturnQty}");
                _logger.LogInformation($"  - æœªåˆ†é…é”å®šè®°å½•: {result.UnallocatedLocks.Count} æ¡, æ•°é‡: {result.UnallocatedLocksReturnQty}");
                _logger.LogInformation($"  - æœªåˆ†é…åº“存货物: {result.PalletStockGoods.Count} ä¸ª, æ•°é‡: {result.PalletStockReturnQty}");
                _logger.LogInformation($"  - æ‹†åŒ…记录: {result.SplitRecords.Count} æ¡, æ•°é‡: {result.SplitReturnQty}");
                _logger.LogInformation($"  - æ€»å›žåº“数量: {result.TotalReturnQty}");
                _logger.LogInformation($"  - æ˜¯å¦ç©ºæ‰˜ç›˜: {result.IsEmptyPallet}");
                _logger.LogInformation($"  - æ¶‰åŠæ¡ç : {string.Join(", ", result.AllBarcodes)}");

                // 5. é¢å¤–的数据验证
                await ValidateAnalysisResults(result, stockId);

                return result;
            }
            catch (Exception ex)
            {
                result.HasPalletStockGoods = true;
                result.PalletStockGoods = trulyUnallocatedGoods;
                result.PalletStockReturnQty = trulyUnallocatedGoods.Sum(x => x.StockQuantity);
                _logger.LogError($"托盘状态分析失败 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}, Error: {ex.Message}");
                throw;
            }
        }

                foreach (var stock in trulyUnallocatedGoods)
        /// <summary>
        /// éªŒè¯åˆ†æžç»“果，确保数据一致性
        /// </summary>
        private async Task ValidateAnalysisResults(PalletStatusAnalysis analysis, int stockId)
        {
            _logger.LogInformation($"开始验证分析结果 - è®¢å•: {analysis.OrderNo}, æ‰˜ç›˜: {analysis.PalletCode}");

            try
            {
                // 1. éªŒè¯é”å®šè®°å½•å’Œåº“存明细的匹配
                foreach (var lockInfo in analysis.RemainingLocks.Concat(analysis.UnallocatedLocks))
                {
                    result.AllBarcodes.Add(stock.Barcode);
                    if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
                    {
                        var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                            .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

                        if (stockDetail == null)
                        {
                            _logger.LogWarning($"锁定记录 {lockInfo.Id} çš„条码 {lockInfo.CurrentBarcode} åœ¨åº“存明细中不存在");
                        }
                        else if (stockDetail.StockQuantity <= 0)
                        {
                            _logger.LogWarning($"锁定记录 {lockInfo.Id} çš„条码 {lockInfo.CurrentBarcode} åº“存数量为0或负数");
                        }
                    }
                }

                _logger.LogInformation($"发现{trulyUnallocatedGoods.Count}个真正未分配库存货物，总数量: {result.PalletStockReturnQty}");
                // 2. éªŒè¯æ€»å›žåº“数量的合理性
                // èŽ·å–托盘上的总库存数量
                var totalStockOnPallet = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockId)
                    .SumAsync(x => x.StockQuantity);

                if (analysis.TotalReturnQty > totalStockOnPallet)
                {
                    _logger.LogWarning($"总回库数量 {analysis.TotalReturnQty} å¤§äºŽæ‰˜ç›˜æ€»åº“å­˜ {totalStockOnPallet}，可能存在计算错误");
                }

                // 3. éªŒè¯æ¡ç çš„唯一性
                var duplicateBarcodes = analysis.AllBarcodes
                    .GroupBy(x => x)
                    .Where(g => g.Count() > 1)
                    .Select(g => g.Key)
                    .ToList();

                if (duplicateBarcodes.Any())
                {
                    _logger.LogWarning($"发现重复的条码: {string.Join(", ", duplicateBarcodes)}");
                }

                _logger.LogInformation($"分析结果验证完成");
            }

            // 3. è®¡ç®—总回库数量
            result.TotalReturnQty = result.RemainingLocksReturnQty + result.UnallocatedLocksReturnQty + result.PalletStockReturnQty;
            result.HasItemsToReturn = result.TotalReturnQty > 0;
            result.IsEmptyPallet = !result.HasItemsToReturn;

            _logger.LogInformation($"托盘状态分析完成 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}, æ€»å›žåº“数量: {result.TotalReturnQty}");

            return result;
            catch (Exception ex)
            {
                _logger.LogError($"分析结果验证失败 - Error: {ex.Message}");
                // ä¸æŠ›å‡ºå¼‚常，只记录错误
            }
        }

        /// <summary>
        /// å¤„理未分拣的锁定记录回库
        /// ç¡®ä¿ä¸ä¼šé”™è¯¯ç»‘定条码数量到锁定数量
@@ -2408,44 +3499,73 @@
        }

        /// <summary>
        /// å–走空箱 - å…ˆæ‰§è¡Œå›žåº“再清理 - å¢žå¼ºç‰ˆæœ¬
        /// å–走空箱 - å…ˆæ‰§è¡Œå›žåº“再清理
        /// </summary>
        public async Task<WebResponseContent> RemoveEmptyPallet(string orderNo, string palletCode)
        {
            try
            {
                _logger.LogInformation($"【取走空箱开始】订单: {orderNo}, æ‰˜ç›˜: {palletCode}");

                _unitOfWorkManage.BeginTran();

                _logger.LogInformation($"开始取走空箱 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");
                // 1. å…ˆå°è¯•æ‰§è¡Œå›žåº“操作，确保所有物品都回库
                _logger.LogInformation($"步骤1: å…ˆæ‰§è¡Œå›žåº“操作");
                var returnResult = await ExecutePalletReturn(orderNo, palletCode, "取走空箱前回库");
                if (!returnResult.Status)
                {
                    // å›žåº“失败，可能是空托盘或者有其他问题
                    _logger.LogWarning($"回库操作失败: {returnResult.Message}");

                // 1. éªŒè¯ç©ºç®±å–走条件（必须全部完成拣选）
                    // ç»§ç»­éªŒè¯ç©ºç®±å–走条件
                }

                // 2. éªŒè¯ç©ºç®±å–走条件（必须全部完成拣选）
                _logger.LogInformation($"步骤2: éªŒè¯ç©ºç®±å–走条件");
                var validationResult = await ValidateEmptyPalletRemoval(orderNo, palletCode);
                if (!validationResult.IsValid)
                {
                    _unitOfWorkManage.RollbackTran();
                    _logger.LogError($"空箱验证失败: {validationResult.ErrorMessage}");
                    return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
                }

                var completedLocks = validationResult.Data;
                _logger.LogInformation($"验证通过，找到 {completedLocks.Count} æ¡å·²å®Œæˆè®°å½•");

                // 2. æ¸…理已完成的锁定记录（标记为已取走）
                await CleanupCompletedLocks(completedLocks);
                // 3. æ¸…理已完成的锁定记录（标记为已取走）
                _logger.LogInformation($"步骤3: æ¸…理锁定记录");
                foreach (var lockInfo in completedLocks)
                {
                    // åªå¤„理状态为拣选完成的记录（已取走的跳过）
                    if (lockInfo.Status == (int)OutLockStockStatusEnum.拣选完成)
                    {
                        // æ ‡è®°é”å®šè®°å½•ä¸ºå·²å–èµ°
                        lockInfo.Status = (int)OutLockStockStatusEnum.已取走;
                        lockInfo.Operator = App.User.UserName;
                        await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
                        _logger.LogInformation($"锁定记录标记为已取走 - ID: {lockInfo.Id}");
                    }
                }

                // 3. æ¸…理对应的库存记录状态
                // 4. æ¸…理对应的库存记录状态
                _logger.LogInformation($"步骤4: æ¸…理库存记录");
                foreach (var lockInfo in completedLocks)
                {
                    await CleanupStockInfo(lockInfo);
                }

                // 4. æ›´æ–°ç›¸å…³è®¢å•çŠ¶æ€
                // 5. æ›´æ–°ç›¸å…³è®¢å•çŠ¶æ€
                _logger.LogInformation($"步骤5: æ›´æ–°è®¢å•çŠ¶æ€");
                await UpdateOrderStatusAfterPalletRemoval(orderNo);

                // 5. è®°å½•æ“ä½œåŽ†å²
                // 6. è®°å½•æ“ä½œåŽ†å²
                _logger.LogInformation($"步骤6: è®°å½•æ“ä½œåŽ†å²");
                await RecordEmptyPalletRemoval(orderNo, palletCode, completedLocks);

                _unitOfWorkManage.CommitTran();

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

                return WebResponseContent.Instance.OK("取走空箱成功");
            }
@@ -2718,6 +3838,359 @@
            }
        }

        /// <summary>
        /// æ”¶é›†éœ€è¦å›žåº“的条码（避免重复）
        /// </summary>
        private async Task<HashSet<string>> CollectBarcodesForReturn(string orderNo, string palletCode, int stockId)
        {
            var barcodes = new HashSet<string>();

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

                // 1. ä»Žé”å®šè®°å½•æ”¶é›†
                var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderNo == orderNo &&
                               x.PalletCode == palletCode &&
                               (x.Status == (int)OutLockStockStatusEnum.出库中
                              // || x.Status == (int)OutLockStockStatusEnum.出库锁定)
                              ))
                    .ToListAsync();

                foreach (var lockInfo in lockInfos)
                {
                    if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
                    {
                        barcodes.Add(lockInfo.CurrentBarcode);
                        _logger.LogInformation($"从锁定记录添加条码: {lockInfo.CurrentBarcode}");
                    }
                }

                // 2. ä»Žåº“存明细收集（状态为出库锁定的）
                var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockId &&
                               x.Status == (int)StockStatusEmun.出库锁定 &&
                               x.StockQuantity > 0)
                    .ToListAsync();

                foreach (var stockDetail in stockDetails)
                {
                    if (!barcodes.Contains(stockDetail.Barcode) && !string.IsNullOrEmpty(stockDetail.Barcode))
                    {
                        barcodes.Add(stockDetail.Barcode);
                        _logger.LogInformation($"从库存明细添加条码: {stockDetail.Barcode}, æ•°é‡: {stockDetail.StockQuantity}");
                    }
                }

                // 3. ä»Žæ‹†åŒ…记录收集
                var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
                    .Where(x => x.OrderNo == orderNo &&
                               x.PalletCode == palletCode &&
                               !x.IsReverted &&
                               x.Status != (int)SplitPackageStatusEnum.已拣选)
                    .ToListAsync();

                foreach (var splitRecord in splitRecords)
                {
                    // æ·»åŠ åŽŸæ¡ç 
                    if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode) && !barcodes.Contains(splitRecord.OriginalBarcode))
                    {
                        barcodes.Add(splitRecord.OriginalBarcode);
                        _logger.LogInformation($"从拆包记录添加原条码: {splitRecord.OriginalBarcode}");
                    }

                    // æ·»åŠ æ–°æ¡ç 
                    if (!string.IsNullOrEmpty(splitRecord.NewBarcode) && !barcodes.Contains(splitRecord.NewBarcode))
                    {
                        barcodes.Add(splitRecord.NewBarcode);
                        _logger.LogInformation($"从拆包记录添加新条码: {splitRecord.NewBarcode}");
                    }
                }

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

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

        /// <summary>
        /// ç»Ÿä¸€å¤„理条码回库（避免重复处理）
        /// </summary>
        private async Task ProcessBarcodeReturn(string barcode, int stockId, decimal returnQty, HashSet<string> processedBarcodes)
        {
            if (returnQty <= 0)
                return;

            // æ£€æŸ¥æ˜¯å¦å·²å¤„理过
            if (processedBarcodes.Contains(barcode))
            {
                _logger.LogInformation($"跳过已处理的条码: {barcode}");
                return;
            }

            // èŽ·å–库存明细
            var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                .FirstAsync(x => x.Barcode == barcode && x.StockId == stockId);

            if (stockDetail == null)
            {
                _logger.LogWarning($"未找到条码对应的库存明细: {barcode}");
                return;
            }

            // è®°å½•åŽŸå§‹å€¼
            decimal originalStockQty = stockDetail.StockQuantity;
            decimal originalOutboundQty = stockDetail.OutboundQuantity;
            int originalStatus = stockDetail.Status;

            _logger.LogInformation($"处理条码回库 - {barcode}: åŽŸå§‹åº“å­˜={originalStockQty}, åŽŸå§‹å‡ºåº“={originalOutboundQty}, çŠ¶æ€={originalStatus}");

            // éªŒè¯æ•°æ®ä¸€è‡´æ€§
            if (originalOutboundQty < returnQty)
            {
                _logger.LogWarning($"出库数量小于回库数量，调整回库数量 - æ¡ç : {barcode}, å‡ºåº“数量: {originalOutboundQty}, å›žåº“数量: {returnQty}");
                returnQty = originalOutboundQty;
            }

            // æ›´æ–°åº“存：出库数量减少，库存数量增加
            stockDetail.OutboundQuantity -= returnQty;
            stockDetail.StockQuantity += returnQty;

            // ç¡®ä¿ä¸ä¼šå‡ºçŽ°è´Ÿæ•°
            if (stockDetail.OutboundQuantity < 0)
            {
                _logger.LogWarning($"出库数量出现负数，重置为0 - æ¡ç : {barcode}");
                stockDetail.OutboundQuantity = 0;
            }

            // æ›´æ–°çŠ¶æ€
            if (stockDetail.OutboundQuantity <= 0 && stockDetail.StockQuantity > 0)
            {
                stockDetail.Status = (int)StockStatusEmun.入库完成;
                _logger.LogInformation($"库存状态更新为入库完成 - æ¡ç : {barcode}");
            }
            else if (stockDetail.StockQuantity > 0)
            {
                stockDetail.Status = (int)StockStatusEmun.出库锁定;
                _logger.LogInformation($"库存状态保持为出库锁定 - æ¡ç : {barcode}");
            }

            await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

            // æ ‡è®°ä¸ºå·²å¤„理
            processedBarcodes.Add(barcode);

            _logger.LogInformation($"条码回库完成 - {barcode}: " +
                                  $"库存 {originalStockQty} -> {stockDetail.StockQuantity}, " +
                                  $"出库 {originalOutboundQty} -> {stockDetail.OutboundQuantity}, " +
                                  $"状态 {originalStatus} -> {stockDetail.Status}");
        }

        /// <summary>
        /// å¤„理拆包记录回库 - é¿å…é‡å¤
        /// </summary>
        private async Task HandleSplitRecordsReturn(List<Dt_SplitPackageRecord> splitRecords, int stockId, HashSet<string> processedBarcodes)
        {
            if (!splitRecords.Any())
                return;

            _logger.LogInformation($"开始处理拆包记录回库 - å…± {splitRecords.Count} æ¡è®°å½•");

            foreach (var splitRecord in splitRecords)
            {
                // åªå¤„理未撤销的拆包记录
                if (splitRecord.IsReverted)
                {
                    _logger.LogInformation($"跳过已撤销的拆包记录 - ID: {splitRecord.Id}");
                    continue;
                }

                // å¤„理新条码
                if (!string.IsNullOrEmpty(splitRecord.NewBarcode) && !processedBarcodes.Contains(splitRecord.NewBarcode))
                {
                    var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                        .FirstAsync(x => x.Barcode == splitRecord.NewBarcode && x.StockId == stockId);

                    if (newStock != null && newStock.StockQuantity > 0)
                    {
                        // æ‹†åŒ…的新条码回库数量应该是其库存数量
                        await ProcessBarcodeReturn(splitRecord.NewBarcode, stockId, newStock.StockQuantity, processedBarcodes);
                    }
                }

                // å¤„理原条码
                if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode) && !processedBarcodes.Contains(splitRecord.OriginalBarcode))
                {
                    var originalStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                        .FirstAsync(x => x.Barcode == splitRecord.OriginalBarcode && x.StockId == stockId);

                    if (originalStock != null && originalStock.StockQuantity > 0)
                    {
                        // åŽŸæ¡ç çš„回库数量应该是拆包后剩余的数量
                        await ProcessBarcodeReturn(splitRecord.OriginalBarcode, stockId, originalStock.StockQuantity, processedBarcodes);
                    }
                }

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

                _logger.LogInformation($"拆包记录状态更新为已回库 - è®°å½•ID: {splitRecord.Id}");
            }

            _logger.LogInformation($"拆包记录回库处理完成");
        }

        /// <summary>
        /// ç®€åŒ–版回库方法 - ç»•è¿‡å¤æ‚验证
        /// </summary>
        public async Task<WebResponseContent> SimplePalletReturn(string orderNo, string palletCode, string returnReason = "简化回库")
        {
            try
            {
                _logger.LogInformation($"【简化回库开始】订单: {orderNo}, æ‰˜ç›˜: {palletCode}");

                _unitOfWorkManage.BeginTran();

                // 1. èŽ·å–库存信息（跳过复杂验证）
                var stockInfo = await _stockInfoService.Db.Queryable<Dt_StockInfo>()
                    .FirstAsync(x => x.PalletCode == palletCode);

                if (stockInfo == null)
                {
                    _unitOfWorkManage.RollbackTran();
                    return WebResponseContent.Instance.Error($"未找到托盘 {palletCode} å¯¹åº”的库存信息");
                }

                // 2. ç›´æŽ¥æŸ¥æ‰¾éœ€è¦å›žåº“的条码（简化逻辑）
                var barcodesToReturn = await GetBarcodesForSimpleReturn(orderNo, palletCode, stockInfo.Id);

                if (!barcodesToReturn.Any())
                {                             
                    try
                    {
                        _logger.LogInformation($"【无回库物品】处理空托盘");
                        var result = await HandleEmptyPalletReturn(orderNo, palletCode, stockInfo);
                        _unitOfWorkManage.CommitTran();
                        return result;
                    }
                    catch (Exception ex)
                    {
                        _unitOfWorkManage.RollbackTran();
                        _logger.LogError($"空箱回库失败: {ex.Message}");
                        return WebResponseContent.Instance.Error($"空箱回库失败：{ex.Message}");
                    }
                }

                // 3. ç®€åŒ–处理每个条码
                foreach (var barcode in barcodesToReturn)
                {
                    await ProcessSimpleBarcodeReturn(barcode, stockInfo.Id);
                }

                // 4. æ›´æ–°è®¢å•çŠ¶æ€ï¼ˆç®€åŒ–）
                await UpdateOrderStatusAfterReturn(orderNo);


                // 5. åˆ›å»ºå›žåº“任务
                await CreateReturnTask(orderNo, palletCode, stockInfo);

                _unitOfWorkManage.CommitTran();
                return WebResponseContent.Instance.OK($"简化回库成功，处理 {barcodesToReturn.Count} ä¸ªæ¡ç ");
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                _logger.LogError($"简化回库失败: {ex.Message}");
                return WebResponseContent.Instance.Error($"回库失败: {ex.Message}");
            }
        }
        /// <summary>
        /// ç®€åŒ–获取回库条码
        /// </summary>
        private async Task<List<string>> GetBarcodesForSimpleReturn(string orderNo, string palletCode, int stockId)
        {
            var barcodes = new List<string>();

            try
            {
                // 1. ä»Žé”å®šè®°å½•èŽ·å–
                var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
                    .Select(x => x.CurrentBarcode)
                    .ToListAsync();

                barcodes.AddRange(lockInfos.Where(b => !string.IsNullOrEmpty(b)));

                // 2. ä»Žåº“存明细获取
                var stockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockId && x.StockQuantity > 0)
                    .Select(x => x.Barcode)
                    .ToListAsync();

                barcodes.AddRange(stockDetails.Where(b => !string.IsNullOrEmpty(b)));

                // åŽ»é‡
                return barcodes.Distinct().ToList();
            }
            catch (Exception ex)
            {
                _logger.LogError($"获取回库条码失败: {ex.Message}");
                return barcodes;
            }
        }

        /// <summary>
        /// ç®€åŒ–处理条码回库
        /// </summary>
        private async Task ProcessSimpleBarcodeReturn(string barcode, int stockId)
        {
            try
            {
                // 1. èŽ·å–库存明细
                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .FirstAsync(x => x.Barcode == barcode && x.StockId == stockId);

                if (stockDetail == null)
                {
                    _logger.LogWarning($"未找到条码对应的库存明细: {barcode}");
                    return;
                }

                // 2. å¦‚果是出库锁定状态，恢复为入库完成
                if (stockDetail.Status == (int)StockStatusEmun.出库锁定)
                {
                    stockDetail.Status = (int)StockStatusEmun.入库完成;
                    await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
                    _logger.LogInformation($"条码状态恢复 - {barcode}: å‡ºåº“锁定 -> å…¥åº“完成");
                }

                // 3. æ›´æ–°ç›¸å…³çš„锁定记录
                var lockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.CurrentBarcode == barcode &&
                               (x.Status == (int)OutLockStockStatusEnum.出库中 ||
                                x.Status == (int)OutLockStockStatusEnum.拣选完成))
                    .ToListAsync();

                foreach (var lockInfo in lockInfos)
                {
                    lockInfo.Status = (int)OutLockStockStatusEnum.已回库;
                    lockInfo.Operator = App.User.UserName;
                    await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
                    _logger.LogInformation($"锁定记录状态更新 - ID: {lockInfo.Id}: å·²å›žåº“");
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"处理条码回库失败 - æ¡ç : {barcode}, Error: {ex.Message}");
            }
        }
        #endregion

        #region è¾…助方法
@@ -2956,12 +4429,13 @@

            return splitResult;
        }

        /// <summary>
        /// æ‰§è¡Œè‡ªåŠ¨æ‹†åŒ…逻辑
        /// ç¡®ä¿è‡ªåŠ¨æ‹†åŒ…不会影响回库逻辑
        /// </summary>
        private async Task<List<SplitResult>> ExecuteAutoSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
     decimal splitQuantity, string palletCode)
            decimal splitQuantity, string palletCode)
        {
            _logger.LogInformation($"开始执行自动拆包逻辑 - åŽŸæ¡ç : {stockDetail.Barcode}, æ‹†åŒ…数量: {splitQuantity}");

@@ -3001,6 +4475,7 @@
                BusinessType = stockDetail.BusinessType,
                InboundOrderRowNo = stockDetail.InboundOrderRowNo,
            };

            await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
            _logger.LogInformation($"创建新库存明细 - æ¡ç : {newBarcode}, åº“存数量: {splitQuantity}");

@@ -3038,8 +4513,24 @@
            await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();
            _logger.LogInformation($"创建新锁定信息 - æ¡ç : {newBarcode}, åˆ†é…æ•°é‡: {splitQuantity}, æ ‡è®°ä¸ºæœªåˆ†é…");

            // è‡ªåŠ¨æ‹†åŒ…不改变订单明细的分配数量
            _logger.LogInformation($"自动拆包 - è®¢å•æ˜Žç»†åˆ†é…æ•°é‡ä¿æŒä¸å˜");
            // é‡è¦ï¼šè‡ªåŠ¨æ‹†åŒ…需要增加订单明细的分配数量和锁定数量
            var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                .FirstAsync(x => x.Id == lockInfo.OrderDetailId);

            if (orderDetail != null)
            {
                decimal originalAllocated = orderDetail.AllocatedQuantity;
                decimal originalLock = orderDetail.LockQuantity;

                orderDetail.AllocatedQuantity += splitQuantity;
                orderDetail.LockQuantity += splitQuantity;

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

                _logger.LogInformation($"自动拆包增加订单明细分配 - åˆ†é…æ•°é‡: {originalAllocated} -> {orderDetail.AllocatedQuantity}, " +
                                     $"锁定数量: {originalLock} -> {orderDetail.LockQuantity}");
            }

            // è®°å½•æ‹†åŒ…历史
            await RecordSplitHistory(lockInfo, stockDetail, splitQuantity, newBarcode, true, stockDetail.StockQuantity);
@@ -3513,7 +5004,7 @@
            _logger.LogInformation($"CreateReturnTaskAndHandleESS  åˆ†æ‰¹åˆ é™¤åŽ†å²ä»»åŠ¡: {orderNo} ï¼Œ {originalTask.TaskNum}");
            // åˆ é™¤åŽŸå§‹å‡ºåº“任务
            //_taskRepository.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.自动完成);
           var result= _task_HtyService.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.人工删除);
            var result = _task_HtyService.DeleteAndMoveIntoHty(originalTask, OperateTypeEnum.人工删除);
            await _taskRepository.Db.Deleteable(originalTask).ExecuteCommandAsync();

            if (!result)