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

heshaofeng

10 天以前 48710581fbbdd40eb3a743d91fa04e81531ba2ab

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

@@ -21,6 +21,7 @@
using WIDESEA_IBasicService;
using WIDESEA_IOutboundService;
using WIDESEA_IStockService;
using WIDESEA_ITaskInfoService;
using WIDESEA_Model.Models;
using WIDESEA_Model.Models.Basic;
using WIDESEA_Model.Models.Outbound;
@@ -49,6 +50,7 @@
        private readonly IDailySequenceService _dailySequenceService;
        private readonly IAllocateService _allocateService;
        private readonly IRepository<Dt_OutboundBatch> _outboundBatchRepository;
        private readonly ITask_HtyService _task_HtyService;
        private readonly ILogger<OutboundPickingService> _logger;

        private Dictionary<string, string> stations = new Dictionary<string, string>
@@ -68,7 +70,7 @@
        public OutboundBatchPickingService(IRepository<Dt_PickingRecord> BaseDal, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, IStockService stockService,
            IOutStockLockInfoService outStockLockInfoService, IStockInfoDetailService stockInfoDetailService, ILocationInfoService locationInfoService,
            IOutboundOrderDetailService outboundOrderDetailService, ISplitPackageService splitPackageService, IOutboundOrderService outboundOrderService,
            IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger, IInvokeMESService invokeMESService, IDailySequenceService dailySequenceService, IAllocateService allocateService, IRepository<Dt_OutboundBatch> outboundBatchRepository) : base(BaseDal)
            IRepository<Dt_Task> taskRepository, IESSApiService eSSApiService, ILogger<OutboundPickingService> logger, IInvokeMESService invokeMESService, IDailySequenceService dailySequenceService, IAllocateService allocateService, IRepository<Dt_OutboundBatch> outboundBatchRepository, ITask_HtyService task_HtyService) : base(BaseDal)
        {
            _unitOfWorkManage = unitOfWorkManage;
            _stockInfoService = stockInfoService;
@@ -86,6 +88,7 @@
            _dailySequenceService = dailySequenceService;
            _allocateService = allocateService;
            _outboundBatchRepository = outboundBatchRepository;
            _task_HtyService = task_HtyService;
        }

        // <summary>
@@ -395,6 +398,26 @@
                    $"托盘还有{unfinishedCount}条未完成记录，剩余数量{unfinishedQty}，不能取走空箱");
            }

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

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

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

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



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

@@ -597,21 +620,21 @@

            _logger.LogInformation($"找到库存信息 - åº“存数量: {stockDetail.StockQuantity}, å‡ºåº“数量: {stockDetail.OutboundQuantity}");

            // é‡è¦ä¿®å¤ï¼šéªŒè¯æ‹†åŒ…数量不能大于库存数量
            // éªŒè¯æ‹†åŒ…数量不能大于库存数量
            if (stockDetail.StockQuantity < splitQuantity)
            {
                _logger.LogWarning($"拆包数量大于库存数量 - æ‹†åŒ…数量: {splitQuantity}, åº“存数量: {stockDetail.StockQuantity}");
                return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error($"拆包数量不能大于库存数量，当前库存：{stockDetail.StockQuantity}");
            }

            // é‡è¦ä¿®å¤ï¼šéªŒè¯æ‹†åŒ…数量不能大于锁定信息的分配数量
            // éªŒè¯æ‹†åŒ…数量不能大于锁定信息的分配数量
            if (lockInfo.AssignQuantity < splitQuantity)
            {
                _logger.LogWarning($"拆包数量大于分配数量 - æ‹†åŒ…数量: {splitQuantity}, åˆ†é…æ•°é‡: {lockInfo.AssignQuantity}");
                return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error($"拆包数量不能大于分配数量，当前分配数量：{lockInfo.AssignQuantity}");
            }

            // é‡è¦ä¿®å¤ï¼šéªŒè¯æ‹†åŒ…数量不能大于锁定信息的未拣选数量
            // éªŒè¯æ‹†åŒ…数量不能大于锁定信息的未拣选数量
            decimal remainingToPick = lockInfo.AssignQuantity - lockInfo.PickedQty;
            if (remainingToPick < splitQuantity)
            {
@@ -619,14 +642,14 @@
                return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error($"拆包数量不能大于未拣选数量，当前未拣选：{remainingToPick}");
            }

            // é‡è¦ä¿®å¤ï¼šéªŒè¯æ‹†åŒ…后原锁定信息的分配数量不会为负数
            // éªŒè¯æ‹†åŒ…后原锁定信息的分配数量不会为负数
            if (lockInfo.AssignQuantity - splitQuantity < 0)
            {
                _logger.LogWarning($"拆包后分配数量为负数 - å½“前分配数量: {lockInfo.AssignQuantity}, æ‹†åŒ…数量: {splitQuantity}");
                return ValidationResult<(Dt_OutStockLockInfo, Dt_StockInfoDetail)>.Error($"拆包后分配数量不能为负数");
            }

            // é‡è¦ä¿®å¤ï¼šéªŒè¯è®¢å•æ˜Žç»†çš„分配数量是否足够
            // éªŒè¯è®¢å•æ˜Žç»†çš„分配数量是否足够
            // æ³¨æ„ï¼šæ‰‹åŠ¨æ‹†åŒ…不会改变订单明细的分配数量，因为总分配数量不变
            // åªæ˜¯ä»Žä¸€ä¸ªé”å®šä¿¡æ¯è½¬ç§»åˆ°å¦ä¸€ä¸ªé”å®šä¿¡æ¯
            decimal totalLockAssignQuantity = await GetTotalLockAssignQuantity(orderDetail.Id);
