Merge branch 'master' of http://115.159.85.185:8098/r/ZhongRui/ALDbanyunxia...

647556386

7 天以前 3fff7e8eb6fe78f3a512eff51bf16aee39cf9072

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

@@ -1,6 +1,5 @@
using Microsoft.Extensions.Logging;
using SqlSugar;
using SqlSugar.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -15,6 +14,7 @@
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Basic;
using WIDESEA_DTO.Outbound;
using WIDESEA_IAllocateService;
@@ -249,16 +249,19 @@

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


        /// <summary>
        /// åˆ†æ‰¹åˆ†æ‹£ç¡®è®¤
        /// åˆ†æ‰¹åˆ†æ‹£ç¡®è®¤ - ä¿®æ­£ç‰ˆï¼ˆåŒ…含拆包后验证）
        /// </summary>
        public async Task<WebResponseContent> ConfirmBatchPicking(string orderNo, string palletCode, string barcode)
        {
            try
            {
                _logger.LogInformation($"【分拣开始】订单: {orderNo}, æ‰˜ç›˜: {palletCode}, æ¡ç : {barcode}");

                _unitOfWorkManage.BeginTran();

                // éªŒè¯åˆ†æ‹£è¯·æ±‚
                // 1. éªŒè¯åˆ†æ‹£è¯·æ±‚
                var validationResult = await ValidatePickingRequest(orderNo, palletCode, barcode);
                if (!validationResult.IsValid)
                {
@@ -268,11 +271,26 @@

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

                // æ£€æŸ¥æ˜¯å¦éœ€è¦è‡ªåŠ¨æ‹†åŒ…
                _logger.LogInformation($"验证通过 - é”å®šID: {lockInfo.Id}, åˆ†é…æ•°é‡: {lockInfo.AssignQuantity}, å·²æ‹£é€‰: {lockInfo.PickedQty}");
                _logger.LogInformation($"库存信息 - æ¡ç : {stockDetail.Barcode}, åº“存数量: {stockDetail.StockQuantity}, å‡ºåº“数量: {stockDetail.OutboundQuantity}");


                decimal originalStockQtyBeforeSplit = stockDetail.StockQuantity;
                decimal originalOutboundQtyBeforeSplit = stockDetail.OutboundQuantity;

                // è®°å½•æ‹†åŒ…前的关键数据（用于后续验证）
                decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
                decimal originalLockQty = orderDetail.LockQuantity;
                decimal originalStockQty = stockDetail.StockQuantity;
                decimal originalOutboundQty = stockDetail.OutboundQuantity;

                // 2. æ£€æŸ¥æ˜¯å¦éœ€è¦è‡ªåŠ¨æ‹†åŒ…
                var autoSplitResult = await CheckAndAutoSplitIfNeeded(lockInfo, stockDetail, palletCode);
                if (autoSplitResult != null)
                {
                    // å¦‚果执行了自动拆包，重新获取最新的锁定信息和库存信息
                    _logger.LogInformation($"执行了自动拆包，重新获取数据");

                    // é‡æ–°èŽ·å–最新的锁定信息和库存信息
                    var refreshedValidation = await ValidatePickingRequest(orderNo, palletCode, barcode);
                    if (!refreshedValidation.IsValid)
                    {
@@ -281,40 +299,56 @@
                    }

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

                    // ã€é‡è¦ã€‘调用自动拆包后验证 
                    decimal splitQuantity =  autoSplitResult.FirstOrDefault()?.quantityTotal.ObjToDecimal()??0 ;
                    bool autoSplitValid = await ValidateAfterAutoSplit(lockInfo, orderDetail, stockDetail, splitQuantity,originalStockQtyBeforeSplit);

                    var actualPickedQty = lockInfo.AssignQuantity;
                    var pickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, actualPickedQty);
                    if (!autoSplitValid)
                    {
                        _unitOfWorkManage.RollbackTran();
                        return WebResponseContent.Instance.Error("自动拆包后数据验证失败，请检查系统日志");
                    }

                    // æ›´æ–°æ‰¹æ¬¡å’Œè®¢å•æ•°æ®
                    await UpdateBatchAndOrderData(batch, orderDetail, actualPickedQty, orderNo);

                    // è®°å½•æ‹£é€‰åŽ†å²
                    await RecordPickingHistory(pickingResult, orderNo, palletCode);

                    _unitOfWorkManage.CommitTran();

                    return WebResponseContent.Instance.OK("自动拆包并分拣成功", autoSplitResult);
                    _logger.LogInformation($"自动拆包验证通过，继续执行分拣");
                }

                // æ­£å¸¸åˆ†æ‹£æµç¨‹ï¼ˆä¸éœ€è¦è‡ªåŠ¨æ‹†åŒ…）
                var normalPickedQty = lockInfo.AssignQuantity;
                var normalPickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, normalPickedQty);
                // 3. è®¡ç®—实际拣选数量
                decimal actualPickedQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

                // æ›´æ–°æ‰¹æ¬¡å’Œè®¢å•æ•°æ®
                await UpdateBatchAndOrderData(batch, orderDetail, normalPickedQty, orderNo);
                if (actualPickedQty <= 0)
                {
                    _unitOfWorkManage.RollbackTran();
                    return WebResponseContent.Instance.Error("该条码已拣选完成，无需重复拣选");
                }

                // è®°å½•æ‹£é€‰åŽ†å²
                await RecordPickingHistory(normalPickingResult, orderNo, palletCode);
                _logger.LogInformation($"开始拣选 - æ•°é‡: {actualPickedQty}");

                // 4. æ‰§è¡Œåˆ†æ‹£é€»è¾‘
                var pickingResult = await ExecutePickingLogic(lockInfo, orderDetail, stockDetail, actualPickedQty);

                // 5. æ›´æ–°æ‰¹æ¬¡å’Œè®¢å•æ•°æ®
                await UpdateBatchAndOrderData(batch, orderDetail, actualPickedQty, orderNo);

                // 6. è®°å½•æ‹£é€‰åŽ†å²
                await RecordPickingHistory(pickingResult, orderNo, palletCode);

                // 7. æ‹£é€‰åŽéªŒè¯
                await ValidateAfterPicking(orderNo, palletCode, barcode, actualPickedQty);

                _unitOfWorkManage.CommitTran();

                return WebResponseContent.Instance.OK("分拣成功", new
                {
                    PickedQuantity = normalPickedQty,
                    PickedQuantity = actualPickedQty,
                    Barcode = barcode,
                    MaterialCode = lockInfo.MaterielCode,
                    AutoSplitted = false
                    AutoSplitted = autoSplitResult != null,
                    RemainingStock = stockDetail.StockQuantity,
                    CurrentOutbound = stockDetail.OutboundQuantity,
                    // å¦‚果是自动拆包，返回相关信息
                    UnallocatedCreated = autoSplitResult != null ? "是" : "否"
                });
            }
            catch (Exception ex)
@@ -324,6 +358,260 @@
                return WebResponseContent.Instance.Error($"分拣失败：{ex.Message}");
            }
        }


        /// <summary>
        /// è‡ªåŠ¨æ‹†åŒ…后验证数据一致性 - ä¿®æ­£ç‰ˆ
        /// é‡ç‚¹ä¿®æ­£ï¼šæ­£ç¡®çš„原库存期望值计算
        /// </summary>
        private async Task<bool> ValidateAfterAutoSplit(Dt_OutStockLockInfo lockInfo, Dt_OutboundOrderDetail orderDetail,
            Dt_StockInfoDetail originalStockDetail, decimal splitQuantity, decimal originalStockQtyBeforeSplit)
        {
            try
            {
                _logger.LogInformation($"开始自动拆包后验证 - åŽŸæ¡ç : {originalStockDetail.Barcode}, æ‹†åŒ…数量: {splitQuantity}");
                _logger.LogInformation($"拆包前原库存数量: {originalStockQtyBeforeSplit}, åˆ†é…æ•°é‡: {lockInfo.AssignQuantity}");

                bool allValid = true;
                List<string> validationErrors = new List<string>();

                // 1. é‡æ–°èŽ·å–最新的数据（拆包后的当前状态）
                var refreshedOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                    .FirstAsync(x => x.Id == orderDetail.Id);

                var refreshedLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .FirstAsync(x => x.Id == lockInfo.Id);

                var refreshedStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .FirstAsync(x => x.Id == originalStockDetail.Id);

                // 2. ã€æ ¸å¿ƒä¿®æ­£ã€‘验证原库存明细数据
                // é‡è¦ï¼šæ‹†åŒ…后原库存的期望值 = åˆ†é…æ•°é‡ (因为自动拆包时，原库存应只保留分配数量)
                decimal expectedOriginalStockQty = lockInfo.AssignQuantity; // åº”该是120，而不是用计算

                _logger.LogInformation($"库存验证基准:");
                _logger.LogInformation($"  æ‹†åŒ…前原库存: {originalStockQtyBeforeSplit}");
                _logger.LogInformation($"  åˆ†é…æ•°é‡: {lockInfo.AssignQuantity}");
                _logger.LogInformation($"  æ‹†åŒ…数量: {splitQuantity}");
                _logger.LogInformation($"  æœŸæœ›åŽŸåº“å­˜: {expectedOriginalStockQty}");
                _logger.LogInformation($"  å®žé™…原库存: {refreshedStockDetail.StockQuantity}");

                // å…è®¸å°‘量误差的验证
                if (Math.Abs(refreshedStockDetail.StockQuantity - expectedOriginalStockQty) > 0.01m)
                {
                    // é¢å¤–检查：如果原库存数量不合理，可能是数据问题
                    if (refreshedStockDetail.StockQuantity < 0)
                    {
                        string error = $"原库存数量异常（负数）！实际: {refreshedStockDetail.StockQuantity}";
                        validationErrors.Add(error);
                        allValid = false;
                        _logger.LogError(error);
                    }
                    else if (refreshedStockDetail.StockQuantity > originalStockQtyBeforeSplit)
                    {
                        string error = $"原库存数量异常（大于拆包前）！拆包前: {originalStockQtyBeforeSplit}, å½“前: {refreshedStockDetail.StockQuantity}";
                        validationErrors.Add(error);
                        allValid = false;
                        _logger.LogError(error);
                    }
                    else
                    {
                        // å¯èƒ½æ˜¯åˆç†çš„误差，记录警告但不标记为失败
                        _logger.LogWarning($"原库存数量与期望值有差异，期望: {expectedOriginalStockQty}, å®žé™…: {refreshedStockDetail.StockQuantity}");
                    }
                }

                // éªŒè¯åŽŸåº“存的出库数量是否保持不变
                if (Math.Abs(refreshedStockDetail.OutboundQuantity - originalStockDetail.OutboundQuantity) > 0.01m)
                {
                    string error = $"原库存出库数量不应变化！拆包前: {originalStockDetail.OutboundQuantity}, æ‹†åŒ…后: {refreshedStockDetail.OutboundQuantity}";
                    validationErrors.Add(error);
                    allValid = false;
                    _logger.LogError(error);
                }

                // 3. éªŒè¯æ–°åº“存明细（拆包产生的）
                // æŸ¥æ‰¾æ–°æ¡ç ï¼ˆé€šè¿‡æ‹†åŒ…记录）
                var splitRecords = await _splitPackageService.Db.Queryable<Dt_SplitPackageRecord>()
                    .Where(x => x.OutStockLockInfoId == lockInfo.Id &&
                               !x.IsReverted &&
                               x.IsAutoSplit == true)
                    .OrderByDescending(x => x.SplitTime)
                    .ToListAsync();

                if (splitRecords.Any())
                {
                    var latestSplit = splitRecords.First();
                    if (!string.IsNullOrEmpty(latestSplit.NewBarcode))
                    {
                        var newStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                            .FirstAsync(x => x.Barcode == latestSplit.NewBarcode && x.StockId == originalStockDetail.StockId);

                        if (newStockDetail != null)
                        {
                            // æ–°åº“存的期望值 = æ‹†åŒ…数量
                            decimal expectedNewStockQty = splitQuantity;

                            _logger.LogInformation($"新库存验证:");
                            _logger.LogInformation($"  æ–°æ¡ç : {newStockDetail.Barcode}");
                            _logger.LogInformation($"  æœŸæœ›æ•°é‡: {expectedNewStockQty}");
                            _logger.LogInformation($"  å®žé™…数量: {newStockDetail.StockQuantity}");
                            _logger.LogInformation($"  å‡ºåº“数量: {newStockDetail.OutboundQuantity} (应为0)");

                            if (Math.Abs(newStockDetail.StockQuantity - expectedNewStockQty) > 0.01m)
                            {
                                string error = $"新库存数量不正确！期望: {expectedNewStockQty}, å®žé™…: {newStockDetail.StockQuantity}";
                                validationErrors.Add(error);
                                allValid = false;
                                _logger.LogError(error);
                            }

                            // æ–°åº“存出库数量应为0
                            if (Math.Abs(newStockDetail.OutboundQuantity - 0) > 0.01m)
                            {
                                string error = $"新库存出库数量不为0！实际: {newStockDetail.OutboundQuantity}";
                                validationErrors.Add(error);
                                allValid = false;
                                _logger.LogError(error);
                            }
                        }
                    }
                }

                // 4. éªŒè¯æœªåˆ†é…é”å®šè®°å½•
                var unallocatedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.ParentLockId == lockInfo.Id &&
                               x.IsUnallocated == 1 &&
                               x.OrderDetailId == 0)
                    .ToListAsync();

                if (!unallocatedLocks.Any())
                {
                    string error = $"未找到自动拆包创建的未分配锁定记录";
                    validationErrors.Add(error);
                    allValid = false;
                    _logger.LogError(error);
                }

                // 5. éªŒè¯è®¢å•æ˜Žç»†æ•°æ®æœªæ”¹å˜
                if (Math.Abs(refreshedOrderDetail.AllocatedQuantity - orderDetail.AllocatedQuantity) > 0.01m)
                {
                    string error = $"订单明细分配数量异常变化！拆包前: {orderDetail.AllocatedQuantity}, æ‹†åŒ…后: {refreshedOrderDetail.AllocatedQuantity}";
                    validationErrors.Add(error);
                    allValid = false;
                    _logger.LogError(error);
                }

                // 6. éªŒè¯åŽŸé”å®šè®°å½•æ•°æ®æœªæ”¹å˜ï¼ˆåˆ†é…æ•°é‡ä¸å˜ï¼‰
                if (Math.Abs(refreshedLockInfo.AssignQuantity - lockInfo.AssignQuantity) > 0.01m)
                {
                    string error = $"锁定记录分配数量异常变化！拆包前: {lockInfo.AssignQuantity}, æ‹†åŒ…后: {refreshedLockInfo.AssignQuantity}";
                    validationErrors.Add(error);
                    allValid = false;
                    _logger.LogError(error);
                }

                // 7. ã€æ–°å¢žã€‘验证总库存守恒
                // æ‹†åŒ…前总库存 = åŽŸåº“存数量
                // æ‹†åŒ…后总库存 = åŽŸåº“存现有数量 + æ–°åº“存数量
                decimal totalStockAfterSplit = refreshedStockDetail.StockQuantity;
                if (splitRecords.Any() && !string.IsNullOrEmpty(splitRecords.First().NewBarcode))
                {
                    var newStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                        .FirstAsync(x => x.Barcode == splitRecords.First().NewBarcode);
                    if (newStock != null)
                    {
                        totalStockAfterSplit += newStock.StockQuantity;
                    }
                }

                _logger.LogInformation($"库存守恒验证:");
                _logger.LogInformation($"  æ‹†åŒ…前总库存: {originalStockQtyBeforeSplit}");
                _logger.LogInformation($"  æ‹†åŒ…后总库存: {totalStockAfterSplit}");
                _logger.LogInformation($"  å·®å¼‚: {originalStockQtyBeforeSplit - totalStockAfterSplit}");

                // å…è®¸å¾ˆå°çš„浮点数误差
                if (Math.Abs(originalStockQtyBeforeSplit - totalStockAfterSplit) > 0.02m)
                {
                    string error = $"库存不守恒！拆包前: {originalStockQtyBeforeSplit}, æ‹†åŒ…后总库存: {totalStockAfterSplit}";
                    validationErrors.Add(error);
                    allValid = false;
                    _logger.LogError(error);
                }

                // æ±‡æ€»éªŒè¯ç»“æžœ
                if (allValid)
                {
                    _logger.LogInformation($"✅ è‡ªåŠ¨æ‹†åŒ…后验证全部通过");
                }
                else
                {
                    string errorSummary = $"自动拆包后验证失败，发现{validationErrors.Count}个问题：" +
                                         string.Join("; ", validationErrors.Take(3));
                    _logger.LogError(errorSummary);

                    // è®°å½•è¯¦ç»†é—®é¢˜åˆ°æ—¥å¿—
                    for (int i = 0; i < validationErrors.Count; i++)
                    {
                        _logger.LogError($"问题{i + 1}: {validationErrors[i]}");
                    }
                }

                return allValid;
            }
            catch (Exception ex)
            {
                _logger.LogError($"自动拆包后验证异常: {ex.Message}");
                return false;
            }
        }


        /// <summary>
        /// æ‹£é€‰åŽéªŒè¯
        /// </summary>
        private async Task ValidateAfterPicking(string orderNo, string palletCode, string barcode, decimal pickedQty)
        {
            try
            {
                _logger.LogInformation($"开始拣选后验证");

                // 1. éªŒè¯åº“存明细
                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .FirstAsync(x => x.Barcode == barcode);

                // 2. æŸ¥æ‰¾è¯¥æ¡ç çš„所有拣选记录
                var pickingRecords = await Db.Queryable<Dt_PickingRecord>()
                    .Where(x => x.Barcode == barcode && x.OrderNo == orderNo && !x.IsCancelled)
                    .ToListAsync();

                decimal totalPickedFromRecords = pickingRecords.Sum(x => x.PickQuantity);

                _logger.LogInformation($"拣选验证 - æ¡ç : {barcode}");
                _logger.LogInformation($"  åº“存出库数量: {stockDetail.OutboundQuantity}");
                _logger.LogInformation($"  æ‹£é€‰è®°å½•æ€»å’Œ: {totalPickedFromRecords}");

                if (Math.Abs(stockDetail.OutboundQuantity - totalPickedFromRecords) > 0.01m)
                {
                    _logger.LogError($"拣选数据不一致！库存出库数量({stockDetail.OutboundQuantity}) â‰  æ‹£é€‰è®°å½•æ€»å’Œ({totalPickedFromRecords})");

                    // è‡ªåŠ¨ä¿®å¤ï¼šä»¥æ‹£é€‰è®°å½•æ€»å’Œä¸ºå‡†
                    decimal originalOutbound = stockDetail.OutboundQuantity;
                    stockDetail.OutboundQuantity = totalPickedFromRecords;
                    await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();

                    _logger.LogWarning($"已自动修复出库数量: {originalOutbound} -> {totalPickedFromRecords}");
                }

                _logger.LogInformation($"拣选后验证完成");
            }
            catch (Exception ex)
            {
                _logger.LogError($"拣选后验证失败: {ex.Message}");
            }
        }


        /// <summary>
        /// å–消分拣
        /// </summary>