@@ -661,14 +684,7 @@
        {
            _logger.LogInformation($"开始执行手动拆包逻辑 - åŽŸæ¡ç : {stockDetail.Barcode}, æ‹†åŒ…数量: {splitQuantity}");

            // é‡è¦ä¿®å¤ï¼šèŽ·å–订单明细并验证分配数量
            var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                .FirstAsync(x => x.Id == lockInfo.OrderDetailId);

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

            // éªŒè¯æ‹†åŒ…数量不会导致分配数量为负数
            // éªŒè¯æ‹†åŒ…数量
            if (lockInfo.AssignQuantity < splitQuantity)
            {
                throw new InvalidOperationException($"拆包数量超过锁定信息分配数量，拆包数量: {splitQuantity}, åˆ†é…æ•°é‡: {lockInfo.AssignQuantity}");
@@ -677,15 +693,10 @@
            // ç”Ÿæˆæ–°æ¡ç 
            string newBarcode = await GenerateNewBarcode();

            // è®°å½•æ‹†åŒ…前的分配数量
            decimal originalAssignQtyBefore = lockInfo.AssignQuantity;
            decimal originalOrderQtyBefore = lockInfo.OrderQuantity;
            decimal remainQty = originalAssignQtyBefore - splitQuantity;
            if (remainQty < 0)
            {
                throw new InvalidOperationException($"拆包后剩余数量为负数，原分配数量: {originalAssignQtyBefore}, æ‹†åŒ…数量: {splitQuantity}");
            }
            //  åˆ›å»ºæ–°åº“存明细
            // è®¡ç®—剩余数量
            decimal remainQty = lockInfo.AssignQuantity - splitQuantity;

            // åˆ›å»ºæ–°åº“存明细
            var newStockDetail = new Dt_StockInfoDetail
            {
                StockId = stockDetail.StockId,
@@ -704,24 +715,17 @@
                InboundOrderRowNo = stockDetail.InboundOrderRowNo,
            };
            await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
            _logger.LogInformation($"创建新库存明细 - æ¡ç : {newBarcode}, åº“存数量: {splitQuantity}");

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

            //   åˆ›å»ºæ–°é”å®šä¿¡æ¯
            // åˆ›å»ºæ–°é”å®šä¿¡æ¯
            var newLockInfo = new Dt_OutStockLockInfo
            {
                OrderNo = lockInfo.OrderNo,
                OrderDetailId = lockInfo.OrderDetailId,
                OrderDetailId = lockInfo.OrderDetailId, // ç»‘定到同一个订单明细
                OutboundBatchNo = lockInfo.OutboundBatchNo,
                MaterielCode = lockInfo.MaterielCode,
                MaterielName = lockInfo.MaterielName,
@@ -748,31 +752,64 @@
            };

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

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

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

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

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

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

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

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

            return splitResults;
        }
 
        /// <summary>
        /// éªŒè¯æ‹†åŒ…后数据一致性
        /// </summary>
        private async Task ValidateDataConsistencyAfterSplit(long orderDetailId, decimal expectedAllocatedQty, decimal expectedLockQty)
        {
            // é‡æ–°èŽ·å–订单明细数据
            var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                .FirstAsync(x => x.Id == orderDetailId);

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

            // å¦‚果数据不一致，记录警告
            if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
            {
                _logger.LogWarning($"数据不一致 - è®¢å•æ˜Žç»†åˆ†é…æ•°é‡: {orderDetail.AllocatedQuantity}, é”å®šä¿¡æ¯æ€»åˆ†é…æ•°é‡: {totalLockAssignQty}");
            }

            // éªŒè¯åˆ†é…æ•°é‡æ²¡æœ‰å¼‚常变化
            if (Math.Abs(orderDetail.AllocatedQuantity - expectedAllocatedQty) > 0.01m)
            {
                _logger.LogWarning($"分配数量异常变化 - æœŸæœ›: {expectedAllocatedQty}, å®žé™…: {orderDetail.AllocatedQuantity}");
            }

            if (Math.Abs(orderDetail.LockQuantity - expectedLockQty) > 0.01m)
            {
                _logger.LogWarning($"锁定数量异常变化 - æœŸæœ›: {expectedLockQty}, å®žé™…: {orderDetail.LockQuantity}");
            }
        }
        #endregion


@@ -833,16 +870,37 @@
        {
            _logger.LogInformation($"开始执行取消拆包逻辑 - åŽŸæ¡ç : {splitRecord.OriginalBarcode}, æ–°æ¡ç : {splitRecord.NewBarcode}, æ‹†åŒ…数量: {splitRecord.SplitQty}");

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

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

            // è®°å½•å–消拆包前的关键数据
            decimal originalOrderDetailAllocatedQty = orderDetail.AllocatedQuantity;
            decimal originalOrderDetailLockQty = orderDetail.LockQuantity;

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

            // æ¢å¤åŽŸé”å®šä¿¡æ¯
            decimal originalAssignQtyBefore = originalLockInfo.AssignQuantity;
            decimal originalOrderQtyBefore = originalLockInfo.OrderQuantity;

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

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

            // å¦‚果原锁定信息的状态是拣选完成，需要重新设置为出库中
            if (originalLockInfo.Status == (int)OutLockStockStatusEnum.拣选完成)
@@ -859,34 +917,67 @@

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

                _logger.LogInformation($"恢复原库存明细 - åº“存数量从 {originalStockQtyBefore} å¢žåŠ åˆ° {originalStock.StockQuantity}");

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

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

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

                    await _stockInfoDetailService.Db.Updateable(originalStock).ExecuteCommandAsync();
                }
            }

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

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

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

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

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

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

                _logger.LogInformation($"取消自动拆包减少订单明细数量 - åˆ†é…æ•°é‡ä»Ž {originalAllocatedBefore} å‡å°‘到 {orderDetail.AllocatedQuantity}");
                _logger.LogInformation($"取消自动拆包减少订单明细数量 - é”å®šæ•°é‡ä»Ž {originalLockBefore} å‡å°‘到 {orderDetail.LockQuantity}");
            }

            // æ ‡è®°æ‹†åŒ…记录为已撤销
@@ -896,13 +987,96 @@
            await _splitPackageService.Db.Updateable(splitRecord).ExecuteCommandAsync();
            _logger.LogInformation($"标记拆包记录为已撤销");

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

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

            _logger.LogInformation($"取消拆包逻辑执行完成");
        }
        /// <summary>
        /// éªŒè¯å–消拆包后数据一致性 - æœ€æ–°ç‰ˆæœ¬
        /// </summary>
        private async Task ValidateDataConsistencyAfterCancelSplit(long orderDetailId, decimal originalAllocatedQty, decimal originalLockQty, bool isAutoSplit, decimal splitQuantity)
        {
            // é‡æ–°èŽ·å–订单明细数据
            var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                .FirstAsync(x => x.Id == orderDetailId);

            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;
            decimal expectedLockQty;

            if (isAutoSplit)
            {
                // è‡ªåŠ¨æ‹†åŒ…取消：分配数量应该减少拆包数量
                expectedAllocatedQty = originalAllocatedQty - splitQuantity;
                expectedLockQty = originalLockQty - splitQuantity;

                _logger.LogInformation($"取消自动拆包期望值 - åˆ†é…æ•°é‡: {expectedAllocatedQty}, é”å®šæ•°é‡: {expectedLockQty}");
            }
            else
            {
                // æ‰‹åŠ¨æ‹†åŒ…取消：分配数量应该保持不变
                expectedAllocatedQty = originalAllocatedQty;
                expectedLockQty = originalLockQty;

                _logger.LogInformation($"取消手动拆包期望值 - åˆ†é…æ•°é‡: {expectedAllocatedQty}, é”å®šæ•°é‡: {expectedLockQty}");
            }

            // è¾¹ç•Œæ£€æŸ¥ï¼šç¡®ä¿æœŸæœ›å€¼ä¸ä¸ºè´Ÿæ•°
            if (expectedAllocatedQty < 0)
            {
                _logger.LogWarning($"期望分配数量为负数，重置为0。计算值: {expectedAllocatedQty}");
                expectedAllocatedQty = 0;
            }

            if (expectedLockQty < 0)
            {
                _logger.LogWarning($"期望锁定数量为负数，重置为0。计算值: {expectedLockQty}");
                expectedLockQty = 0;
            }

            // éªŒè¯åˆ†é…æ•°é‡
            if (Math.Abs(orderDetail.AllocatedQuantity - expectedAllocatedQty) > 0.01m)
            {
                _logger.LogWarning($"取消拆包后分配数量异常 - æœŸæœ›: {expectedAllocatedQty}, å®žé™…: {orderDetail.AllocatedQuantity}");
            }

            // éªŒè¯é”å®šæ•°é‡
            if (Math.Abs(orderDetail.LockQuantity - expectedLockQty) > 0.01m)
            {
                _logger.LogWarning($"取消拆包后锁定数量异常 - æœŸæœ›: {expectedLockQty}, å®žé™…: {orderDetail.LockQuantity}");
            }

            // éªŒè¯è®¢å•æ˜Žç»†åˆ†é…æ•°é‡ä¸Žé”å®šä¿¡æ¯æ€»åˆ†é…æ•°é‡çš„一致性
            if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
            {
                _logger.LogWarning($"取消拆包后数据不一致 - è®¢å•æ˜Žç»†åˆ†é…æ•°é‡: {orderDetail.AllocatedQuantity}, é”å®šä¿¡æ¯æ€»åˆ†é…æ•°é‡: {totalLockAssignQty}");
            }

            // è®°å½•è¯¦ç»†çš„一致性报告
            _logger.LogInformation($"取消拆包数据一致性报告 - " +
                                  $"订单明细分配数量: {orderDetail.AllocatedQuantity}, " +
                                  $"订单明细锁定数量: {orderDetail.LockQuantity}, " +
                                  $"锁定信息总分配数量: {totalLockAssignQty}, " +
                                  $"拆包类型: {(isAutoSplit ? "自动" : "手动")}, " +
                                  $"拆包数量: {splitQuantity}");
        }
        /// <summary>
        /// éªŒè¯å–消拆包请求 
        /// </summary>
@@ -935,7 +1109,7 @@

            _logger.LogInformation($"找到新锁定信息 - çŠ¶æ€: {newLockInfo.Status}, å·²æ‹£é€‰: {newLockInfo.PickedQty}, åˆ†é…æ•°é‡: {newLockInfo.AssignQuantity}");

            // é‡è¦ä¿®å¤ï¼šæ£€æŸ¥æ–°æ¡ç æ˜¯å¦å·²è¢«åˆ†æ‹£
            // æ£€æŸ¥æ–°æ¡ç æ˜¯å¦å·²è¢«åˆ†æ‹£
            var newBarcodePickingRecords = await Db.Queryable<Dt_PickingRecord>()
                .Where(x => x.Barcode == newBarcode && x.OrderNo == orderNo && !x.IsCancelled)
                .ToListAsync();
@@ -948,7 +1122,7 @@
                    $"新条码已被分拣（已拣选数量：{totalPickedQty}），请先取消分拣，然后再取消拆包");
            }

            // é‡è¦ä¿®å¤ï¼šæ£€æŸ¥åŽŸæ¡ç æ˜¯å¦å·²è¢«åˆ†æ‹£
            // æ£€æŸ¥åŽŸæ¡ç æ˜¯å¦å·²è¢«åˆ†æ‹£
            var originalBarcodePickingRecords = await Db.Queryable<Dt_PickingRecord>()
                .Where(x => x.Barcode == splitRecord.OriginalBarcode && x.OrderNo == orderNo && !x.IsCancelled)
                .ToListAsync();