@@ -459,13 +747,17 @@
            }
        }


        /// <summary>
        /// æ¸…理库存信息 - å¢žå¼ºç‰ˆæœ¬
        /// æ¸…理库存信息 - å®Œæ•´ä¿®æ­£ç‰ˆ
        /// ç¡®ä¿OutboundQuantity正确清零
        /// </summary>
        private async Task CleanupStockInfo(Dt_OutStockLockInfo lockInfo)
        {
            try
            {
                _logger.LogInformation($"清理库存信息 - é”å®šID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}");

                // æŸ¥æ‰¾é”å®šçš„库存明细
                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);
@@ -473,44 +765,59 @@
                if (stockDetail != null)
                {
                    // è®°å½•æ¸…理前的状态
                    decimal originalQty = stockDetail.StockQuantity;
                    decimal originalStockQty = stockDetail.StockQuantity;
                    decimal originalOutboundQty = stockDetail.OutboundQuantity;
                    int originalStatus = stockDetail.Status;

                    // å¦‚果库存数量大于0，需要先清零
                    if (stockDetail.StockQuantity > 0)
                    _logger.LogInformation($"清理前状态 - åº“å­˜: {originalStockQty}, å‡ºåº“: {originalOutboundQty}, çŠ¶æ€: {GetStockStatusName(originalStatus)}");

                    // ã€é‡è¦ã€‘检查库存数量是否应该为0
                    // å¦‚果锁定状态是拣选完成，理论上库存应该为0
                    if (lockInfo.Status == (int)OutLockStockStatusEnum.拣选完成)
                    {
                        _logger.LogWarning($"取走空托盘时发现条码 {lockInfo.CurrentBarcode} è¿˜æœ‰åº“å­˜ {stockDetail.StockQuantity}，自动清零");
                        stockDetail.StockQuantity = 0;
                        stockDetail.OutboundQuantity = 0;
                        if (stockDetail.StockQuantity > 0)
                        {
                            _logger.LogWarning($"拣选完成但库存不为0 - æ¡ç : {stockDetail.Barcode}, åº“å­˜: {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");
                    _logger.LogInformation($"清理库存明细完成");
                    _logger.LogInformation($"  åº“存数量: {originalStockQty} -> 0");
                    _logger.LogInformation($"  å‡ºåº“数量: {originalOutboundQty} -> 0");
                    _logger.LogInformation($"  çŠ¶æ€: {GetStockStatusName(originalStatus)} -> å·²æ¸…理");
                }
                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())
                {
                    _logger.LogInformation($"清理托盘上其他库存 - å…± {allStockDetails.Count} æ¡è®°å½•");

                    foreach (var stock in allStockDetails)
                    {
                        decimal originalQty = stock.StockQuantity;
                        decimal originalOutbound = stock.OutboundQuantity;

                        stock.StockQuantity = 0;
                        stock.OutboundQuantity = 0;
                        stock.OutboundQuantity = 0;  // ã€ä¿®æ­£ã€‘确保出库数量清零
                        stock.Status = (int)StockStatusEmun.已清理;

                        await _stockInfoDetailService.Db.Updateable(stock).ExecuteCommandAsync();
                        _logger.LogWarning($"清理遗漏库存 - æ¡ç : {stock.Barcode}, æ•°é‡: {stock.StockQuantity} -> 0");
                        _logger.LogInformation($"清理遗漏库存 - æ¡ç : {stock.Barcode}, åº“å­˜: {originalQty}->0, å‡ºåº“: {originalOutbound}->0");
                    }
                }
            }
@@ -520,7 +827,6 @@
                // ä¸æŠ›å‡ºå¼‚常，继续处理其他记录
            }
        }


        /// <summary>
        /// æ›´æ–°è®¢å•çŠ¶æ€
@@ -556,17 +862,17 @@
        /// </summary>
        private async Task RecordEmptyPalletRemoval(string orderNo, string palletCode, List<Dt_OutStockLockInfo> completedLocks)
        {
            var removalRecord = new Dt_EmptyPalletRemoval
            {
                OrderNo = orderNo,
                PalletCode = palletCode,
                RemovalTime = DateTime.Now,
                Operator = App.User.UserName,
                CompletedItemsCount = completedLocks.Count,
                TotalPickedQuantity = completedLocks.Sum(x => x.PickedQty)
            };
            //var removalRecord = new Dt_EmptyPalletRemoval
            //{
            //    OrderNo = orderNo,
            //    PalletCode = palletCode,
            //    RemovalTime = DateTime.Now,
            //    Operator = App.User.UserName,
            //    CompletedItemsCount = completedLocks.Count,
            //    TotalPickedQuantity = completedLocks.Sum(x => x.PickedQty)
            //};

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

        #endregion
@@ -597,7 +903,6 @@
            }
        };
        }



        #region æ‰‹åŠ¨æ‹†åŒ…   
@@ -737,8 +1042,10 @@
            return lockInfos.Sum(x => x.AssignQuantity);
        }



        /// <summary>
        /// æ‰§è¡Œæ‰‹åŠ¨æ‹†åŒ…逻辑 - å®Œæ•´ç‰ˆæœ¬
        /// æ‰§è¡Œæ‰‹åŠ¨æ‹†åŒ…逻辑 - ä¿®å¤ç‰ˆæœ¬
        /// </summary>
        private async Task<List<SplitResult>> ExecuteManualSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
            decimal splitQuantity, string palletCode)
@@ -782,15 +1089,22 @@
                decimal originalStockQty = stockDetail.StockQuantity;
                decimal originalOutboundQty = stockDetail.OutboundQuantity;

                // åˆ›å»ºæ–°åº“存明细
                // ä¿®å¤ï¼šè®¡ç®—新库存明细的正确数量
                // æ–°æ¡ç åº”该只有拆包数量，而不是2倍
                decimal newStockQuantity = splitQuantity;
                decimal originalRemainingStockQuantity = originalStockQty - splitQuantity;

                _logger.LogInformation($"数量分配 - æ–°æ¡ç æ•°é‡: {newStockQuantity}, åŽŸæ¡ç å‰©ä½™æ•°é‡: {originalRemainingStockQuantity}");

                // åˆ›å»ºæ–°åº“存明细 - ä¿®å¤æ•°é‡é—®é¢˜
                var newStockDetail = new Dt_StockInfoDetail
                {
                    StockId = stockDetail.StockId,
                    MaterielCode = stockDetail.MaterielCode,
                    OrderNo = stockDetail.OrderNo,
                    BatchNo = stockDetail.BatchNo,
                    StockQuantity = splitQuantity,
                    OutboundQuantity = 0,
                    StockQuantity = newStockQuantity,  // ä¿®å¤ï¼šä½¿ç”¨æ­£ç¡®çš„拆包数量
                    OutboundQuantity = 0,  // æ–°æ¡ç åˆå§‹å‡ºåº“数量为0
                    Barcode = newBarcode,
                    Status = (int)StockStatusEmun.出库锁定,
                    SupplyCode = stockDetail.SupplyCode,
@@ -802,11 +1116,10 @@
                };

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

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

                // ç¡®ä¿ä¸ä¼šä¸ºè´Ÿæ•°
                if (stockDetail.StockQuantity < 0)