@@ -1366,7 +1540,7 @@

        #endregion

         #region ç»Ÿä¸€å›žåº“逻辑
        #region ç»Ÿä¸€å›žåº“逻辑
        private async Task<Dt_Task> GetCurrentTask(string orderNo, string palletCode)
        {
            // å…ˆå°è¯•é€šè¿‡è®¢å•å·å’Œæ‰˜ç›˜å·æŸ¥æ‰¾ä»»åŠ¡
@@ -1522,50 +1696,34 @@
                    return WebResponseContent.Instance.Error("订单号和托盘码不能为空");

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

                var task = await GetCurrentTask(orderNo, palletCode);
                if (task == null)
                    return WebResponseContent.Instance.Error("未找到对应的任务信息");

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

                if (!statusAnalysis.HasItemsToReturn)
                    return await HandleNoReturnItems(orderNo, palletCode, task, stockInfo.Id);
                    return await HandleEmptyPalletReturn(orderNo, palletCode, stockInfo);

                // æ£€æŸ¥æ˜¯å¦æœ‰è¿›è¡Œä¸­çš„任务
                if (statusAnalysis.HasActiveTasks)
                {
                    return WebResponseContent.Instance.Error($"托盘 {palletCode} æœ‰è¿›è¡Œä¸­çš„任务，不能执行回库操作");
                }
                _logger.LogInformation($"开始回库操作 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}, å›žåº“数量: {statusAnalysis.TotalReturnQty}");

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

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

                _unitOfWorkManage.CommitTran();

                // æ”¶é›†æ‰€æœ‰éœ€è¦å›žåº“的条码
                var returnBarcodes = await CollectReturnBarcodes(statusAnalysis);

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

                // æ›´æ–°è®¢å•çŠ¶æ€ï¼ˆä¸è§¦å‘MES回传）
                await UpdateOrderStatusForReturn(orderNo);
                // åˆ›å»ºå›žåº“任务（AGV）
                await CreateReturnTask(orderNo, palletCode, stockInfo);

                return WebResponseContent.Instance.OK($"回库操作成功，共回库数量：{statusAnalysis.TotalReturnQty}", new
                {
                    ReturnQuantity = statusAnalysis.TotalReturnQty,
                    ReturnBarcodes = returnBarcodes,
                    ReturnBarcodes = statusAnalysis.AllBarcodes,
                    Reason = returnReason,
                    PalletCode = palletCode,
                    OrderNo = orderNo
@@ -1578,32 +1736,646 @@
                return WebResponseContent.Instance.Error($"回库操作失败: {ex.Message}");
            }
        }
        private async Task ExecuteReturnDataOperations(string orderNo, string palletCode, Dt_StockInfo stockInfo,Dt_Task task, PalletStatusAnalysis statusAnalysis)
        /// <summary>
        /// æ‰§è¡Œå›žåº“数据操作
        /// ç¡®ä¿ä¸ä¼šå°†ç”Ÿæˆçš„条码数量错误绑定到锁定数量
        /// </summary>
        private async Task ExecuteReturnDataOperations(PalletStatusAnalysis statusAnalysis)
        {
            _logger.LogInformation($"开始执行回库数据操作 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");
            _logger.LogInformation($"开始执行回库数据操作 - è®¢å•: {statusAnalysis.OrderNo}, æ‰˜ç›˜: {statusAnalysis.PalletCode}");

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

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

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

                _logger.LogInformation($"回库数据操作完成 - æ€»å›žåº“数量: {statusAnalysis.TotalReturnQty}");
            }
            catch (Exception ex)
            {
                _logger.LogError($"回库数据操作失败 - è®¢å•: {statusAnalysis.OrderNo}, æ‰˜ç›˜: {statusAnalysis.PalletCode}, Error: {ex.Message}");
                throw;
            }
        }
        // <summary>
        /// å¤„理未分配的锁定记录回库
        /// ä¸éœ€è¦å‡å°‘订单明细的分配数量
        /// </summary>
        private async Task HandleUnallocatedLocksReturn(List<Dt_OutStockLockInfo> unallocatedLocks)
        {
            _logger.LogInformation($"开始处理未分配锁定记录回库 - å…± {unallocatedLocks.Count} æ¡è®°å½•");

            foreach (var lockInfo in unallocatedLocks)
            {
                // è®¡ç®—回库数量（未拣选的部分）
                decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

                if (returnQty <= 0)
                {
                    _logger.LogInformation($"跳过未分配锁定记录 - é”å®šID: {lockInfo.Id}, å·²æ‹£é€‰å®Œæˆæˆ–无需回库");
                    continue;
                }

                _logger.LogInformation($"处理未分配锁定记录回库 - é”å®šID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, å›žåº“数量: {returnQty}");

                // æ¢å¤åº“存状态
                await RestoreStockForLockInfo(lockInfo, returnQty);

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

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

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

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

            // 2. å¤„理托盘上的库存货物
            if (statusAnalysis.HasPalletStockGoods)
            _logger.LogInformation($"未分配锁定记录回库处理完成 - å…±å¤„理 {unallocatedLocks.Count} æ¡è®°å½•");
        }
        private async Task HandleAllocatedLocksReturn(List<Dt_OutStockLockInfo> allocatedLocks)
        {
            _logger.LogInformation($"开始处理已分配锁定记录回库 - å…± {allocatedLocks.Count} æ¡è®°å½•");

            // æŒ‰è®¢å•æ˜Žç»†åˆ†ç»„处理
            var orderDetailGroups = allocatedLocks.GroupBy(x => x.OrderDetailId);

            foreach (var group in orderDetailGroups)
            {
                _logger.LogInformation($"处理 {statusAnalysis.PalletStockGoods.Count} ä¸ªåº“存货物");
                await HandlePalletStockGoodsReturn(statusAnalysis.PalletStockGoods, stockInfo.Id);
                var orderDetailId = group.Key;
                var groupLocks = group.ToList();

                _logger.LogInformation($"处理订单明细 {orderDetailId} çš„ {groupLocks.Count} æ¡é”å®šè®°å½•");

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

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

                decimal totalReturnQtyForDetail = 0;

                foreach (var lockInfo in groupLocks)
                {
                    // è®¡ç®—回库数量（未拣选的部分）
                    decimal returnQty = lockInfo.AssignQuantity - lockInfo.PickedQty;

                    if (returnQty <= 0)
                    {
                        _logger.LogInformation($"跳过锁定记录 - é”å®šID: {lockInfo.Id}, å·²æ‹£é€‰å®Œæˆæˆ–无需回库");
                        continue;
                    }

                    _logger.LogInformation($"处理已分配锁定记录回库 - é”å®šID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, å›žåº“数量: {returnQty}");

                    // æ¢å¤åº“存状态
                    await RestoreStockForLockInfo(lockInfo, returnQty);

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

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

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

                    totalReturnQtyForDetail += returnQty;
                }

                // å‡å°‘订单明细的分配数量
                if (totalReturnQtyForDetail > 0)
                {
                    await ReduceOrderDetailAllocation(orderDetail, totalReturnQtyForDetail);
                }
            }

            // 3. å¤„理拆包记录
            if (statusAnalysis.HasSplitRecords)
            _logger.LogInformation($"已分配锁定记录回库处理完成 - å…±å¤„理 {allocatedLocks.Count} æ¡è®°å½•");
        }
        /// <summary>
        /// æ¢å¤é”å®šè®°å½•å¯¹åº”的库存
        /// </summary>
        private async Task RestoreStockForLockInfo(Dt_OutStockLockInfo lockInfo, decimal returnQty)
        {
            var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);

            if (stockDetail != null)
            {
                _logger.LogInformation($"处理 {statusAnalysis.SplitRecords.Count} æ¡æ‹†åŒ…记录");
                await HandleSplitRecordsReturn(statusAnalysis.SplitRecords, stockInfo.Id);
                // è®°å½•æ¢å¤å‰çš„库存状态
                decimal originalStockQty = stockDetail.StockQuantity;
                decimal originalOutboundQty = stockDetail.OutboundQuantity;

                // æ¢å¤åº“存数量：出库数量减少，库存数量增加
                stockDetail.OutboundQuantity -= returnQty;
                stockDetail.StockQuantity += returnQty;

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

                // æ¢å¤åº“存状态为可用状态
                if (stockDetail.Status == (int)StockStatusEmun.出库锁定)
                {
                    stockDetail.Status = (int)StockStatusEmun.入库完成;
                    _logger.LogInformation($"库存状态更新为入库完成 - æ¡ç : {stockDetail.Barcode}");
                }

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

                _logger.LogInformation($"恢复库存状态 - æ¡ç : {stockDetail.Barcode}, " +
                                     $"库存数量: {originalStockQty} -> {stockDetail.StockQuantity}, " +
                                     $"出库数量: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
            }
            else
            {
                _logger.LogWarning($"未找到对应的库存信息 - æ¡ç : {lockInfo.CurrentBarcode}, StockId: {lockInfo.StockId}");
            }
        }
        /// <summary>
        /// åˆ›å»ºå›žåº“任务
        /// </summary>
        private async Task CreateReturnTask(string orderNo, string palletCode, Dt_StockInfo stockInfo)
        {
            // èŽ·å–当前任务信息
            var currentTask = await _taskRepository.Db.Queryable<Dt_Task>()
                .Where(x => x.OrderNo == orderNo && x.PalletCode == palletCode)
                .FirstAsync();

            if (currentTask != null)
            {
                // åˆ†é…æ–°è´§ä½
                var newLocation = _locationInfoService.AssignLocation(stockInfo.LocationType);

                var returnTask = new Dt_Task()
                {
                    CurrentAddress = stations[currentTask.TargetAddress],
                    Grade = 0,
                    PalletCode = palletCode,
                    NextAddress = "",
                    OrderNo = orderNo,
                    Roadway = newLocation.RoadwayNo,
                    SourceAddress = stations[currentTask.TargetAddress],
                    TargetAddress = newLocation.LocationCode,
                    TaskStatus = TaskStatusEnum.New.ObjToInt(),
                    TaskType = TaskTypeEnum.InPick.ObjToInt(),
                    PalletType = stockInfo.PalletType,
                    WarehouseId = currentTask.WarehouseId
                };
                try
                {
                    await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();

                }
                catch (Exception ex)
                {
                    _logger.LogInformation($"创建回库任务失败 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");
                    throw new Exception($"创建回库任务失败 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");
                  
                }
                // å‘送ESS命令
                await SendESSCommands(palletCode, currentTask.TargetAddress, returnTask);

                _logger.LogInformation($"创建回库任务成功 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");
            }
        }
        /// <summary>
        /// æ›´æ–°å›žåº“后的订单状态
        /// </summary>
        private async Task UpdateOrderStatusAfterReturn(string orderNo)
        {
            // æ£€æŸ¥è®¢å•æ˜¯å¦è¿˜æœ‰æœªå®Œæˆçš„锁定记录
            var activeLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderNo == orderNo &&
                           (x.Status == (int)OutLockStockStatusEnum.出库中 ||
                            x.Status == (int)OutLockStockStatusEnum.回库中))
                .ToListAsync();

            if (!activeLocks.Any())
            {
                // æ‰€æœ‰é”å®šè®°å½•éƒ½å·²å®Œæˆæˆ–已回库，更新订单状态
                await _outboundOrderService.Db.Updateable<Dt_OutboundOrder>()
                    .SetColumns(x => new Dt_OutboundOrder
                    {
                        OrderStatus = (int)OutOrderStatusEnum.出库完成,
                    })
                    .Where(x => x.OrderNo == orderNo)
                    .ExecuteCommandAsync();

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

        /// <summary>
        /// å¤„理空托盘回库
        /// </summary>
        private async Task<WebResponseContent> HandleEmptyPalletReturn(string orderNo, string palletCode, Dt_StockInfo stockInfo)
        {
            _logger.LogInformation($"处理空托盘回库 - è®¢å•: {orderNo}, æ‰˜ç›˜: {palletCode}");

            try
            {
                // æ¸…理零库存数据
                await CleanupZeroStockData(stockInfo.Id);

                // åˆ›å»ºç©ºæ‰˜ç›˜åº“存记录
                var emptyStockInfo = new Dt_StockInfo()
                {
                    PalletType = PalletTypeEnum.Empty.ObjToInt(),
                    StockStatus = StockStatusEmun.组盘暂存.ObjToInt(),
                    PalletCode = palletCode,
                    LocationType = stockInfo.LocationType
                };
                emptyStockInfo.Details = new List<Dt_StockInfoDetail>();
                _stockInfoService.AddMaterielGroup(emptyStockInfo);

                // åˆ›å»ºç©ºæ‰˜ç›˜å›žåº“任务
                await CreateReturnTask(orderNo, palletCode, emptyStockInfo);

                return WebResponseContent.Instance.OK("空托盘回库成功");
            }
            catch (Exception ex)
            {
                _logger.LogError($"空托盘回库失败: {ex.Message}");
                return WebResponseContent.Instance.Error($"空托盘回库失败: {ex.Message}");
            }
        }
        /// <summary>
        /// åˆ†æžæ‰˜ç›˜çŠ¶æ€ç”¨äºŽå›žåº“
        /// ç¡®ä¿ä¸ä¼šé”™è¯¯è¯†åˆ«éœ€è¦å›žåº“的物品
        /// </summary>
        private async Task<PalletStatusAnalysis> AnalyzePalletStatusForReturn(string orderNo, string palletCode, int stockId)
        {
            var result = new PalletStatusAnalysis
            {
                OrderNo = orderNo,
                PalletCode = palletCode,
                StockId = stockId
            };

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

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

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

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

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

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

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

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

            _logger.LogInformation($"回库数据操作完成 - æ€»å›žåº“数量: {statusAnalysis.TotalReturnQty}");
            // 2. åˆ†æžæ‰˜ç›˜ä¸Šçš„剩余库存货物（状态为出库锁定但未分配）
            var palletStockGoods = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                .Where(x => x.StockId == stockId &&
                           x.Status == (int)StockStatusEmun.出库锁定 &&
                           x.StockQuantity > 0)
                .ToListAsync();

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

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

                if (!hasLock)
                {
                    trulyUnallocatedGoods.Add(stock);
                }
            }

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

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

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

            return result;
        }
        /// <summary>
        /// å¤„理未分拣的锁定记录回库
        /// ç¡®ä¿ä¸ä¼šé”™è¯¯ç»‘定条码数量到锁定数量
        /// </summary>
        private async Task HandleRemainingLocksReturn(List<Dt_OutStockLockInfo> remainingLocks)
        {
            _logger.LogInformation($"开始处理未分拣锁定记录回库 - å…± {remainingLocks.Count} æ¡è®°å½•");

            // æŒ‰è®¢å•æ˜Žç»†åˆ†ç»„处理，确保订单明细数据的一致性
            var orderDetailGroups = remainingLocks.GroupBy(x => x.OrderDetailId);

            foreach (var group in orderDetailGroups)
            {
                var orderDetailId = group.Key;
                var groupLocks = group.ToList();

                _logger.LogInformation($"处理订单明细 {orderDetailId} çš„ {groupLocks.Count} æ¡é”å®šè®°å½•");

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

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

                decimal totalReturnQtyForDetail = 0;

                foreach (var lockInfo in groupLocks)
                {
                    // åªå¤„理状态为出库中的锁定记录
                    if (lockInfo.Status != (int)OutLockStockStatusEnum.出库中)
                    {
                        _logger.LogInformation($"跳过非出库中状态的锁定记录 - é”å®šID: {lockInfo.Id}, çŠ¶æ€: {lockInfo.Status}");
                        continue;
                    }

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

                    if (returnQty <= 0)
                    {
                        _logger.LogInformation($"跳过锁定记录 - é”å®šID: {lockInfo.Id}, å·²æ‹£é€‰å®Œæˆæˆ–无需回库");
                        continue;
                    }

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

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

                    if (stockDetail != null)
                    {
                        // è®°å½•æ¢å¤å‰çš„库存状态
                        decimal originalStockQty = stockDetail.StockQuantity;
                        decimal originalOutboundQty = stockDetail.OutboundQuantity;

                        // åªæ¢å¤å®žé™…的库存数量，不创建新的条码或绑定
                        // æ¢å¤åº“存数量：出库数量减少，库存数量增加
                        stockDetail.OutboundQuantity -= returnQty;
                        stockDetail.StockQuantity += returnQty;

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

                        // æ¢å¤åº“存状态为可用状态
                        if (stockDetail.Status == (int)StockStatusEmun.出库锁定)
                        {
                            stockDetail.Status = (int)StockStatusEmun.入库完成;
                            _logger.LogInformation($"库存状态更新为入库完成 - æ¡ç : {stockDetail.Barcode}");
                        }

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

                        _logger.LogInformation($"恢复库存状态 - æ¡ç : {stockDetail.Barcode}, " +
                                             $"库存数量: {originalStockQty} -> {stockDetail.StockQuantity}, " +
                                             $"出库数量: {originalOutboundQty} -> {stockDetail.OutboundQuantity}");
                    }
                    else
                    {
                        _logger.LogWarning($"未找到对应的库存信息 - æ¡ç : {lockInfo.CurrentBarcode}, StockId: {lockInfo.StockId}");
                        // é‡è¦ï¼šå¦‚果找不到库存信息，跳过此锁定记录，避免数据不一致
                        continue;
                    }

                    // æ›´æ–°é”å®šè®°å½•çŠ¶æ€ä¸ºå·²å›žåº“，但不修改分配数量
                    // åˆ†é…æ•°é‡åœ¨è®¢å•æ˜Žç»†å±‚面统一处理
                    var originalStatus = lockInfo.Status;
                    lockInfo.Status = (int)OutLockStockStatusEnum.已回库;
                    lockInfo.Operator = App.User.UserName;

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

                    _logger.LogInformation($"更新锁定状态 - é”å®šID: {lockInfo.Id}, çŠ¶æ€: {originalStatus} -> {lockInfo.Status}");

                    totalReturnQtyForDetail += returnQty;

                    _logger.LogInformation($"锁定记录回库完成 - é”å®šID: {lockInfo.Id}, å›žåº“数量: {returnQty}");
                }

                // å‡å°‘订单明细的分配数量
                if (totalReturnQtyForDetail > 0)
                {
                    await ReduceOrderDetailAllocation(orderDetail, totalReturnQtyForDetail);
                }
            }

            _logger.LogInformation($"未分拣锁定记录回库处理完成 - å…±å¤„理 {remainingLocks.Count} æ¡è®°å½•");
        }
        /// <summary>
        /// å¤„理未分配的库存货物回库
        /// ç¡®ä¿ä¸ä¼šåˆ›å»ºæ–°çš„锁定记录
        /// </summary>
        private async Task HandleUnallocatedStockReturn(List<Dt_StockInfoDetail> stockGoods)
        {
            _logger.LogInformation($"开始处理未分配库存回库 - å…± {stockGoods.Count} ä¸ªè´§ç‰©");

            foreach (var stockDetail in stockGoods)
            {
                if (stockDetail.StockQuantity <= 0)
                {
                    _logger.LogInformation($"跳过零库存货物 - æ¡ç : {stockDetail.Barcode}");
                    continue;
                }

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

                // æ£€æŸ¥æ˜¯å¦å·²ç»æœ‰å¯¹åº”的锁定记录
                var existingLock = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.CurrentBarcode == stockDetail.Barcode &&
                               x.Status == (int)OutLockStockStatusEnum.出库中)
                    .FirstAsync();

                if (existingLock != null)
                {
                    _logger.LogWarning($"库存条码 {stockDetail.Barcode} å·²æœ‰é”å®šè®°å½•ï¼Œè·³è¿‡ç›´æŽ¥å›žåº“处理");
                    continue;
                }

                // è®°å½•æ¢å¤å‰çš„状态
                var originalStatus = stockDetail.Status;

                // ç›´æŽ¥æ¢å¤åº“存状态为可用状态，不创建任何锁定记录
                stockDetail.Status = (int)StockStatusEmun.入库完成;

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

                _logger.LogInformation($"未分配库存回库完成 - æ¡ç : {stockDetail.Barcode}, çŠ¶æ€: {originalStatus} -> {stockDetail.Status}");
            }

            _logger.LogInformation($"未分配库存回库处理完成 - å…±å¤„理 {stockGoods.Count} ä¸ªè´§ç‰©");
        }
        /// <summary>
        /// å‡å°‘订单明细的分配数量
        /// ç¡®ä¿åˆ†é…æ•°é‡çš„减少是准确的
        /// </summary>
        private async Task ReduceOrderDetailAllocation(Dt_OutboundOrderDetail orderDetail, decimal reduceQty)
        {
            if (orderDetail == null)
                return;

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

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

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

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

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

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

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

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

            // éªŒè¯æ•°æ®ä¸€è‡´æ€§
            await ValidateOrderDetailConsistency(orderDetail.Id);
        }
        /// <summary>
        /// éªŒè¯è®¢å•æ˜Žç»†æ•°æ®ä¸€è‡´æ€§
        /// </summary>
        private async Task ValidateOrderDetailConsistency(long orderDetailId)
        {
            var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                .FirstAsync(x => x.Id == orderDetailId);

            if (orderDetail == null)
                return;

            // è®¡ç®—所有相关锁定记录的总分配数量
            var relatedLocks = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                .Where(x => x.OrderDetailId == orderDetailId &&
                           x.Status != (int)OutLockStockStatusEnum.已回库)
                .ToListAsync();

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

            // éªŒè¯è®¢å•æ˜Žç»†åˆ†é…æ•°é‡ä¸Žé”å®šè®°å½•æ€»åˆ†é…æ•°é‡çš„一致性
            if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
            {
                _logger.LogWarning($"数据不一致警告 - OrderDetailId: {orderDetailId}, " +
                                  $"订单明细分配数量: {orderDetail.AllocatedQuantity}, " +
                                  $"锁定记录总分配数量: {totalLockAssignQty}");
            }
            else
            {
                _logger.LogInformation($"数据一致性验证通过 - OrderDetailId: {orderDetailId}");
            }
        }
        /// <summary>
        /// åˆ†æ‰¹å›žåº“ - è°ƒç”¨ç»Ÿä¸€å›žåº“方法