@@ -815,8 +1128,8 @@
                    stockDetail.StockQuantity = 0;
                }

                // å‡ºåº“数量保持不变
                // stockDetail.OutboundQuantity = stockDetail.OutboundQuantity; // ä¿æŒä¸å˜
                // å‡ºåº“数量保持不变，因为是拆包，不是实际出库
                // stockDetail.OutboundQuantity = stockDetail.OutboundQuantity;

                await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
                _logger.LogInformation($"更新原库存明细 - æ¡ç : {stockDetail.Barcode}, " +
@@ -827,7 +1140,7 @@
                var newLockInfo = new Dt_OutStockLockInfo
                {
                    OrderNo = lockInfo.OrderNo,
                    OrderDetailId = lockInfo.OrderDetailId, // ç»‘定到同一个订单明细
                    OrderDetailId = lockInfo.OrderDetailId,
                    OutboundBatchNo = lockInfo.OutboundBatchNo,
                    MaterielCode = lockInfo.MaterielCode,
                    MaterielName = lockInfo.MaterielName,
@@ -864,18 +1177,14 @@
                _logger.LogInformation($"更新原锁定信息 - åˆ†é…æ•°é‡: {originalLockAssignQty} -> {lockInfo.AssignQuantity}, " +
                                     $"订单数量: {originalLockOrderQty} -> {lockInfo.OrderQuantity}");

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

                // è®°å½•æ‹†åŒ…历史
                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}");

@@ -887,6 +1196,7 @@
                throw;
            }
        }

        /// <summary>
        /// éªŒè¯æ‹†åŒ…后订单明细的分配数量是否保持不变
        /// </summary>
@@ -965,8 +1275,6 @@
            }
        }
        #endregion



        #region å–消拆包 

@@ -1864,136 +2172,7 @@

            return totalQty;
        }

        /// <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>
@@ -2005,11 +2184,11 @@

                _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);

@@ -2018,7 +2197,7 @@

                int stockId = stockInfo.Id;

                // 3. æ‰§è¡Œå›žåº“前数据验证
                //  æ‰§è¡Œå›žåº“前数据验证
                var validationResult = await ValidateDataBeforeReturn(orderNo, palletCode, stockId);
                if (!validationResult.IsValid)
                {
@@ -2026,7 +2205,7 @@
                    // å¯ä»¥æ ¹æ®å®žé™…情况决定是否继续
                }

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

                if (!statusAnalysis.HasItemsToReturn)
@@ -2048,7 +2227,7 @@

                _logger.LogInformation($"【开始回库】总回库数量: {statusAnalysis.TotalReturnQty}, æ¡ç æ•°: {statusAnalysis.AllBarcodes.Count}");

                // 5. æ‰§è¡Œå›žåº“操作
                //  æ‰§è¡Œå›žåº“操作
                try
                {
                    await ExecuteEnhancedReturnOperations(statusAnalysis);
@@ -2060,12 +2239,12 @@
                    await ExecuteSimpleReturnDataOperations(statusAnalysis);
                }

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

                _unitOfWorkManage.CommitTran();
              

                // 7. åˆ›å»ºå›žåº“任务
                //  åˆ›å»ºå›žåº“任务
                try
                {
                    await CreateReturnTask(orderNo, palletCode, stockInfo);
@@ -2174,40 +2353,569 @@
            }
        }

        /// <summary>
        /// æ‰§è¡Œå¢žå¼ºçš„回库操作
        // <summary>
        /// æ‰§è¡Œå¢žå¼ºçš„回库操作 - ä¿®æ­£ç‰ˆï¼ˆé¿å…é‡å¤å¤„理）
        /// </summary>
        private async Task ExecuteEnhancedReturnOperations(PalletStatusAnalysis statusAnalysis)
        {
            _logger.LogInformation($"执行增强回库操作 - è®¢å•: {statusAnalysis.OrderNo}, æ‰˜ç›˜: {statusAnalysis.PalletCode}");
            _logger.LogInformation($"【开始执行回库操作】订单: {statusAnalysis.OrderNo}, æ‰˜ç›˜: {statusAnalysis.PalletCode}");

            // å¤„理已分配的锁定记录
            // ä½¿ç”¨æœ¬åœ°å·²å¤„理集合，避免重复
            var locallyProcessedBarcodes = new HashSet<string>();
            decimal totalProcessedQty = 0;

            // 1. å¤„理已分配的锁定记录
            if (statusAnalysis.HasRemainingLocks)
            {
                await HandleAllocatedLocksReturn(statusAnalysis.RemainingLocks);
                _logger.LogInformation($"处理已分配锁定记录 - {statusAnalysis.RemainingLocks.Count} æ¡");
                foreach (var lockInfo in statusAnalysis.RemainingLocks)
                {
                    if (string.IsNullOrEmpty(lockInfo.CurrentBarcode) ||
                        locallyProcessedBarcodes.Contains(lockInfo.CurrentBarcode))
                    {
                        _logger.LogInformation($"跳过已处理条码的锁定记录: {lockInfo.CurrentBarcode}");
                        continue;
                    }

                    decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
                    if (returnQty > 0)
                    {
                        // ã€ä¿®å¤ã€‘传递 isUnallocated = false
                        await ProcessSingleBarcodeReturn(lockInfo.CurrentBarcode, statusAnalysis.StockId, returnQty, false);
                        locallyProcessedBarcodes.Add(lockInfo.CurrentBarcode);
                        totalProcessedQty += returnQty;
                        _logger.LogInformation($"已处理锁定记录 - æ¡ç : {lockInfo.CurrentBarcode}, æ•°é‡: {returnQty}");
                    }
                }
            }

            // å¤„理未分配的锁定记录
            // 2. å¤„理未分配的锁定记录
            if (statusAnalysis.HasUnallocatedLocks)
            {
                await HandleUnallocatedLocksReturn(statusAnalysis.UnallocatedLocks);
                _logger.LogInformation($"处理未分配锁定记录 - {statusAnalysis.UnallocatedLocks.Count} æ¡");
                foreach (var lockInfo in statusAnalysis.UnallocatedLocks)
                {
                    if (string.IsNullOrEmpty(lockInfo.CurrentBarcode) ||
                        locallyProcessedBarcodes.Contains(lockInfo.CurrentBarcode))
                    {
                        _logger.LogInformation($"跳过已处理条码的未分配锁定: {lockInfo.CurrentBarcode}");
                        continue;
                    }

                    decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;
                    if (returnQty > 0)
                    {
                        // ã€ä¿®å¤ã€‘使用专门的未分配锁定处理方法
                        await ProcessUnallocatedLockReturn(lockInfo, returnQty);
                        locallyProcessedBarcodes.Add(lockInfo.CurrentBarcode);
                        totalProcessedQty += returnQty;
                        _logger.LogInformation($"已处理未分配锁定 - æ¡ç : {lockInfo.CurrentBarcode}, æ•°é‡: {returnQty}");
                    }
                }
            }

            // å¤„理未分配的库存货物
            // 3. å¤„理未分配的库存货物
            if (statusAnalysis.HasPalletStockGoods)
            {
                await HandleUnallocatedStockReturn(statusAnalysis.PalletStockGoods);
                _logger.LogInformation($"处理未分配库存货物 - {statusAnalysis.PalletStockGoods.Count} ä¸ª");
                foreach (var stockDetail in statusAnalysis.PalletStockGoods)
                {
                    if (string.IsNullOrEmpty(stockDetail.Barcode) ||
                        locallyProcessedBarcodes.Contains(stockDetail.Barcode))
                    {
                        _logger.LogInformation($"跳过已处理条码的库存: {stockDetail.Barcode}");
                        continue;
                    }

                    decimal returnQty = stockDetail.StockQuantity;
                    if (returnQty > 0)
                    {
                        await ProcessUnallocatedStockReturn(stockDetail);
                        locallyProcessedBarcodes.Add(stockDetail.Barcode);
                        totalProcessedQty += returnQty;
                        _logger.LogInformation($"已处理未分配库存 - æ¡ç : {stockDetail.Barcode}, æ•°é‡: {returnQty}");
                    }
                }
            }

            // å¤„理拆包记录
            if (statusAnalysis.HasSplitRecords)
            // 4. ã€ä¿®æ­£ã€‘处理拆包记录 - åªå¤„理未被其他逻辑覆盖的条码
            if (statusAnalysis.HasSplitRecords && statusAnalysis.SplitReturnQty > 0)
            {
                await HandleSplitRecordsReturn(statusAnalysis.SplitRecords, statusAnalysis.StockId);
                _logger.LogInformation($"处理拆包记录相关库存 - æ–°å¢žæ•°é‡: {statusAnalysis.SplitReturnQty}");

                // åªå¤„理在SplitRecords中但不在已处理集合中的条码
                var splitBarcodes = statusAnalysis.SplitRecords
                    .SelectMany(r => new[] { r.OriginalBarcode, r.NewBarcode })
                    .Where(b => !string.IsNullOrEmpty(b))
                    .Distinct()
                    .ToList();

                foreach (var barcode in splitBarcodes)
                {
                    if (locallyProcessedBarcodes.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;
                        await ProcessSingleBarcodeReturn(barcode, statusAnalysis.StockId, returnQty);
                        locallyProcessedBarcodes.Add(barcode);
                        totalProcessedQty += returnQty;
                        _logger.LogInformation($"处理拆包条码 - {barcode}, æ•°é‡: {returnQty}");
                    }
                }
            }

            _logger.LogInformation($"【回库操作完成】总处理数量: {totalProcessedQty}, å¤„理条码数: {locallyProcessedBarcodes.Count}");

            // éªŒè¯å¤„理数量与预期一致
            if (Math.Abs(totalProcessedQty - statusAnalysis.TotalReturnQty) > 0.01m)
            {
                _logger.LogWarning($"处理数量({totalProcessedQty})与预期({statusAnalysis.TotalReturnQty})不一致，但继续执行");
            }
        }


        /// <summary>
        /// å¤„理已分配锁定记录的回库
        /// å·²åˆ†é…é”å®šè®°å½•éœ€è¦ï¼š1.恢复库存 2.更新锁定状态 3.减少订单明细分配数量
        /// </summary>
        private async Task ProcessSingleLockReturn(Dt_OutStockLockInfo lockInfo, decimal returnQty)
        {
            try
            {
                _logger.LogInformation($"开始处理已分配锁定记录回库 - é”å®šID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, å›žåº“数量: {returnQty}");

                if (returnQty <= 0)
                {
                    _logger.LogInformation($"回库数量无效({returnQty})，跳过处理");
                    return;
                }

                // 1. éªŒè¯é”å®šè®°å½•çŠ¶æ€
                if (lockInfo.Status != (int)OutLockStockStatusEnum.出库中 &&
                    lockInfo.Status != (int)OutLockStockStatusEnum.回库中)
                {
                    _logger.LogWarning($"锁定记录状态不是出库中或回库中，跳过处理 - çŠ¶æ€: {lockInfo.Status}");
                    return;
                }

                // 2. èŽ·å–关联的库存明细
                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

                if (stockDetail == null)
                {
                    _logger.LogError($"未找到库存明细 - æ¡ç : {lockInfo.CurrentBarcode}, StockId: {lockInfo.StockId}");
                    throw new InvalidOperationException($"库存明细不存在: {lockInfo.CurrentBarcode}");
                }

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

                if (orderDetail == null)
                {
                    _logger.LogError($"未找到订单明细 - OrderDetailId: {lockInfo.OrderDetailId}");
                    throw new InvalidOperationException($"订单明细不存在: {lockInfo.OrderDetailId}");
                }

                // è®°å½•åŽŸå§‹å€¼ï¼ˆç”¨äºŽæ—¥å¿—和回滚检查）
                decimal originalStockQty = stockDetail.StockQuantity;
                decimal originalOutboundQty = stockDetail.OutboundQuantity;
                int originalStockStatus = stockDetail.Status;

                decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
                decimal originalLockQty = orderDetail.LockQuantity;
                decimal originalOverOutQty = orderDetail.OverOutQuantity;

                decimal originalLockPickedQty = lockInfo.PickedQty;
                decimal originalLockAssignQty = lockInfo.AssignQuantity;
                int originalLockStatus = lockInfo.Status;

                _logger.LogInformation($"回库前数据状态:");
                _logger.LogInformation($"  åº“å­˜ - æ¡ç : {stockDetail.Barcode}, æ•°é‡: {originalStockQty}, å‡ºåº“: {originalOutboundQty}, çŠ¶æ€: {GetStockStatusName(originalStockStatus)}");
                _logger.LogInformation($"  è®¢å•æ˜Žç»† - åˆ†é…: {originalAllocatedQty}, é”å®š: {originalLockQty}, å·²å‡ºåº“: {originalOverOutQty}");
                _logger.LogInformation($"  é”å®šè®°å½• - åˆ†é…: {originalLockAssignQty}, å·²æ‹£é€‰: {originalLockPickedQty}, çŠ¶æ€: {GetLockStatusName(originalLockStatus)}");

                // 4. ã€æ ¸å¿ƒé€»è¾‘】恢复库存数据
                // 4.1 å¢žåŠ åº“存数量
                stockDetail.StockQuantity += returnQty;

                // 4.2 å‡å°‘出库数量（但需确保不会出现负数）
                if (stockDetail.OutboundQuantity >= returnQty)
                {
                    stockDetail.OutboundQuantity -= returnQty;
                }
                else
                {
                    // å¦‚果出库数量小于回库数量，说明数据异常
                    _logger.LogWarning($"出库数量({stockDetail.OutboundQuantity})小于回库数量({returnQty})，数据异常");
                    stockDetail.OutboundQuantity = 0;
                }

                // 4.3 æ›´æ–°åº“存状态
                if (stockDetail.OutboundQuantity <= 0 && stockDetail.StockQuantity > 0)
                {
                    stockDetail.Status = (int)StockStatusEmun.入库完成;
                    _logger.LogInformation($"库存状态更新为: å…¥åº“完成");
                }
                else if (stockDetail.StockQuantity > 0)
                {
                    stockDetail.Status = (int)StockStatusEmun.出库锁定;
                    _logger.LogInformation($"库存状态保持为: å‡ºåº“锁定");
                }

                await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
                _logger.LogInformation($"库存更新完成 - æ¡ç : {stockDetail.Barcode}");
                _logger.LogInformation($"  åº“存数量: {originalStockQty} -> {stockDetail.StockQuantity}");
                _logger.LogInformation($"  å‡ºåº“数量: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
                _logger.LogInformation($"  çŠ¶æ€: {GetStockStatusName(originalStockStatus)} -> {GetStockStatusName(stockDetail.Status)}");

                // 5. æ›´æ–°é”å®šè®°å½•çŠ¶æ€
                lockInfo.Status = (int)OutLockStockStatusEnum.已回库;
                lockInfo.Operator = App.User.UserName;

                // ã€é‡è¦ã€‘如果锁定记录是部分拣选后回库，需要调整已拣选数量
                // ä½†ä¸€èˆ¬æƒ…况下，回库的是未拣选的部分，所以PickedQty保持不变

                await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
                _logger.LogInformation($"锁定记录更新完成 - ID: {lockInfo.Id}");
                _logger.LogInformation($"  çŠ¶æ€: {GetLockStatusName(originalLockStatus)} -> {GetLockStatusName(lockInfo.Status)}");
                _logger.LogInformation($"  åˆ†é…æ•°é‡: {originalLockAssignQty} (不变)");
                _logger.LogInformation($"  å·²æ‹£é€‰æ•°é‡: {originalLockPickedQty} (不变)");

                // 6. æ›´æ–°è®¢å•æ˜Žç»†æ•°æ®
                // 6.1 å‡å°‘已分配数量
                if (orderDetail.AllocatedQuantity >= returnQty)
                {
                    orderDetail.AllocatedQuantity -= returnQty;
                }
                else
                {
                    // å¦‚果分配数量小于回库数量，说明数据异常
                    _logger.LogWarning($"分配数量({orderDetail.AllocatedQuantity})小于回库数量({returnQty})，重置为0");
                    orderDetail.AllocatedQuantity = 0;
                }

                // 6.2 å‡å°‘锁定数量（应与分配数量保持同步）
                if (orderDetail.LockQuantity >= returnQty)
                {
                    orderDetail.LockQuantity -= returnQty;
                }
                else
                {
                    _logger.LogWarning($"锁定数量({orderDetail.LockQuantity})小于回库数量({returnQty})，重置为0");
                    orderDetail.LockQuantity = 0;
                }

                // 6.3 å·²å‡ºåº“数量保持不变（回库不影响已出库数量）
                // orderDetail.OverOutQuantity = orderDetail.OverOutQuantity;

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

                await _outboundOrderDetailService.Db.Updateable(orderDetail).ExecuteCommandAsync();
                _logger.LogInformation($"订单明细更新完成 - ID: {orderDetail.Id}");
                _logger.LogInformation($"  åˆ†é…æ•°é‡: {originalAllocatedQty} -> {orderDetail.AllocatedQuantity}");
                _logger.LogInformation($"  é”å®šæ•°é‡: {originalLockQty} -> {orderDetail.LockQuantity}");
                _logger.LogInformation($"  å·²å‡ºåº“数量: {originalOverOutQty} (保持不变)");

                // 7. éªŒè¯å›žåº“后的数据一致性
                await ValidateAfterLockReturn(lockInfo, stockDetail, orderDetail, returnQty);

                _logger.LogInformation($"已分配锁定记录回库处理完成 - é”å®šID: {lockInfo.Id}, å›žåº“数量: {returnQty}");
            }
            catch (Exception ex)
            {
                _logger.LogError($"处理已分配锁定记录回库失败 - é”å®šID: {lockInfo.Id}, Error: {ex.Message}");
                throw new InvalidOperationException($"处理锁定记录回库失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// å›žåº“后数据验证
        /// é”å®šè®°å½•å›žåº“后验证数据一致性
        /// </summary>
        private async Task ValidateAfterLockReturn(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
            Dt_OutboundOrderDetail orderDetail, decimal returnQty)
        {
            try
            {
                _logger.LogInformation($"开始回库后数据验证 - é”å®šID: {lockInfo.Id}");

                bool allValid = true;
                List<string> validationErrors = new List<string>();

                // 1. é‡æ–°èŽ·å–最新数据
                var refreshedStock = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .FirstAsync(x => x.Id == stockDetail.Id);

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

                var refreshedLock = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .FirstAsync(x => x.Id == lockInfo.Id);

                // 2. éªŒè¯åº“存数据
                // è®¡ç®—库存数量应该增加回库数量
                decimal expectedStockQty = stockDetail.StockQuantity + returnQty;
                if (Math.Abs(refreshedStock.StockQuantity - expectedStockQty) > 0.01m)
                {
                    string error = $"库存数量不正确！期望: {expectedStockQty}, å®žé™…: {refreshedStock.StockQuantity}";
                    validationErrors.Add(error);
                    allValid = false;
                    _logger.LogError(error);
                }

                // éªŒè¯åº“存状态应为入库完成或出库锁定
                if (refreshedStock.Status != (int)StockStatusEmun.入库完成 &&
                    refreshedStock.Status != (int)StockStatusEmun.出库锁定)
                {
                    string error = $"库存状态异常！期望:入库完成或出库锁定, å®žé™…:{GetStockStatusName(refreshedStock.Status)}";
                    validationErrors.Add(error);
                    allValid = false;
                    _logger.LogError(error);
                }

                // 3. éªŒè¯é”å®šè®°å½•çŠ¶æ€
                if (refreshedLock.Status != (int)OutLockStockStatusEnum.已回库)
                {
                    string error = $"锁定记录状态异常！期望:已回库, å®žé™…:{GetLockStatusName(refreshedLock.Status)}";
                    validationErrors.Add(error);
                    allValid = false;
                    _logger.LogError(error);
                }

                // 4. éªŒè¯è®¢å•æ˜Žç»†æ•°æ®
                // è®¡ç®—分配数量应该减少回库数量
                decimal expectedAllocatedQty = Math.Max(0, orderDetail.AllocatedQuantity - returnQty);
                if (Math.Abs(refreshedOrder.AllocatedQuantity - expectedAllocatedQty) > 0.01m)
                {
                    string error = $"订单分配数量不正确！期望: {expectedAllocatedQty}, å®žé™…: {refreshedOrder.AllocatedQuantity}";
                    validationErrors.Add(error);
                    allValid = false;
                    _logger.LogError(error);
                }

                // åˆ†é…æ•°é‡åº”与锁定数量一致
                if (Math.Abs(refreshedOrder.AllocatedQuantity - refreshedOrder.LockQuantity) > 0.01m)
                {
                    string error = $"订单分配数量与锁定数量不一致！分配: {refreshedOrder.AllocatedQuantity}, é”å®š: {refreshedOrder.LockQuantity}";
                    validationErrors.Add(error);
                    allValid = false;
                    _logger.LogError(error);
                }

                // 5. æ•°æ®å…³è”性验证
                // é”å®šè®°å½•çš„已拣选数量 + å½“前库存的出库数量应等于原始出库数量
                decimal totalOutboundFromLock = refreshedLock.PickedQty + refreshedStock.OutboundQuantity;

                // æŸ¥æ‰¾è¯¥æ¡ç çš„所有未取消拣选记录
                var pickingRecords = await Db.Queryable<Dt_PickingRecord>()
                    .Where(x => x.Barcode == stockDetail.Barcode && !x.IsCancelled)
                    .ToListAsync();

                decimal totalPickedFromRecords = pickingRecords.Sum(x => x.PickQuantity);

                if (Math.Abs(totalOutboundFromLock - totalPickedFromRecords) > 0.01m)
                {
                    string error = $"数据关联性异常！锁定拣选({refreshedLock.PickedQty})+库存出库({refreshedStock.OutboundQuantity})={totalOutboundFromLock}, ä½†æ‹£é€‰è®°å½•æ€»å’Œ={totalPickedFromRecords}";
                    validationErrors.Add(error);
                    allValid = false;
                    _logger.LogError(error);
                }

                // 6. è¾“出验证结果
                if (allValid)
                {
                    _logger.LogInformation($"回库后数据验证全部通过");
                }
                else
                {
                    _logger.LogError($"回库后数据验证失败，发现{validationErrors.Count}个问题");
                    foreach (var error in validationErrors.Take(3)) // åªæ˜¾ç¤ºå‰3个问题
                    {
                        _logger.LogError($"验证问题: {error}");
                    }

                    // å¦‚果问题严重，可以抛出异常
                    if (validationErrors.Any(e => e.Contains("异常")))
                    {
                        throw new InvalidOperationException($"回库后数据验证失败: {string.Join("; ", validationErrors.Take(2))}");
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"回库后验证异常: {ex.Message}");
                // ä¸é‡æ–°æŠ›å‡ºï¼Œé¿å…å½±å“ä¸»æµç¨‹
            }
        }

        /// <summary>
        /// å¤„理单个条码回库（通用方法）- åŒºåˆ†å·²åˆ†é…å’Œæœªåˆ†é…
        /// </summary>
        private async Task ProcessSingleBarcodeReturn(string barcode, int stockId, decimal returnQty, bool isUnallocated = false)
        {
            try
            {
                _logger.LogInformation($"处理单个条码回库 - {barcode}, æ•°é‡: {returnQty}, æ˜¯å¦æœªåˆ†é…: {isUnallocated}");

                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($"回库前状态 - åº“å­˜: {originalStockQty}, å‡ºåº“: {originalOutboundQty}, çŠ¶æ€: {GetStockStatusName(originalStatus)}");

                // ã€ä¿®å¤ã€‘根据是否未分配决定处理逻辑
                if (isUnallocated)
                {
                    // æœªåˆ†é…é”å®šï¼šåªæ¢å¤çŠ¶æ€ï¼Œä¸æ”¹å˜åº“存数量
                    // å‡ºåº“数量应为0
                    if (stockDetail.OutboundQuantity > 0)
                    {
                        _logger.LogWarning($"未分配锁定的库存出库数量不为0，重置为0 - æ¡ç : {stockDetail.Barcode}, å½“前出库: {stockDetail.OutboundQuantity}");
                        stockDetail.OutboundQuantity = 0;
                    }

                    // åº“存数量保持不变
                    _logger.LogInformation($"未分配锁定回库 - åº“存数量保持不变: {stockDetail.StockQuantity}");
                }
                else
                {
                    // å·²åˆ†é…é”å®šï¼šæ¢å¤åº“存数量
                    stockDetail.StockQuantity += returnQty;

                    // å‡å°‘出库数量（如果出库数量大于0）
                    if (stockDetail.OutboundQuantity >= returnQty)
                    {
                        stockDetail.OutboundQuantity -= returnQty;
                    }
                    else
                    {
                        // å¦‚果出库数量小于回库数量，说明数据异常，出库数量清零
                        _logger.LogWarning($"出库数量({stockDetail.OutboundQuantity})小于回库数量({returnQty})，清零");
                        stockDetail.OutboundQuantity = 0;
                    }

                    _logger.LogInformation($"已分配锁定回库 - åº“存数量增加: {originalStockQty} -> {stockDetail.StockQuantity}");
                }

                // æ›´æ–°çŠ¶æ€
                stockDetail.Status = (int)StockStatusEmun.入库完成;

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

                _logger.LogInformation($"条码回库完成 - {barcode}: åº“å­˜ {originalStockQty}->{stockDetail.StockQuantity}, å‡ºåº“ {originalOutboundQty}->{stockDetail.OutboundQuantity}");
            }
            catch (Exception ex)
            {
                _logger.LogError($"处理条码回库失败 - {barcode}: {ex.Message}");
                throw;
            }
        }
        /// <summary>
        /// å¤„理未分配锁定记录回库 - ä¿®å¤ç‰ˆæœ¬
        /// æœªåˆ†é…é”å®šè®°å½•ï¼šåªæ¢å¤çŠ¶æ€ï¼Œä¸å¢žåŠ åº“存数量
        /// </summary>
        private async Task ProcessUnallocatedLockReturn(Dt_OutStockLockInfo lockInfo, decimal returnQty)
        {
            _logger.LogInformation($"处理未分配锁定回库 - é”å®šID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, æ•°é‡: {returnQty}");

            try
            {
                // éªŒè¯é”å®šè®°å½•çŠ¶æ€
                if (lockInfo.Status != (int)OutLockStockStatusEnum.出库中 &&
                    lockInfo.Status != (int)OutLockStockStatusEnum.回库中)
                {
                    _logger.LogWarning($"锁定记录状态不是出库中或回库中，跳过处理 - çŠ¶æ€: {lockInfo.Status}");
                    return;
                }

                // ã€ä¿®å¤ã€‘获取库存明细
                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

                if (stockDetail == null)
                {
                    _logger.LogError($"未找到库存明细 - æ¡ç : {lockInfo.CurrentBarcode}, StockId: {lockInfo.StockId}");
                    throw new InvalidOperationException($"库存明细不存在: {lockInfo.CurrentBarcode}");
                }

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

                _logger.LogInformation($"未分配锁定回库前状态:");
                _logger.LogInformation($"  åº“å­˜ - æ¡ç : {stockDetail.Barcode}, æ•°é‡: {originalStockQty}, å‡ºåº“: {originalOutboundQty}, çŠ¶æ€: {GetStockStatusName(originalStatus)}");

                // ã€ä¿®å¤å…³é”®ã€‘对于未分配锁定记录，库存数量不应改变！
                // å› ä¸ºåº“存本来就存在，只是状态被锁定
                // stockDetail.StockQuantity ä¿æŒä¸å˜

                // å‡ºåº“数量应为0（未分配锁定不应该有出库）
                if (stockDetail.OutboundQuantity > 0)
                {
                    _logger.LogWarning($"未分配锁定的库存出库数量不为0，重置为0 - æ¡ç : {stockDetail.Barcode}, å½“前出库: {stockDetail.OutboundQuantity}");
                    stockDetail.OutboundQuantity = 0;
                }

                // æ›´æ–°åº“存状态为入库完成（恢复为可用状态）
                stockDetail.Status = (int)StockStatusEmun.入库完成;

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

                _logger.LogInformation($"更新未分配库存状态 - æ¡ç : {stockDetail.Barcode}");
                _logger.LogInformation($"  åº“存数量: {originalStockQty} -> {stockDetail.StockQuantity} (保持不变)");
                _logger.LogInformation($"  å‡ºåº“数量: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
                _logger.LogInformation($"  çŠ¶æ€: {GetStockStatusName(originalStatus)} -> {GetStockStatusName(stockDetail.Status)}");

                // æ›´æ–°é”å®šè®°å½•çŠ¶æ€ä¸ºå·²å›žåº“
                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($"处理未分配锁定回库失败 - é”å®šID: {lockInfo.Id}, Error: {ex.Message}");
                throw new InvalidOperationException($"处理未分配锁定回库失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// å¤„理未分配库存回库
        /// </summary>
        private async Task ProcessUnallocatedStockReturn(Dt_StockInfoDetail stockDetail)
        {
            _logger.LogInformation($"处理未分配库存回库 - æ¡ç : {stockDetail.Barcode}, æ•°é‡: {stockDetail.StockQuantity}");

            // ç›´æŽ¥æ›´æ–°åº“存状态
            stockDetail.Status = (int)StockStatusEmun.入库完成;
            await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
        }


        /// <summary>
        /// å›žåº“后数据验证 - å¢žå¼ºç‰ˆ
        /// </summary>
        private async Task ValidateDataAfterReturn(string orderNo, string palletCode, int stockId)
        {
@@ -2215,17 +2923,18 @@
            {
                _logger.LogInformation($"开始回库后数据验证");

                // 1. éªŒè¯åº“存状态
                // 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();
                decimal totalStock = stockDetails.Sum(x => x.StockQuantity);

                if (stillOutboundLocked.Any())
                // éªŒè¯åº“存数量是否合理
                var unreasonableStocks = stockDetails.Where(x => x.StockQuantity < 0).ToList();
                if (unreasonableStocks.Any())
                {
                    _logger.LogWarning($"回库后仍有出库锁定状态的库存: {stillOutboundLocked.Count}个");
                    _logger.LogError($"发现负数库存数量！条码: {string.Join(", ", unreasonableStocks.Select(x => x.Barcode))}");
                }

                // 2. éªŒè¯é”å®šè®°å½•çŠ¶æ€
@@ -2235,16 +2944,42 @@

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

                if (notReturnedLocks.Any())
                {
                    _logger.LogWarning($"回库后仍有未回库状态的锁定记录: {notReturnedLocks.Count}条");
                    foreach (var lockInfo in notReturnedLocks)
                    {
                        _logger.LogWarning($"未回库锁定 - ID: {lockInfo.Id}, çŠ¶æ€: {GetLockStatusName(lockInfo.Status)}, æ¡ç : {lockInfo.CurrentBarcode}");
                    }
                }

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

                _logger.LogInformation($"回库验证汇总:");
                _logger.LogInformation($"  å›žåº“后库存总量: {totalStock}");
                _logger.LogInformation($"  å·²å›žåº“锁定记录数量: {lockInfos.Count(x => x.Status == (int)OutLockStockStatusEnum.已回库)}");
                _logger.LogInformation($"  æ€»å›žåº“数量（锁定记录计算）: {totalExpectedReturnQty}");

                // 4. éªŒè¯åº“存数量与锁定记录的一致性
                foreach (var lockInfo in lockInfos.Where(x => !string.IsNullOrEmpty(x.CurrentBarcode)))
                {
                    var stock = stockDetails.FirstOrDefault(x => x.Barcode == lockInfo.CurrentBarcode);
                    if (stock != null)
                    {
                        // å¦‚果锁定记录是已回库状态，对应的库存应该是入库完成状态
                        if (lockInfo.Status == (int)OutLockStockStatusEnum.已回库 &&
                            stock.Status != (int)StockStatusEmun.入库完成)
                        {
                            _logger.LogWarning($"锁定记录已回库但库存状态不正确 - æ¡ç : {lockInfo.CurrentBarcode}, åº“存状态: {GetStockStatusName(stock.Status)}");
                        }
                    }
                }

                _logger.LogInformation($"回库后数据验证完成");
            }
@@ -2253,7 +2988,6 @@
                _logger.LogError($"回库后验证失败: {ex.Message}");
            }
        }


        /// <summary>
        /// éªŒè¯å›žåº“前后数据一致性
@@ -2336,6 +3070,7 @@
                _ => $"未知({status})"
            };
        }

        /// <summary>
        /// ç®€åŒ–回库数据操作（当主方法失败时使用）
        /// </summary>
@@ -2345,22 +3080,51 @@

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

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

                foreach (var stockDetail in allStockDetails)
                {
                    // æ¢å¤æ‰€æœ‰åº“存状态为入库完成
                    if (stockDetail.Status == (int)StockStatusEmun.出库锁定)
                    // è®°å½•åŽŸå§‹çŠ¶æ€
                    int originalStatus = stockDetail.Status;
                    decimal originalStockQty = stockDetail.StockQuantity;

                    // å°†æ‰€æœ‰å‡ºåº“相关的状态恢复为入库完成
                    if (stockDetail.Status == (int)StockStatusEmun.出库锁定 ||
                        //stockDetail.Status == (int)StockStatusEmun.出库中 ||
                        stockDetail.Status == (int)StockStatusEmun.出库完成)
                    {
                        // å¦‚果是出库完成状态且库存为0，可能需要特殊处理
                        if (stockDetail.Status == (int)StockStatusEmun.出库完成 && stockDetail.StockQuantity == 0)
                        {
                            _logger.LogInformation($"跳过已出库完成的零库存条码: {stockDetail.Barcode}");
                            continue;
                        }

                        stockDetail.Status = (int)StockStatusEmun.入库完成;

                        // å¦‚果是出库锁定状态但库存为0，重置库存为1（避免零库存问题）
                        if (stockDetail.Status == (int)StockStatusEmun.出库锁定 && stockDetail.StockQuantity == 0)
                        {
                            // æŸ¥æ‰¾æ˜¯å¦æœ‰å¯¹åº”的锁定记录来确定应该恢复的数量
                            var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                                .Where(x => x.CurrentBarcode == stockDetail.Barcode &&
                                           x.StockId == stockDetail.StockId)
                                .FirstAsync();

                            if (lockInfo != null)
                            {
                                stockDetail.StockQuantity = lockInfo.AssignQuantity - lockInfo.PickedQty;
                                _logger.LogInformation($"恢复零库存条码的数量 - æ¡ç : {stockDetail.Barcode}, æ•°é‡: {stockDetail.StockQuantity}");
                            }
                        }

                        await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
                        _logger.LogInformation($"简化回库 - æ¡ç : {stockDetail.Barcode}, æ•°é‡: {stockDetail.StockQuantity}");
                        _logger.LogInformation($"简化回库 - æ¡ç : {stockDetail.Barcode}, çŠ¶æ€: {GetStockStatusName(originalStatus)} -> å…¥åº“完成, æ•°é‡: {originalStockQty} -> {stockDetail.StockQuantity}");
                    }
                }

@@ -2378,7 +3142,7 @@
                    lockInfo.Operator = App.User.UserName;

                    await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
                    _logger.LogInformation($"简化回库 - é”å®šè®°å½•: {lockInfo.Id}");
                    _logger.LogInformation($"简化回库 - é”å®šè®°å½•: {lockInfo.Id}, çŠ¶æ€: å·²å›žåº“");
                }

                _logger.LogInformation($"【简化回库】完成 - å¤„理 {allStockDetails.Count} ä¸ªæ¡ç , {allLocks.Count} æ¡é”å®šè®°å½•");
@@ -2389,6 +3153,25 @@
                throw;
            }
        }

        /// <summary>
        /// èŽ·å–库存状态名称
        /// </summary>
        private string GetStockStatusName(int status)
        {
            return status switch
            {
                1 => "入库确认",
                2 => "入库完成",
                3 => "出库锁定",
                4 => "出库中",
                5 => "出库完成",
                6 => "已清理",
                _ => $"未知({status})"
            };
        }


        /// <summary>
        /// æ‰§è¡Œå›žåº“数据操作 - ç®€åŒ–版本
        /// </summary>
@@ -2541,13 +3324,18 @@
                throw;
            }
        }


        /// <summary>
        /// å¤„理库存回库 - ç®€åŒ–逻辑
        /// å¤„理库存回库 - å®Œæ•´ä¿®æ­£ç‰ˆ
        /// ç¡®ä¿OutboundQuantity正确减少
        /// </summary>
        private async Task ProcessStockForReturn(string barcode, int stockId, decimal returnQty)
        {
            try
            {
                _logger.LogInformation($"处理库存回库 - æ¡ç : {barcode}, å›žåº“数量: {returnQty}");

                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .FirstAsync(x => x.Barcode == barcode && x.StockId == stockId);

@@ -2562,22 +3350,37 @@
                decimal originalOutboundQty = stockDetail.OutboundQuantity;
                int originalStatus = stockDetail.Status;

                // ç®€åŒ–处理：如果库存数量大于0，恢复为入库完成状态
                if (stockDetail.StockQuantity > 0)
                _logger.LogInformation($"回库前状态 - åº“å­˜: {originalStockQty}, å‡ºåº“: {originalOutboundQty}, çŠ¶æ€: {GetStockStatusName(originalStatus)}");

                // ã€æ ¸å¿ƒä¿®æ­£ã€‘确保回库操作正确处理
                // 1. åº“存数量增加（回库的货物回到库存）
                stockDetail.StockQuantity += returnQty;

                // 2. å‡ºåº“数量减少（因为货物没有出库，而是回库了）
                // ä½†éœ€è¦ç¡®ä¿ä¸ä¼šå‡ºçŽ°è´Ÿæ•°
                if (stockDetail.OutboundQuantity >= returnQty)
                {
                    stockDetail.Status = (int)StockStatusEmun.入库完成;
                    stockDetail.OutboundQuantity -= returnQty;
                }
                else
                {
                    // å¦‚果出库数量小于回库数量，说明数据异常
                    _logger.LogWarning($"出库数量({stockDetail.OutboundQuantity})小于回库数量({returnQty})，重置出库数量为0");
                    stockDetail.OutboundQuantity = 0;
                }

                // è°ƒæ•´å‡ºåº“数量（避免出现负数）
                if (stockDetail.OutboundQuantity > 0)
                {
                    stockDetail.OutboundQuantity = Math.Max(0, stockDetail.OutboundQuantity - returnQty);
                }
                // 3. æ›´æ–°çŠ¶æ€ä¸ºå…¥åº“完成
                stockDetail.Status = (int)StockStatusEmun.入库完成;

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

                _logger.LogInformation($"库存回库处理 - æ¡ç : {barcode}, çŠ¶æ€: {originalStatus} -> {stockDetail.Status}, " +
                                     $"库存: {originalStockQty} -> {stockDetail.StockQuantity}, " +
                                     $"出库: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
                _logger.LogInformation($"库存回库完成 - æ¡ç : {barcode}");
                _logger.LogInformation($"  åº“存数量: {originalStockQty} -> {stockDetail.StockQuantity}");
                _logger.LogInformation($"  å‡ºåº“数量: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
                _logger.LogInformation($"  çŠ¶æ€: {GetStockStatusName(originalStatus)} -> {GetStockStatusName(stockDetail.Status)}");

                // éªŒè¯å›žåº“后的数据
                await ValidateStockAfterReturn(barcode, stockId, returnQty);
            }
            catch (Exception ex)
            {
@@ -2585,6 +3388,35 @@
                throw;
            }
        }

        /// <summary>
        /// éªŒè¯å›žåº“后库存数据
        /// </summary>
        private async Task ValidateStockAfterReturn(string barcode, int stockId, decimal returnQty)
        {
            try
            {
                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .FirstAsync(x => x.Barcode == barcode && x.StockId == stockId);

                // æ£€æŸ¥å‡ºåº“数量是否为0或合理
                if (stockDetail.OutboundQuantity > stockDetail.StockQuantity)
                {
                    _logger.LogWarning($"回库后数据异常 - å‡ºåº“数量({stockDetail.OutboundQuantity})大于库存数量({stockDetail.StockQuantity})");
                }

                // æ£€æŸ¥çŠ¶æ€æ˜¯å¦æ­£ç¡®
                if (stockDetail.Status != (int)StockStatusEmun.入库完成)
                {
                    _logger.LogWarning($"回库后状态异常 - æœŸæœ›:入库完成, å®žé™…:{GetStockStatusName(stockDetail.Status)}");
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"验证回库后数据失败: {ex.Message}");
            }
        }

        /// <summary>
        /// ä¸ºé”å®šè®°å½•å‡å°‘订单明细的分配数量
        /// </summary>
@@ -2638,8 +3470,8 @@
        }

        /// <summary>
        /// å¤„理未分配的锁定记录回库
        /// ä¸éœ€è¦å‡å°‘订单明细的分配数量
        /// å¤„理未分配的锁定记录回库 - ä¿®æ­£ç‰ˆ
        /// æ³¨æ„ï¼šæœªåˆ†é…é”å®šè®°å½•æ²¡æœ‰ç»‘定订单明细，不需要减少订单明细的分配数量
        /// </summary>
        private async Task HandleUnallocatedLocksReturn(List<Dt_OutStockLockInfo> unallocatedLocks)
        {
@@ -2664,22 +3496,21 @@

                if (stockDetail != null)
                {
                    // æ¢å¤åº“存数量
                    // ã€ä¿®æ­£ã€‘恢复库存数量，出库数量保持不变（因为未分配锁定的出库数量本来就是0）
                    decimal originalStockQty = stockDetail.StockQuantity;
                    stockDetail.StockQuantity += returnQty;

                    // æ¢å¤åº“存状态
                    if (stockDetail.Status == (int)StockStatusEmun.出库完成)
                    {
                        stockDetail.Status = (int)StockStatusEmun.入库完成;
                    }
                    else if (stockDetail.Status == (int)StockStatusEmun.出库锁定)
                    // å‡ºåº“数量保持为0不变！
                    // stockDetail.OutboundQuantity = stockDetail.OutboundQuantity; // ä¿æŒä¸å˜

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

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

                // æ›´æ–°é”å®šè®°å½•çŠ¶æ€ä¸ºå·²å›žåº“
@@ -2927,8 +3758,7 @@
        /// </summary>

        /// <summary>
        /// åˆ†æžæ‰˜ç›˜çŠ¶æ€ç”¨äºŽå›žåº“ - å®Œæ•´ç‰ˆæœ¬
        /// ç¡®ä¿ä¸ä¼šé”™è¯¯è¯†åˆ«éœ€è¦å›žåº“的物品，避免重复计算
        /// åˆ†æžæ‰˜ç›˜çŠ¶æ€ç”¨äºŽå›žåº“ - ä¿®æ­£ç‰ˆï¼ˆè§£å†³æ‹†åŒ…记录重复计算问题）
        /// </summary>
        private async Task<PalletStatusAnalysis> AnalyzePalletStatusForReturn(string orderNo, string palletCode, int stockId)
        {
@@ -2938,250 +3768,158 @@
                PalletCode = palletCode,
                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>()
                ProcessedBarcodes = new HashSet<string>()
            };

            _logger.LogInformation($"开始分析托盘状态用于回库 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}, StockId: {stockId}");
            _logger.LogInformation($"【回库分析】开始分析托盘状态 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}, StockId: {stockId}");

            try
            {
                // 1. åˆ†æžæ‰€æœ‰é”å®šè®°å½•ï¼ˆçŠ¶æ€ä¸ºå‡ºåº“中）
                var allUnfinishedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderNo == orderNo &&
                               x.PalletCode == palletCode &&
                               x.Status == (int)OutLockStockStatusEnum.出库中)
                    .ToListAsync();

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

                    // åŒºåˆ†å·²åˆ†é…å’Œæœªåˆ†é…çš„锁定记录
                    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. åˆ†æžæ‰˜ç›˜ä¸Šçš„剩余库存货物（状态为出库锁定但未分配）
                // 1. é¦–先获取托盘上所有的库存明细（基础数据）
                var allStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockId &&
                               x.Status == (int)StockStatusEmun.出库锁定 &&
                               x.StockQuantity > 0)
                    .Where(x => x.StockId == stockId && x.StockQuantity > 0)
                    .ToListAsync();

                if (allStockDetails.Any())
                {
                    _logger.LogInformation($"找到 {allStockDetails.Count} ä¸ªå‡ºåº“锁定状态的库存货物");
                _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.已回库)
                // 2. åˆ†æžæ‰€æœ‰é”å®šè®°å½•ï¼ˆå·²åˆ†é…å’Œæœªåˆ†é…ï¼‰
                var allLockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
                    .ToListAsync();

                if (splitRecords.Any())
                // åŒºåˆ†å·²åˆ†é…å’Œæœªåˆ†é…é”å®šè®°å½•
                var allocatedLocks = allLockInfos
                    .Where(x => x.IsUnallocated != 1 && x.OrderDetailId > 0 &&
                               x.Status == (int)OutLockStockStatusEnum.出库中)
                    .ToList();

                var unallocatedLocks = allLockInfos
                    .Where(x => (x.IsUnallocated == 1 || x.OrderDetailId == 0) &&
                               x.Status == (int)OutLockStockStatusEnum.出库中)
                    .ToList();

                // å¤„理已分配锁定记录
                if (allocatedLocks.Any())
                {
                    result.HasSplitRecords = true;
                    result.SplitRecords = splitRecords;
                    result.HasRemainingLocks = true;
                    result.RemainingLocks = allocatedLocks;

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

                    foreach (var splitRecord in splitRecords)
                    // ã€ä¿®å¤ã€‘对于已分配锁定记录，回库数量是未拣选的部分
                    result.RemainingLocksReturnQty = allocatedLocks.Sum(x =>
                    {
                        // åŽŸæ¡ç 
                        if (!string.IsNullOrEmpty(splitRecord.OriginalBarcode) && !splitBarcodes.Contains(splitRecord.OriginalBarcode))
                        var returnQty = x.AssignQuantity - x.PickedQty;
                        return returnQty > 0 ? returnQty : 0;
                    });

                    foreach (var lockInfo in allocatedLocks)
                    {
                        if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode))
                        {
                            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}");
                            }
                            result.AllBarcodes.Add(lockInfo.CurrentBarcode);
                            result.ProcessedBarcodes.Add(lockInfo.CurrentBarcode);
                        }

                        // æ–°æ¡ç 
                        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}");
                    _logger.LogInformation($"发现 {allocatedLocks.Count} æ¡å·²åˆ†é…é”å®šè®°å½•ï¼Œå›žåº“数量: {result.RemainingLocksReturnQty}");
                }
                else

                // å¤„理未分配锁定记录（自动拆包产生的）
                if (unallocatedLocks.Any())
                {
                    _logger.LogInformation($"未找到需要回库的拆包记录");
                    result.HasUnallocatedLocks = true;
                    result.UnallocatedLocks = unallocatedLocks;

                    // ã€ä¿®å¤ã€‘对于未分配锁定记录，回库数量是它的分配数量（因为未拣选过）
                    // ä½†å®žé™…上，库存本来就存在，只是状态需要恢复
                    result.UnallocatedLocksReturnQty = unallocatedLocks.Sum(x => x.AssignQuantity);

                    foreach (var lockInfo in unallocatedLocks)
                    {
                        if (!string.IsNullOrEmpty(lockInfo.CurrentBarcode) &&
                            !result.ProcessedBarcodes.Contains(lockInfo.CurrentBarcode))
                        {
                            result.AllBarcodes.Add(lockInfo.CurrentBarcode);
                            result.ProcessedBarcodes.Add(lockInfo.CurrentBarcode);
                        }
                    }
                    _logger.LogInformation($"发现 {unallocatedLocks.Count} æ¡æœªåˆ†é…é”å®šè®°å½•ï¼Œå›žåº“数量（状态恢复）: {result.UnallocatedLocksReturnQty}");
                }

                // 4. è®¡ç®—总回库数量和空托盘状态
                result.TotalReturnQty = result.RemainingLocksReturnQty +
                                      result.UnallocatedLocksReturnQty +
                                      result.PalletStockReturnQty +
                                      result.SplitReturnQty;
                // 3. ã€é‡è¦ä¿®å¤ã€‘重新计算总回库数量
                // å¯¹äºŽå·²åˆ†é…é”å®šï¼šå›žåº“数量 = æœªæ‹£é€‰æ•°é‡
                // å¯¹äºŽæœªåˆ†é…é”å®šï¼šæ²¡æœ‰å®žé™…的库存数量变化，只是状态恢复
                result.TotalReturnQty = result.RemainingLocksReturnQty; // åªè®¡ç®—已分配锁定的回库数量

                result.HasItemsToReturn = result.TotalReturnQty > 0;
                // è®°å½•åº“存数量（用于验证）
                decimal totalStockOnPallet = allStockDetails.Sum(x => x.StockQuantity);

                _logger.LogInformation($"回库分析完成:");
                _logger.LogInformation($"  æ‰˜ç›˜æ€»åº“å­˜: {totalStockOnPallet}");
                _logger.LogInformation($"  å·²åˆ†é…é”å®šå›žåº“数量: {result.RemainingLocksReturnQty}");
                _logger.LogInformation($"  æœªåˆ†é…é”å®šçŠ¶æ€æ¢å¤æ•°é‡: {result.UnallocatedLocksReturnQty}");
                _logger.LogInformation($"  å®žé™…物理回库数量: {result.TotalReturnQty}");

                result.HasItemsToReturn = result.TotalReturnQty > 0 || result.UnallocatedLocksReturnQty > 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)
            {
                _logger.LogError($"托盘状态分析失败 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}, Error: {ex.Message}");
                _logger.LogError($"回库分析失败 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}, Error: {ex.Message}");
                throw;
            }
        }


        /// <summary>
        /// éªŒè¯æ²¡æœ‰é‡å¤æ¡ç 
        /// </summary>
        private async Task ValidateNoDuplicateBarcodes(PalletStatusAnalysis analysis, List<Dt_StockInfoDetail> allStockDetails)
        {
            try
            {
                // æ£€æŸ¥AllBarcodes中是否有重复
                var duplicateBarcodes = analysis.AllBarcodes
                    .GroupBy(b => b)
                    .Where(g => g.Count() > 1)
                    .Select(g => g.Key)
                    .ToList();

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

                    // è‡ªåŠ¨åŽ»é‡
                    analysis.AllBarcodes = analysis.AllBarcodes.Distinct().ToList();
                    _logger.LogWarning($"已自动去重，条码数: {analysis.AllBarcodes.Count}");
                }

                // æ£€æŸ¥æ¯ä¸ªæ¡ç çš„实际库存
                decimal totalStockFromBarcodes = 0;
                foreach (var barcode in analysis.AllBarcodes)
                {
                    var stock = allStockDetails.FirstOrDefault(x => x.Barcode == barcode);
                    if (stock != null)
                    {
                        totalStockFromBarcodes += stock.StockQuantity;
                        _logger.LogInformation($"条码库存 - {barcode}: {stock.StockQuantity}");
                    }
                }

                _logger.LogInformation($"回库分析总库存: {analysis.TotalReturnQty}, æ¡ç å®žé™…总库存: {totalStockFromBarcodes}");

                // å¦‚果分析的数量大于实际库存，说明有重复计算
                if (analysis.TotalReturnQty > totalStockFromBarcodes * 1.1m) // å…è®¸10%的误差
                {
                    _logger.LogError($"回库数量({analysis.TotalReturnQty})明显大于实际库存({totalStockFromBarcodes})，可能存在重复计算！");
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"验证重复条码失败: {ex.Message}");
            }
        }


        /// <summary>
        /// éªŒè¯åˆ†æžç»“果，确保数据一致性