@@ -1784,51 +2556,12 @@
            }

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

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

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

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

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

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

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

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

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

        /// <summary>
        /// å¤„理托盘上的库存货物回库
@@ -1884,42 +2617,61 @@
            }
        }

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

            if (returnQty > 0)
            if (returnQty <= 0)
            {
                // æ¢å¤åº“å­˜
                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .FirstAsync(x => x.Barcode == lockInfo.CurrentBarcode && x.StockId == lockInfo.StockId);
                _logger.LogInformation($"跳过锁定记录 - é”å®šID: {lockInfo.Id}, å·²æ‹£é€‰å®Œæˆæˆ–无需回库");
                return;
            }

                if (stockDetail != null)
            _logger.LogInformation($"处理拆包相关锁定记录 - é”å®šID: {lockInfo.Id}, æ¡ç : {lockInfo.CurrentBarcode}, å›žåº“数量: {returnQty}");

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

            if (stockDetail != null)
            {
                decimal originalStockQty = stockDetail.StockQuantity;
                decimal originalOutboundQty = stockDetail.OutboundQuantity;

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

                if (stockDetail.OutboundQuantity < 0)
                {
                    stockDetail.StockQuantity += returnQty;
                    stockDetail.OutboundQuantity -= returnQty;

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

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

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

                _logger.LogInformation($"处理拆包相关锁定 - æ¡ç : {lockInfo.CurrentBarcode}, å›žåº“数量: {returnQty}");
                _logger.LogInformation($"恢复拆包相关库存 - æ¡ç : {stockDetail.Barcode}, " +
                                     $"库存数量: {originalStockQty} -> {stockDetail.StockQuantity}");
            }
        }

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

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

                if (orderDetail != null)
                {
                    await ReduceOrderDetailAllocation(orderDetail, returnQty);
                }
            }

            _logger.LogInformation($"拆包相关锁定记录回库完成 - é”å®šID: {lockInfo.Id}, å›žåº“数量: {returnQty}");
        }
        /// <summary>
        /// é‡Šæ”¾æ‰€æœ‰é”å®šä»¥ä¾¿é‡æ–°åˆ†é…
        /// </summary>
@@ -2017,9 +2769,8 @@
            {
                // 1. åˆ é™¤åº“存数量为0的明细记录
                var deleteDetailCount = await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
                    .Where(x => x.StockId == stockId && x.StockQuantity == 0 && (x.Status == StockStatusEmun.出库完成.ObjToInt() || x.Status ==
                                          StockStatusEmun.入库完成.ObjToInt()))
                    .ExecuteCommandAsync();
            .Where(x => x.StockId == stockId && x.StockQuantity == 0)
            .ExecuteCommandAsync();

                await _stockInfoService.Db.Deleteable<Dt_StockInfo>()
                   .Where(x => x.Id == stockId).ExecuteCommandAsync();
@@ -2086,6 +2837,11 @@
            if (lockInfo == null)
                return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("未找到有效的锁定信息");

            if (lockInfo.IsUnallocated == 1 || lockInfo.OrderDetailId == 0)
            {
                return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error("该条码是未分配锁定记录，不能直接分拣");
            }

            _logger.LogInformation($"找到锁定信息 - åˆ†é…æ•°é‡: {lockInfo.AssignQuantity}, å·²æ‹£é€‰: {lockInfo.PickedQty}");

            // æ£€æŸ¥æ˜¯å¦å·²ç»åˆ†æ‹£å®Œæˆ
@@ -2101,21 +2857,32 @@

            _logger.LogInformation($"找到订单明细 - å·²åˆ†é…æ•°é‡: {orderDetail.AllocatedQuantity}, é”å®šæ•°é‡: {orderDetail.LockQuantity}");

            // é‡è¦ä¿®å¤ï¼šæ£€æŸ¥è®¢å•æ˜Žç»†çš„已分配数量是否足够
            // æ£€æŸ¥è®¢å•æ˜Žç»†çš„已分配数量是否足够
            decimal remainingToPick = lockInfo.AssignQuantity - lockInfo.PickedQty;
            if (orderDetail.AllocatedQuantity < remainingToPick)

            // è¿™é‡Œåº”该检查锁定信息的分配数量，而不是订单明细的分配数量
            // å› ä¸ºæ‹†åŒ…后，锁定信息的分配数量可能小于订单明细的分配数量
            if (lockInfo.AssignQuantity < remainingToPick)
            {
                _logger.LogWarning($"订单明细已分配数量不足 - éœ€è¦æ‹£é€‰: {remainingToPick}, å¯ç”¨åˆ†é…æ•°é‡: {orderDetail.AllocatedQuantity}");
                _logger.LogWarning($"锁定信息分配数量不足 - éœ€è¦æ‹£é€‰: {remainingToPick}, é”å®šä¿¡æ¯åˆ†é…æ•°é‡: {lockInfo.AssignQuantity}");
                return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
                    $"订单明细分配数量不足，需要拣选：{remainingToPick}，可用分配数量：{orderDetail.AllocatedQuantity}");
                    $"锁定信息分配数量不足，需要拣选：{remainingToPick}，锁定信息分配数量：{lockInfo.AssignQuantity}");
            }

            // é‡è¦ä¿®å¤ï¼šæ£€æŸ¥é”å®šæ•°é‡æ˜¯å¦è¶³å¤Ÿ
            // æ£€æŸ¥é”å®šæ•°é‡æ˜¯å¦è¶³å¤Ÿ
            if (orderDetail.LockQuantity < remainingToPick)
            {
                _logger.LogWarning($"订单明细锁定数量不足 - éœ€è¦æ‹£é€‰: {remainingToPick}, å¯ç”¨é”å®šæ•°é‡: {orderDetail.LockQuantity}");
                return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
                    $"订单明细锁定数量不足，需要拣选：{remainingToPick}，可用锁定数量：{orderDetail.LockQuantity}");
            }

            // æ£€æŸ¥è®¢å•æ˜Žç»†åˆ†é…æ•°é‡æ˜¯å¦ä¸ºè´Ÿæ•°
            if (orderDetail.AllocatedQuantity < 0)
            {
                _logger.LogError($"订单明细分配数量为负数 - å½“前值: {orderDetail.AllocatedQuantity}");
                return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
                    $"订单明细分配数量异常（负数），请联系管理员处理");
            }

            var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