@@ -3499,7 +4237,7 @@
        }

        /// <summary>
        /// å–走空箱 - å…ˆæ‰§è¡Œå›žåº“再清理
        /// å–走空箱 - ä¿®æ­£ç‰ˆï¼Œæ­£ç¡®å¤„理未分配锁定记录
        /// </summary>
        public async Task<WebResponseContent> RemoveEmptyPallet(string orderNo, string palletCode)
        {
@@ -3512,35 +4250,79 @@
                // 1. å…ˆå°è¯•æ‰§è¡Œå›žåº“操作，确保所有物品都回库
                _logger.LogInformation($"步骤1: å…ˆæ‰§è¡Œå›žåº“操作");
                var returnResult = await ExecutePalletReturn(orderNo, palletCode, "取走空箱前回库");

                // å³ä½¿å›žåº“失败，继续验证空箱条件（可能是真的空托盘）
                if (!returnResult.Status)
                {
                    // å›žåº“失败，可能是空托盘或者有其他问题
                    _logger.LogWarning($"回库操作失败: {returnResult.Message}");

                    // ç»§ç»­éªŒè¯ç©ºç®±å–走条件
                    _logger.LogWarning($"回库操作可能失败或无物品: {returnResult.Message}");
                }

                // 2. éªŒè¯ç©ºç®±å–走条件（必须全部完成拣选）
                // 2. éªŒè¯ç©ºç®±å–走条件（必须全部完成拣选或已回库）
                _logger.LogInformation($"步骤2: éªŒè¯ç©ºç®±å–走条件");
                var validationResult = await ValidateEmptyPalletRemoval(orderNo, palletCode);
                if (!validationResult.IsValid)

                // èŽ·å–托盘的所有锁定记录（包括已回库和已取走的）
                var allLockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
                    .ToListAsync();

                if (!allLockInfos.Any())
                {
                    _unitOfWorkManage.RollbackTran();
                    _logger.LogError($"空箱验证失败: {validationResult.ErrorMessage}");
                    return WebResponseContent.Instance.Error(validationResult.ErrorMessage);
                    return WebResponseContent.Instance.Error("该托盘没有锁定记录");
                }

                var completedLocks = validationResult.Data;
                // ã€ä¿®æ­£ã€‘检查是否有未完成的锁定记录
                var unfinishedLocks = allLockInfos.Where(x =>
                    x.Status == (int)OutLockStockStatusEnum.出库中 ||
                    x.Status == (int)OutLockStockStatusEnum.回库中).ToList();

                if (unfinishedLocks.Any())
                {
                    var unfinishedCount = unfinishedLocks.Count;
                    // åŒºåˆ†å·²åˆ†é…å’Œæœªåˆ†é…
                    var allocatedUnfinished = unfinishedLocks.Where(x => x.IsUnallocated != 1).ToList();
                    var unallocatedUnfinished = unfinishedLocks.Where(x => x.IsUnallocated == 1).ToList();

                    string errorMsg = $"托盘还有{unfinishedCount}条未完成记录";
                    if (allocatedUnfinished.Any()) errorMsg += $"，其中已分配{allocatedUnfinished.Count}条";
                    if (unallocatedUnfinished.Any()) errorMsg += $"，未分配{unallocatedUnfinished.Count}条";

                    errorMsg += "，不能取走空箱";

                    _unitOfWorkManage.RollbackTran();
                    return WebResponseContent.Instance.Error(errorMsg);
                }

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

                if (!completedLocks.Any())
                {
                    // æ£€æŸ¥æ˜¯å¦éƒ½æ˜¯å·²å›žåº“状态
                    var returnedLocks = allLockInfos.Where(x => x.Status == (int)OutLockStockStatusEnum.已回库).ToList();
                    if (returnedLocks.Any())
                    {
                        _logger.LogInformation($"所有锁定记录都已回库，可以取走空箱");
                        completedLocks = returnedLocks;
                    }
                    else
                    {
                        _unitOfWorkManage.RollbackTran();
                        return WebResponseContent.Instance.Error("该托盘没有已完成拣选或已回库的记录");
                    }
                }

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

                // 3. æ¸…理已完成的锁定记录（标记为已取走）
                _logger.LogInformation($"步骤3: æ¸…理锁定记录");
                foreach (var lockInfo in completedLocks)
                {
                    // åªå¤„理状态为拣选完成的记录（已取走的跳过）
                    if (lockInfo.Status == (int)OutLockStockStatusEnum.拣选完成)
                    // åªå¤„理状态不是已取走的记录
                    if (lockInfo.Status != (int)OutLockStockStatusEnum.已取走)
                    {
                        // æ ‡è®°é”å®šè®°å½•ä¸ºå·²å–èµ°
                        lockInfo.Status = (int)OutLockStockStatusEnum.已取走;
                        lockInfo.Operator = App.User.UserName;
                        await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();
@@ -3576,6 +4358,8 @@
                return WebResponseContent.Instance.Error($"取走空箱失败：{ex.Message}");
            }
        }


        /// <summary>
        /// æ”¶é›†éœ€è¦å›žåº“的条码
        /// </summary>
@@ -4304,9 +5088,6 @@

        #endregion




        #region éªŒè¯æ–¹æ³•
        private async Task<ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>> ValidatePickingRequest(
       string orderNo, string palletCode, string barcode)
@@ -4410,6 +5191,7 @@
                _logger.LogInformation($"跳过未分配锁定记录的自动拆包检查 - é”å®šID: {lockInfo.Id}");
                return null;
            }

            // æ£€æŸ¥æ˜¯å¦éœ€è¦è‡ªåŠ¨æ‹†åŒ…的条件：
            // 1. åº“存数量大于分配数量
            // 2. é”å®šä¿¡æ¯çŠ¶æ€ä¸ºå‡ºåº“中