@@ -2130,11 +2897,11 @@
                    $"库存数量不足，需要拣选：{remainingToPick}，实际库存：{stockDetail.StockQuantity}");

            // éªŒè¯åº“存状态
            if (stockDetail.Status != (int)StockStatusEmun.出库锁定)
            {
                return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
                    $"库存状态异常，当前状态：{stockDetail.Status}，期望状态：出库锁定");
            }
            //if (stockDetail.Status != (int)StockStatusEmun.出库锁定)
            //{
            //    return ValidationResult<(Dt_OutStockLockInfo, Dt_OutboundOrderDetail, Dt_StockInfoDetail, Dt_OutboundBatch)>.Error(
            //        $"库存状态异常，当前状态：{stockDetail.Status}，期望状态：出库锁定");
            //}

            // ä½¿ç”¨ OutboundBatchNo æŸ¥æ‰¾æ‰¹æ¬¡
            var batch = await _outboundBatchRepository.Db.Queryable<Dt_OutboundBatch>()
@@ -2151,6 +2918,11 @@
        /// </summary>
        private async Task<List<SplitResult>> CheckAndAutoSplitIfNeeded(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail, string palletCode)
        {
            if (lockInfo.IsUnallocated == 1 || lockInfo.OrderDetailId == 0)
            {
                _logger.LogInformation($"跳过未分配锁定记录的自动拆包检查 - é”å®šID: {lockInfo.Id}");
                return null;
            }
            // æ£€æŸ¥æ˜¯å¦éœ€è¦è‡ªåŠ¨æ‹†åŒ…的条件：
            // 1. åº“存数量大于分配数量
            // 2. é”å®šä¿¡æ¯çŠ¶æ€ä¸ºå‡ºåº“中
@@ -2172,21 +2944,32 @@
        }
        /// <summary>
        /// æ‰§è¡Œè‡ªåŠ¨æ‹†åŒ…逻辑
        /// ç¡®ä¿è‡ªåŠ¨æ‹†åŒ…不会影响回库逻辑
        /// </summary>
        private async Task<List<SplitResult>> ExecuteAutoSplitLogic(Dt_OutStockLockInfo lockInfo, Dt_StockInfoDetail stockDetail,
            decimal splitQuantity, string palletCode)
     decimal splitQuantity, string palletCode)
        {
            _logger.LogInformation($"开始执行自动拆包逻辑 - åŽŸæ¡ç : {stockDetail.Barcode}, æ‹†åŒ…数量: {splitQuantity}");

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

            if (stockDetail.StockQuantity < lockInfo.AssignQuantity + splitQuantity)
            {
                throw new InvalidOperationException($"库存数量不足以进行自动拆包");
            }

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

            // é‡è¦ä¿®å¤ï¼šè®°å½•æ‹†åŒ…前的分配数量
            decimal originalAssignQtyBefore = lockInfo.AssignQuantity;
            decimal originalOrderQtyBefore = lockInfo.OrderQuantity;
            decimal remainQty = originalAssignQtyBefore; // è‡ªåŠ¨æ‹†åŒ…后原条码分配数量保持不变
            // è®°å½•æ‹†åŒ…前的分配数量
            decimal originalAssignQty = lockInfo.AssignQuantity;
            decimal remainQty = originalAssignQty; // åŽŸé”å®šä¿¡æ¯åˆ†é…æ•°é‡ä¿æŒä¸å˜

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

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

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

            // åˆ›å»ºæ–°é”å®šä¿¡æ¯ï¼ˆå‰©ä½™éƒ¨åˆ†ï¼‰
            // åˆ›å»ºæ–°é”å®šä¿¡æ¯ï¼ˆå¤šä½™éƒ¨åˆ†ï¼‰- æ ‡è®°ä¸ºæœªåˆ†é…
            var newLockInfo = new Dt_OutStockLockInfo
            {
                OrderNo = lockInfo.OrderNo,
                OrderDetailId = lockInfo.OrderDetailId,
                OrderDetailId = 0, // é‡è¦ï¼šä¸ç»‘定到具体订单明细
                OutboundBatchNo = lockInfo.OutboundBatchNo,
                MaterielCode = lockInfo.MaterielCode,
                MaterielName = lockInfo.MaterielName,
@@ -2241,19 +3018,19 @@
                WarehouseCode = lockInfo.WarehouseCode,
                BarcodeQty = lockInfo.BarcodeQty,
                BarcodeUnit = lockInfo.BarcodeUnit,
                IsUnallocated = 1 // æ ‡è®°ä¸ºæœªåˆ†é…
            };

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

            // è‡ªåŠ¨æ‹†åŒ…时，原锁定信息的分配数量保持不变
            // å› ä¸ºè‡ªåŠ¨æ‹†åŒ…后，原条码仍然需要被分拣，分配数量不应该改变
            _logger.LogInformation($"原锁定信息保持不变 - åˆ†é…æ•°é‡: {lockInfo.AssignQuantity}, è®¢å•æ•°é‡: {lockInfo.OrderQuantity}");
            // è‡ªåŠ¨æ‹†åŒ…不改变订单明细的分配数量
            _logger.LogInformation($"自动拆包 - è®¢å•æ˜Žç»†åˆ†é…æ•°é‡ä¿æŒä¸å˜");

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

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

            _logger.LogInformation($"自动拆包逻辑执行完成");
@@ -2261,7 +3038,46 @@
            return splitResults;
        }

        /// <summary>
        /// éªŒè¯è‡ªåŠ¨æ‹†åŒ…后数据一致性
        /// </summary>
        private async Task ValidateDataConsistencyAfterAutoSplit(long orderDetailId, decimal originalAllocatedQty, decimal originalLockQty, decimal splitQuantity)
        {
            // é‡æ–°èŽ·å–订单明细数据
            var orderDetail = await _outboundOrderDetailService.Db.Queryable<Dt_OutboundOrderDetail>()
                .FirstAsync(x => x.Id == orderDetailId);

            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)
            {
                _logger.LogWarning($"自动拆包后分配数量异常 - æœŸæœ›: {expectedAllocatedQty}, å®žé™…: {orderDetail.AllocatedQuantity}");
            }

            if (Math.Abs(orderDetail.LockQuantity - expectedLockQty) > 0.01m)
            {
                _logger.LogWarning($"自动拆包后锁定数量异常 - æœŸæœ›: {expectedLockQty}, å®žé™…: {orderDetail.LockQuantity}");
            }

            if (Math.Abs(orderDetail.AllocatedQuantity - totalLockAssignQty) > 0.01m)
            {
                _logger.LogWarning($"自动拆包后数据不一致 - è®¢å•æ˜Žç»†åˆ†é…æ•°é‡: {orderDetail.AllocatedQuantity}, é”å®šä¿¡æ¯æ€»åˆ†é…æ•°é‡: {totalLockAssignQty}");
            }
        }
        #endregion

        #region æ ¸å¿ƒé€»è¾‘方法
@@ -2351,7 +3167,7 @@
            decimal originalPickedQty = lockInfo.PickedQty;
            decimal originalAssignQty = lockInfo.AssignQuantity; // è®°å½•åŽŸå§‹åˆ†é…æ•°é‡

            // é‡è¦ä¿®å¤ï¼šåªæ¢å¤å·²æ‹£é€‰æ•°é‡ï¼Œä¸ä¿®æ”¹åˆ†é…æ•°é‡
            // åªæ¢å¤å·²æ‹£é€‰æ•°é‡ï¼Œä¸ä¿®æ”¹åˆ†é…æ•°é‡
            lockInfo.PickedQty -= pickingRecord.PickQuantity;

            // ç¡®ä¿å·²æ‹£é€‰æ•°é‡ä¸ä¼šä¸ºè´Ÿæ•°
@@ -2434,7 +3250,7 @@
                throw new InvalidOperationException("未找到订单明细");

            orderDetail = latestOrderDetail;
            // é‡è¦ä¿®å¤ï¼šéªŒè¯åˆ†é…æ•°é‡ä¸ä¼šå˜æˆè´Ÿæ•°
            // éªŒè¯åˆ†é…æ•°é‡ä¸ä¼šå˜æˆè´Ÿæ•°
            if (orderDetail.AllocatedQuantity < pickedQty)
            {
                decimal actualPickedQty = orderDetail.AllocatedQuantity;
@@ -2529,9 +3345,9 @@
                decimal originalAllocatedQty = orderDetail.AllocatedQuantity;
                decimal originalLockQty = orderDetail.LockQuantity;

                // é‡è¦ä¿®å¤ï¼šåªæ¢å¤ç›¸å…³æ•°é‡ï¼Œåˆ†é…æ•°é‡ä¿æŒä¸å˜
                // åªæ¢å¤ç›¸å…³æ•°é‡ï¼Œåˆ†é…æ•°é‡ä¿æŒä¸å˜
                orderDetail.OverOutQuantity -= pickingRecord.PickQuantity;
                orderDetail.AllocatedQuantity += pickingRecord.PickQuantity;   
                orderDetail.AllocatedQuantity += pickingRecord.PickQuantity;
                orderDetail.LockQuantity += pickingRecord.PickQuantity;
                if (orderDetail.OverOutQuantity < 0) orderDetail.OverOutQuantity = 0;
                if (orderDetail.AllocatedQuantity < 0) orderDetail.AllocatedQuantity = 0;
@@ -2673,12 +3489,17 @@

            };
            // ä¿å­˜å›žåº“任务
            await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();
            var insertcount = await _taskRepository.Db.Insertable(returnTask).ExecuteCommandAsync();
            if (insertcount <= 0)
            {
                throw new Exception("创建任务失败！");
            }
            var targetAddress = originalTask.TargetAddress;

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