@@ -4424,127 +5206,134 @@
            // è®¡ç®—拆包数量 = åº“存数量 - åˆ†é…æ•°é‡
            decimal splitQuantity = stockDetail.StockQuantity - lockInfo.AssignQuantity;

            _logger.LogInformation($"需要自动拆包 - åº“å­˜: {stockDetail.StockQuantity}, åˆ†é…: {lockInfo.AssignQuantity}, æ‹†åŒ…数量: {splitQuantity}");

            // æ‰§è¡Œè‡ªåŠ¨æ‹†åŒ…
            var splitResult = await ExecuteAutoSplitLogic(lockInfo, stockDetail, splitQuantity, palletCode);

            // å°†æ‹†åŒ…数量传递给调用方，用于验证
            if (splitResult != null && splitResult.Any())
            {
                // åœ¨è¿”回结果中携带拆包数量信息
                foreach (var result in splitResult)
                {
                    result.quantityTotal = splitQuantity.ToString("F2");
                }
            }

            return splitResult;
        }

        /// <summary>
        /// æ‰§è¡Œè‡ªåŠ¨æ‹†åŒ…逻辑
        /// ç¡®ä¿è‡ªåŠ¨æ‹†åŒ…不会影响回库逻辑
        /// æ‰§è¡Œè‡ªåŠ¨æ‹†åŒ…逻辑 - å®Œå…¨ä¿®æ­£ç‰ˆ
        /// åŽŸåˆ™ï¼šåªåˆ†ç¦»ç‰©ç†åº“存，不改变原订单的任何分配和出库数量
        /// </summary>
        private async Task<List<SplitResult>> ExecuteAutoSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
            decimal splitQuantity, string palletCode)
        {
            _logger.LogInformation($"开始执行自动拆包逻辑 - åŽŸæ¡ç : {stockDetail.Barcode}, æ‹†åŒ…数量: {splitQuantity}");

            // éªŒè¯æ‹†åŒ…数量合理性
            if (splitQuantity <= 0)
            try
            {
                throw new InvalidOperationException($"拆包数量必须大于0，当前值: {splitQuantity}");
                // 1. éªŒè¯æ‹†åŒ…数量合理性
                if (splitQuantity <= 0)
                    throw new InvalidOperationException($"拆包数量必须大于0，当前值: {splitQuantity}");

                if (stockDetail.StockQuantity < lockInfo.AssignQuantity + splitQuantity)
                    throw new InvalidOperationException($"库存数量不足以进行自动拆包，库存: {stockDetail.StockQuantity}, éœ€è¦: {lockInfo.AssignQuantity + splitQuantity}");

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

                // 3. ã€æ ¸å¿ƒä¿®æ­£ã€‘更新原库存明细：只减少物理库存，不影响出库数量
                decimal originalStockQty = stockDetail.StockQuantity;
                stockDetail.StockQuantity -= splitQuantity; // ä»…库存减少
                                                            // stockDetail.OutboundQuantity ä¿æŒä¸å˜ï¼

                await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
                _logger.LogInformation($"更新原库存明细：条码 {stockDetail.Barcode} åº“å­˜ {originalStockQty} -> {stockDetail.StockQuantity}，出库数量不变({stockDetail.OutboundQuantity})");

                // 4. åˆ›å»ºæ–°åº“存明细（多余部分）- å‡ºåº“数量为0
                var newStockDetail = new Dt_StockInfoDetail
                {
                    StockId = stockDetail.StockId,
                    MaterielCode = stockDetail.MaterielCode,
                    OrderNo = stockDetail.OrderNo,
                    BatchNo = stockDetail.BatchNo,
                    StockQuantity = splitQuantity, // æ–°åº“存数量
                    OutboundQuantity = 0, // ã€é‡ç‚¹ã€‘初始出库数量为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}，出库 0");

                // 5. åˆ›å»ºæ–°é”å®šä¿¡æ¯ - æ ‡è®°ä¸ºæœªåˆ†é…
                var newLockInfo = new Dt_OutStockLockInfo
                {
                    OrderNo = lockInfo.OrderNo,
                    OrderDetailId = 0, // ã€é‡ç‚¹ã€‘不绑定到具体订单明细，表示未分配
                    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,
                    IsUnallocated = 1 // ã€é‡ç‚¹ã€‘明确标记为"未分配"的锁定记录
                };

                await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();
                _logger.LogInformation($"创建未分配锁定记录：ID {newLockInfo.Id}，条码 {newBarcode}，数量 {splitQuantity}");

                // 6. ã€å…³é”®ä¿®æ­£ã€‘原锁定记录和原订单明细数据完全保持不变！
                // - ä¸ä¿®æ”¹ lockInfo çš„任何字段
                // - ä¸ä¿®æ”¹å…³è”çš„ Dt_OutboundOrderDetail çš„ AllocatedQuantity å’Œ LockQuantity

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

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

                _logger.LogInformation($"自动拆包逻辑执行完成 - åˆ›å»ºäº†æœªåˆ†é…çš„库存和锁定记录");

                return splitResults;
            }

            if (stockDetail.StockQuantity < lockInfo.AssignQuantity + splitQuantity)
            catch (Exception ex)
            {
                throw new InvalidOperationException($"库存数量不足以进行自动拆包");
                _logger.LogError($"自动拆包逻辑执行失败 - åŽŸæ¡ç : {stockDetail.Barcode}, Error: {ex.Message}");
                throw;
            }

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

            // è®°å½•æ‹†åŒ…前的分配数量
            decimal originalAssignQty = lockInfo.AssignQuantity;
            decimal remainQty = originalAssignQty; // åŽŸé”å®šä¿¡æ¯åˆ†é…æ•°é‡ä¿æŒä¸å˜

            // åˆ›å»ºæ–°åº“存明细（多余部分）
            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}");

            // åˆ›å»ºæ–°é”å®šä¿¡æ¯ï¼ˆå¤šä½™éƒ¨åˆ†ï¼‰- æ ‡è®°ä¸ºæœªåˆ†é…
            var newLockInfo = new Dt_OutStockLockInfo
            {
                OrderNo = lockInfo.OrderNo,
                OrderDetailId = 0, // é‡è¦ï¼šä¸ç»‘定到具体订单明细
                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,
                IsUnallocated = 1 // æ ‡è®°ä¸ºæœªåˆ†é…
            };

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

            // é‡è¦ï¼šè‡ªåŠ¨æ‹†åŒ…需要增加订单明细的分配数量和锁定数量
            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);

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

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

            return splitResults;
        }

        /// <summary>
        /// éªŒè¯è‡ªåŠ¨æ‹†åŒ…后数据一致性
        /// éªŒè¯è‡ªåŠ¨æ‹†åŒ…后数据一致性 - ä¿®æ­£ç‰ˆ
        /// åŽŸåˆ™ï¼šéªŒè¯æœªåˆ†é…é”å®šè®°å½•çš„创建，而不是订单明细数量的变化
        /// </summary>
        private async Task ValidateDataConsistencyAfterAutoSplit(long orderDetailId, decimal originalAllocatedQty, decimal originalLockQty, decimal splitQuantity)
        {
@@ -4555,60 +5344,104 @@
            if (orderDetail == null)
                return;

            // è®¡ç®—所有锁定信息的总分配数量
            var allLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderDetailId == orderDetailId)
                .ToListAsync();

            decimal totalLockAssignQty = allLocks.Sum(x => x.AssignQuantity);

            _logger.LogInformation($"自动拆包后数据一致性验证 - è®¢å•æ˜Žç»†åˆ†é…æ•°é‡: {orderDetail.AllocatedQuantity}, é”å®šä¿¡æ¯æ€»åˆ†é…æ•°é‡: {totalLockAssignQty}");

            // éªŒè¯è‡ªåŠ¨æ‹†åŒ…后的数据一致性
            decimal expectedAllocatedQty = originalAllocatedQty + splitQuantity;
            decimal expectedLockQty = originalLockQty + splitQuantity;

            if (Math.Abs(orderDetail.AllocatedQuantity - expectedAllocatedQty) > 0.01m)
            // ã€ä¿®æ­£ã€‘自动拆包后，订单明细分配数量应该保持不变！
            if (Math.Abs(orderDetail.AllocatedQuantity - originalAllocatedQty) > 0.01m)
            {
                _logger.LogWarning($"自动拆包后分配数量异常 - æœŸæœ›: {expectedAllocatedQty}, å®žé™…: {orderDetail.AllocatedQuantity}");
                _logger.LogError($"自动拆包后订单明细分配数量异常变化！期望保持不变: {originalAllocatedQty}, å®žé™…: {orderDetail.AllocatedQuantity}");
                // è®°å½•ä¸¥é‡é”™è¯¯ï¼Œä½†ä¸æŠ›å‡ºå¼‚常（生产环境可能需要告警）
            }

            if (Math.Abs(orderDetail.LockQuantity - expectedLockQty) > 0.01m)
            if (Math.Abs(orderDetail.LockQuantity - originalLockQty) > 0.01m)
            {
                _logger.LogWarning($"自动拆包后锁定数量异常 - æœŸæœ›: {expectedLockQty}, å®žé™…: {orderDetail.LockQuantity}");
                _logger.LogError($"自动拆包后订单明细锁定数量异常变化！期望保持不变: {originalLockQty}, å®žé™…: {orderDetail.LockQuantity}");
            }

            if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
            // éªŒè¯æœªåˆ†é…é”å®šè®°å½•çš„创建
            // æŸ¥æ‰¾çˆ¶é”å®šè®°å½•
            var parentLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .FirstAsync(x => x.OrderDetailId == orderDetailId);

            if (parentLockInfo != null)
            {
                _logger.LogWarning($"自动拆包后数据不一致 - è®¢å•æ˜Žç»†åˆ†é…æ•°é‡: {orderDetail.AllocatedQuantity}, é”å®šä¿¡æ¯æ€»åˆ†é…æ•°é‡: {totalLockAssignQty}");
                // æŸ¥æ‰¾æœªåˆ†é…çš„子锁定记录（自动拆包生成的）
                var unallocatedChildLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.ParentLockId == parentLockInfo.Id &&
                               x.IsUnallocated == 1 &&
                               x.OrderDetailId == 0)
                    .ToListAsync();

                if (unallocatedChildLocks.Any())
                {
                    decimal totalUnallocatedQty = unallocatedChildLocks.Sum(x => x.AssignQuantity);
                    _logger.LogInformation($"验证通过：创建了{unallocatedChildLocks.Count}条未分配锁定记录，总数量: {totalUnallocatedQty}");

                    if (Math.Abs(totalUnallocatedQty - splitQuantity) > 0.01m)
                    {
                        _logger.LogWarning($"未分配锁定记录总数量与拆包数量不匹配，拆包数量: {splitQuantity}, æœªåˆ†é…æ€»æ•°: {totalUnallocatedQty}");
                    }
                }
                else
                {
                    _logger.LogWarning($"未找到自动拆包生成的未分配锁定记录");
                }
            }

            _logger.LogInformation($"自动拆包数据一致性验证完成");
        }

        #endregion

        #region æ ¸å¿ƒé€»è¾‘方法

        /// <summary>
        /// æ‰§è¡Œåˆ†æ‹£é€»è¾‘ - å®Œå…¨ä¿®æ­£ç‰ˆ
        /// ç¡®ä¿OutboundQuantity准确累加，不包含拆包数量
        /// </summary>
        private async Task<PickingResult> ExecutePickingLogic(
            Dt_OutStockLockInfo lockInfo, Dt_OutboundOrderDetail orderDetail,
            Dt_StockInfoDetail stockDetail, decimal actualPickedQty)
        {
            _logger.LogInformation($"开始执行分拣逻辑 - æ¡ç : {stockDetail.Barcode}, åˆ†é…æ•°é‡: {lockInfo.AssignQuantity}, å®žé™…拣选: {actualPickedQty}");

            // å†æ¬¡éªŒè¯è®¢å•æ˜Žç»†çš„分配数量（防止并发操作）
            if (orderDetail.AllocatedQuantity < actualPickedQty)
            // å†æ¬¡éªŒè¯åº“存数量
            if (stockDetail.StockQuantity < actualPickedQty)
            {
                throw new InvalidOperationException($"订单明细分配数量不足，需要拣选 {actualPickedQty}，可用分配数量 {orderDetail.AllocatedQuantity}");
                throw new InvalidOperationException($"库存数量不足，需要拣选 {actualPickedQty}，实际库存 {stockDetail.StockQuantity}");
            }

            if (orderDetail.LockQuantity < actualPickedQty)
            // è®°å½•æ‹£é€‰å‰çš„值
            decimal originalStockQty = stockDetail.StockQuantity;
            decimal originalOutboundQty = stockDetail.OutboundQuantity;
            int originalStatus = stockDetail.Status;

            // ã€æ ¸å¿ƒä¿®æ­£ã€‘确保OutboundQuantity只增加本次拣选数量，不包含其他
            stockDetail.StockQuantity -= actualPickedQty;
            stockDetail.OutboundQuantity += actualPickedQty;  // åªå¢žåŠ æœ¬æ¬¡æ‹£é€‰æ•°é‡

            _logger.LogInformation($"更新库存信息 - æ¡ç : {stockDetail.Barcode}");
            _logger.LogInformation($"  åº“存数量: {originalStockQty} -> {stockDetail.StockQuantity}");
            _logger.LogInformation($"  å‡ºåº“数量: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");

            // æ›´æ–°åº“存状态
            if (stockDetail.StockQuantity <= 0)
            {
                throw new InvalidOperationException($"订单明细锁定数量不足，需要拣选 {actualPickedQty}，可用锁定数量 {orderDetail.LockQuantity}");
                stockDetail.Status = (int)StockStatusEmun.出库完成;
                _logger.LogInformation($"库存状态更新为出库完成");
            }
            else
            {
                stockDetail.Status = (int)StockStatusEmun.出库锁定;
                _logger.LogInformation($"库存状态保持为出库锁定");
            }

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

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

            // å‡†ç¡®åˆ¤æ–­æ‹£é€‰å®ŒæˆçŠ¶æ€
            // åˆ¤æ–­æ‹£é€‰å®ŒæˆçŠ¶æ€
            if (Math.Abs(lockInfo.PickedQty - lockInfo.AssignQuantity) < 0.001m)
            {
                lockInfo.Status = (int)OutLockStockStatusEnum.拣选完成;
@@ -4623,29 +5456,8 @@
            lockInfo.Operator = App.User.UserName;
            await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

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

            stockDetail.StockQuantity -= actualPickedQty;
            stockDetail.OutboundQuantity += actualPickedQty;

            _logger.LogInformation($"更新库存信息 - åº“存数量从 {originalStockQty} å‡å°‘到 {stockDetail.StockQuantity}");
            _logger.LogInformation($"更新库存信息 - å‡ºåº“数量从 {originalOutboundQty} å¢žåŠ åˆ° {stockDetail.OutboundQuantity}");

            // å‡†ç¡®åˆ¤æ–­åº“存状态
            if (stockDetail.StockQuantity <= 0)
            {
                stockDetail.Status = (int)StockStatusEmun.出库完成;
                _logger.LogInformation($"库存状态更新为出库完成");
            }
            else
            {
                stockDetail.Status = (int)StockStatusEmun.出库锁定;
                _logger.LogInformation($"库存状态保持为出库锁定");
            }

            await _stockInfoDetailService.Db.Updateable(stockDetail).ExecuteCommandAsync();
            // éªŒè¯æ‹£é€‰åŽçš„数据一致性
            await ValidatePickingDataConsistency(lockInfo, stockDetail, actualPickedQty);

            _logger.LogInformation($"分拣逻辑执行完成 - æ¡ç : {stockDetail.Barcode}");

@@ -4654,6 +5466,40 @@
                FinalLockInfo = lockInfo,
                ActualPickedQty = actualPickedQty
            };
        }

        /// <summary>
        /// éªŒè¯æ‹£é€‰åŽæ•°æ®ä¸€è‡´æ€§
        /// </summary>
        private async Task ValidatePickingDataConsistency(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail, decimal pickedQty)
        {
            _logger.LogInformation($"验证拣选数据一致性 - æ¡ç : {stockDetail.Barcode}");

            // 1. éªŒè¯åº“存明细的OutboundQuantity增加量等于拣选数量
            var refreshedStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                .FirstAsync(x => x.Id == stockDetail.Id);

            decimal outboundIncrease = refreshedStockDetail.OutboundQuantity - stockDetail.OutboundQuantity;

            if (Math.Abs(outboundIncrease - pickedQty) > 0.01m)
            {
                _logger.LogError($"拣选数据不一致：出库数量增加 {outboundIncrease}，但拣选数量是 {pickedQty}");
                // ä¿®å¤ï¼šç¡®ä¿OutboundQuantity正确
                refreshedStockDetail.OutboundQuantity = stockDetail.OutboundQuantity + pickedQty;
                await _stockInfoDetailService.Db.Updateable(refreshedStockDetail).ExecuteCommandAsync();
                _logger.LogWarning($"已修复出库数量：{stockDetail.OutboundQuantity} -> {refreshedStockDetail.OutboundQuantity}");
            }

            // 2. éªŒè¯é”å®šè®°å½•çš„已拣选数量
            var refreshedLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .FirstAsync(x => x.Id == lockInfo.Id);

            if (Math.Abs(refreshedLockInfo.PickedQty - (lockInfo.PickedQty - pickedQty) - pickedQty) > 0.01m)
            {
                _logger.LogError($"锁定记录已拣选数量不一致");
            }

            _logger.LogInformation($"拣选数据一致性验证通过");
        }

        private async Task<RevertPickingResult> RevertPickingData(Dt_PickingRecord pickingRecord)
@@ -4746,59 +5592,85 @@

        #region æ•°æ®æ›´æ–°æ–¹æ³•

        /// <summary>
        /// æ›´æ–°æ‰¹æ¬¡å’Œè®¢å•æ•°æ® - ä¿®æ­£ç‰ˆ
        /// ç¡®ä¿åªæ›´æ–°å®žé™…的拣选数量
        /// </summary>
        private async Task UpdateBatchAndOrderData(Dt_OutboundBatch batch, Dt_OutboundOrderDetail orderDetail, decimal pickedQty, string orderNo)
        {
            _logger.LogInformation($"开始更新批次和订单数据 - æ‹£é€‰æ•°é‡: {pickedQty}");
            var latestOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>().FirstAsync(x => x.Id == orderDetail.Id);

            // é‡æ–°èŽ·å–最新数据（防止并发问题）
            var latestOrderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                .FirstAsync(x => x.Id == orderDetail.Id);

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

            orderDetail = latestOrderDetail;
            // éªŒè¯åˆ†é…æ•°é‡ä¸ä¼šå˜æˆè´Ÿæ•°
            if (orderDetail.AllocatedQuantity < pickedQty)

            // éªŒè¯æ‹£é€‰æ•°é‡åˆç†æ€§
            if (pickedQty <= 0)
            {
                decimal actualPickedQty = orderDetail.AllocatedQuantity;
                _logger.LogWarning($"分配数量不足，调整拣选数量 - åŽŸéœ€è¦: {pickedQty}, å®žé™…可用: {actualPickedQty}");
                pickedQty = actualPickedQty;
                _logger.LogWarning($"拣选数量无效: {pickedQty}");
                return;
            }

            if (orderDetail.LockQuantity < pickedQty)
            {
                decimal actualPickedQty = orderDetail.LockQuantity;
                _logger.LogWarning($"锁定数量不足，调整拣选数量 - åŽŸéœ€è¦: {pickedQty}, å®žé™…可用: {actualPickedQty}");
                pickedQty = actualPickedQty;
            }

            // 1. æ›´æ–°æ‰¹æ¬¡å®Œæˆæ•°é‡
            decimal originalBatchCompletedQty = batch.CompletedQuantity;
            batch.CompletedQuantity += pickedQty;

            _logger.LogInformation($"更新批次完成数量 - ä»Ž {originalBatchCompletedQty} å¢žåŠ åˆ° {batch.CompletedQuantity}");

            if (batch.CompletedQuantity >= batch.BatchQuantity)
            {
                batch.BatchStatus = (int)BatchStatusEnum.已完成;
                _logger.LogInformation($"批次状态更新为已完成");
            }
            await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();

            // æ›´æ–°è®¢å•æ˜Žç»†
            // è®°å½•åŽŸå§‹å€¼
            decimal originalOverOutQty = orderDetail.OverOutQuantity;
            decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
            decimal originalLockQty = orderDetail.LockQuantity;

            orderDetail.OverOutQuantity += pickedQty;
            orderDetail.AllocatedQuantity -= pickedQty;
            // LockQuantity åŒæ­¥å‡å°‘
            orderDetail.LockQuantity = orderDetail.AllocatedQuantity;
            if (orderDetail.AllocatedQuantity < 0) orderDetail.AllocatedQuantity = 0;
            if (orderDetail.LockQuantity < 0) orderDetail.LockQuantity = 0;
            _logger.LogInformation($"更新订单明细 - å·²å‡ºåº“数量从 {originalOverOutQty} å¢žåŠ åˆ° {orderDetail.OverOutQuantity}");
            _logger.LogInformation($"更新订单明细 - å·²åˆ†é…æ•°é‡ä»Ž {originalAllocatedQty} å‡å°‘到 {orderDetail.AllocatedQuantity}");
            _logger.LogInformation($"更新订单明细 - é”å®šæ•°é‡ä»Ž {originalLockQty} å‡å°‘到 {orderDetail.LockQuantity}");
            // æ›´æ–°è®¢å•æ˜Žç»†
            orderDetail.OverOutQuantity += pickedQty;  // å·²å‡ºåº“数量增加
            orderDetail.AllocatedQuantity -= pickedQty;  // å·²åˆ†é…æ•°é‡å‡å°‘
            orderDetail.LockQuantity -= pickedQty;  // é”å®šæ•°é‡å‡å°‘

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

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

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

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

            _logger.LogInformation($"更新订单明细成功");
            _logger.LogInformation($"  å·²å‡ºåº“数量: {originalOverOutQty} -> {orderDetail.OverOutQuantity}");
            _logger.LogInformation($"  å·²åˆ†é…æ•°é‡: {originalAllocatedQty} -> {orderDetail.AllocatedQuantity}");
            _logger.LogInformation($"  é”å®šæ•°é‡: {originalLockQty} -> {orderDetail.LockQuantity}");

            // æ›´æ–°æ‰¹æ¬¡å®Œæˆæ•°é‡
            if (batch != null)
            {
                decimal originalBatchCompletedQty = batch.CompletedQuantity;
                batch.CompletedQuantity += pickedQty;

                _logger.LogInformation($"更新批次完成数量 - ä»Ž {originalBatchCompletedQty} å¢žåŠ åˆ° {batch.CompletedQuantity}");

                // æ›´æ–°æ‰¹æ¬¡çŠ¶æ€
                if (batch.CompletedQuantity >= batch.BatchQuantity)
                {
                    batch.BatchStatus = (int)BatchStatusEnum.已完成;
                    _logger.LogInformation($"批次状态更新为已完成");
                }
                else if (batch.CompletedQuantity > 0)
                {
                    batch.BatchStatus = (int)BatchStatusEnum.执行中;
                    _logger.LogInformation($"批次状态更新为执行中");
                }

                await _outboundBatchRepository.Db.Updateable(batch).ExecuteCommandAsync();
            }

            // æ£€æŸ¥è®¢å•çŠ¶æ€
            await CheckAndUpdateOrderStatus(orderNo);
@@ -5071,7 +5943,6 @@
            }
        }


        #region è¾…助方法

        private async Task<string> GenerateNewBarcode()
@@ -5159,7 +6030,6 @@
            };
        }
        #endregion


        #region DTOç±»
        /// <summary>