提交

pan

2025-11-20 246622a6e9c2563bd21d627c21c6012017f0f04e

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

@@ -1,6 +1,7 @@
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Org.BouncyCastle.Asn1.Ocsp;
using SqlSugar.Extensions;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -45,6 +46,168 @@
        /// <summary>
        /// æ‹†åŒ…拆箱操作
        /// </summary>
        //public async Task<WebResponseContent> SplitPackage(SplitPackageDto request)
        //{
        //    try
        //    {
        //        _unitOfWorkManage.BeginTran();

        //        // 1. éªŒè¯å‡ºåº“锁定信息
        //        var lockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
        //                  .Where(x => x.OrderNo == request.OrderNo &&
        //                   x.PalletCode == request.PalletCode &&
        //                   x.CurrentBarcode == request.OriginalBarcode &&
        //                   x.Status == 1)
        //            .FirstAsync();

        //        if (lockInfo == null)
        //            return WebResponseContent.Instance.Error("未找到有效的出库锁定信息");

        //        // 2. æ£€æŸ¥å‰©ä½™é”å®šæ•°é‡
        //        decimal remainingLockQuantity = lockInfo.OriginalQuantity - lockInfo.PickedQty;
        //        if (request.SplitQuantity > remainingLockQuantity)
        //            return WebResponseContent.Instance.Error($"拆包数量不能大于剩余锁定数量，剩余：{remainingLockQuantity}");

        //        var baseStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
        //       .Where(x => x.Barcode == request.OriginalBarcode && x.StockId == lockInfo.StockId)
        //       .FirstAsync();
        //        if (baseStockDetail == null)
        //            throw new Exception($"未找到条码{request.OriginalBarcode}对应的库存记录");


        //        // 4. è®¡ç®—拆分后的数量
        //        decimal remainingQty = baseStockDetail.StockQuantity - request.SplitQuantity;

        //        // æ›´æ–°åŸºç¡€æ¡ç çš„库存数量为剩余数量
        //        baseStockDetail.StockQuantity = remainingQty;
        //        baseStockDetail.OutboundQuantity = remainingQty;
        //        await _stockInfoDetailService.Db.Updateable(baseStockDetail).ExecuteCommandAsync();


        //        var seq = await _dailySequenceService.GetNextSequenceAsync();
        //        // 3. ç”Ÿæˆæ–°æ¡ç 
        //        string newBarcode = "WSLOT" + DateTime.Now.ToString("yyyyMMdd") + seq.ToString()?.PadLeft(5, '0');


        //        // ä¸ºæ‹†åŒ…产生的新条码创建库存记录
        //        var newStockDetail = new Dt_StockInfoDetail
        //        {
        //            SupplyCode = baseStockDetail.SupplyCode,
        //            WarehouseCode = baseStockDetail.WarehouseCode,
        //            BarcodeQty = baseStockDetail.BarcodeQty,
        //            BarcodeUnit = baseStockDetail.BarcodeUnit,
        //            BusinessType = baseStockDetail.BusinessType,
        //            Unit = baseStockDetail.Unit,
        //            StockId = lockInfo.StockId,
        //            MaterielCode = baseStockDetail.MaterielCode,
        //            OrderNo = baseStockDetail.OrderNo,
        //            BatchNo = baseStockDetail.BatchNo,
        //            StockQuantity = request.SplitQuantity, // æ–°æ¡ç èŽ·å¾—拆分数量
        //            OutboundQuantity = request.SplitQuantity,
        //            Barcode = newBarcode,
        //            InboundOrderRowNo = baseStockDetail.InboundOrderRowNo,

        //        };
        //        await _outStockLockInfoService.Db.Insertable(newStockDetail).ExecuteCommandAsync();

        //        // 4. åˆ›å»ºæ–°çš„出库锁定信息（新条码）
        //        var newLockInfo = new Dt_OutStockLockInfo
        //        {

        //            OrderNo = lockInfo.OrderNo,
        //            OrderDetailId = lockInfo.OrderDetailId,
        //            BatchNo = lockInfo.BatchNo,
        //            MaterielCode = lockInfo.MaterielCode,
        //            MaterielName = lockInfo.MaterielName,
        //            StockId = lockInfo.StockId,
        //            OrderQuantity = request.SplitQuantity,
        //            OriginalQuantity = request.SplitQuantity,
        //            AssignQuantity = request.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, // æ–°æ¡ç 
        //            OriginalLockQuantity = request.SplitQuantity,
        //            IsSplitted = 1,
        //            ParentLockId = lockInfo.Id // è®°å½•çˆ¶çº§é”å®šID
        //        };
        //        await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();

        //        lockInfo.AssignQuantity = remainingQty;
        //        lockInfo.IsSplitted = 1; // æ ‡è®°ä¸ºå·²æ‹†åŒ…
        //        await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

        //        var previousSplitRecord = await Db.Queryable<Dt_SplitPackageRecord>()
        //      .Where(x => x.OriginalBarcode == request.OriginalBarcode && !x.IsReverted)
        //      .OrderByDescending(x => x.SplitTime)
        //      .FirstAsync();

        //        // 6. è®°å½•æ‹†åŒ…历史（用于追踪）
        //        var splitHistory = new Dt_SplitPackageRecord
        //        {
        //            FactoryArea = lockInfo.FactoryArea,
        //            TaskNum = lockInfo.TaskNum,
        //            OutStockLockInfoId = lockInfo.Id,
        //            StockId = baseStockDetail.StockId,
        //            Operator = App.User.UserName,
        //            IsReverted = false,
        //            OriginalBarcode = request.OriginalBarcode,
        //            NewBarcode = newBarcode,
        //            SplitQty = request.SplitQuantity,
        //            RemainQuantity = remainingQty, // è®°å½•æ‹†åˆ†åŽçš„剩余数量
        //            MaterielCode = lockInfo.MaterielCode,
        //            SplitTime = DateTime.Now,
        //            OrderNo = request.OrderNo,
        //            PalletCode = request.PalletCode,
        //            Status = (int)SplitPackageStatusEnum.已拆包,
        //            PreviousSplitRecordId = previousSplitRecord?.Id??0 // è®°å½•å‰ä¸€æ¬¡æ‹†åŒ…ID，建立拆包链
        //        };
        //        await Db.Insertable(splitHistory).ExecuteCommandAsync();

        //        _unitOfWorkManage.CommitTran();

        //        try
        //        {
        //            MaterielToMesDTO dto = new MaterielToMesDTO
        //            {
        //                batchNo = baseStockDetail.BatchNo,
        //                factoryArea = baseStockDetail.FactoryArea,
        //                materialCode = baseStockDetail.MaterielCode,
        //                newmaterialCode = newBarcode,
        //                oldmaterialCode = request.OriginalBarcode,
        //                operationType = 1,
        //                qty = remainingQty,
        //                supplyCode = baseStockDetail.SupplyCode,
        //                unit = baseStockDetail.BarcodeUnit,
        //                warehouseCode = baseStockDetail.WarehouseCode,
        //                reqCode = Guid.NewGuid().ToString(),
        //                reqTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
        //            };
        //            _invokeMESService.NewMaterielToMes(dto);
        //        }
        //        catch(Exception ex)
        //        {
        //            _logger.LogError("SplitPackage å›žä¼ MES:  " + ex.Message);
        //        }
        //        return WebResponseContent.Instance.OK("拆包成功", new
        //        {
        //            NewBarcode = newBarcode,
        //            NewLockInfoId = newLockInfo.Id
        //        });
        //    }
        //    catch (Exception ex)
        //    {
        //        _unitOfWorkManage.RollbackTran();
        //        return WebResponseContent.Instance.Error($"拆包失败: {ex.Message}");
        //    }
        //}
        // èŽ·å–条码的拆包历史链

        public async Task<WebResponseContent> SplitPackage(SplitPackageDto request)
        {
            try
@@ -67,58 +230,63 @@
                if (request.SplitQuantity > remainingLockQuantity)
                    return WebResponseContent.Instance.Error($"拆包数量不能大于剩余锁定数量，剩余：{remainingLockQuantity}");

                var stockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                // 3. æŸ¥æ‰¾å½“前条码的库存信息
                var baseStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
               .Where(x => x.Barcode == request.OriginalBarcode && x.StockId == lockInfo.StockId)
               .FirstAsync();
                if (stockDetail == null)

                if (baseStockDetail == null)
                    throw new Exception($"未找到条码{request.OriginalBarcode}对应的库存记录");

                stockDetail.StockQuantity = request.SplitQuantity;
                stockDetail.OutboundQuantity = request.SplitQuantity;
                _stockInfoDetailService.Db.Updateable<Dt_StockInfoDetail>(stockDetail).ExecuteCommand();
                // 4. è®°å½•æ‹†åŒ…前的库存数量和锁定信息
                decimal stockBeforeSplit = baseStockDetail.StockQuantity;
                decimal assignBeforeSplit = lockInfo.AssignQuantity;

                // 5. è®¡ç®—拆分后的剩余数量
                decimal remainingQty = baseStockDetail.StockQuantity - request.SplitQuantity;

                // æ›´æ–°åŸºç¡€æ¡ç çš„库存数量为剩余数量
                baseStockDetail.StockQuantity = remainingQty;
                baseStockDetail.OutboundQuantity = remainingQty;
                await _stockInfoDetailService.Db.Updateable(baseStockDetail).ExecuteCommandAsync();

                // 6. ç”Ÿæˆæ–°æ¡ç 
                var seq = await _dailySequenceService.GetNextSequenceAsync();
                // 3. ç”Ÿæˆæ–°æ¡ç 
                string newBarcode = "WSLOT" + DateTime.Now.ToString("yyyyMMdd") + seq.ToString()?.PadLeft(5, '0');

                decimal remainingQty = remainingLockQuantity - request.SplitQuantity;

                // ä¸ºæ‹†åŒ…产生的新条码创建库存记录
                // 7. ä¸ºæ–°æ¡ç åˆ›å»ºåº“存记录（拆分出的数量）
                var newStockDetail = new Dt_StockInfoDetail
                {
                    SupplyCode = stockDetail.SupplyCode,
                    WarehouseCode = stockDetail.WarehouseCode,
                    BarcodeQty = stockDetail.BarcodeQty,
                    BarcodeUnit = stockDetail.BarcodeUnit,
                    BusinessType = stockDetail.BusinessType,
                    Unit = stockDetail.Unit,
                    SupplyCode = baseStockDetail.SupplyCode,
                    WarehouseCode = baseStockDetail.WarehouseCode,
                    BarcodeQty = baseStockDetail.BarcodeQty,
                    BarcodeUnit = baseStockDetail.BarcodeUnit,
                    BusinessType = baseStockDetail.BusinessType,
                    Unit = baseStockDetail.Unit,
                    StockId = lockInfo.StockId,
                    MaterielCode = stockDetail.MaterielCode,
                    OrderNo = stockDetail.OrderNo,
                    BatchNo = stockDetail.BatchNo,
                    StockQuantity = remainingQty,
                    OutboundQuantity = remainingQty, // é”å®šå…¨éƒ¨æ•°é‡
                    MaterielCode = baseStockDetail.MaterielCode,
                    OrderNo = baseStockDetail.OrderNo,
                    BatchNo = baseStockDetail.BatchNo,
                    StockQuantity = request.SplitQuantity,
                    OutboundQuantity = request.SplitQuantity,
                    Barcode = newBarcode,
                    InboundOrderRowNo = stockDetail.InboundOrderRowNo,

                    InboundOrderRowNo = baseStockDetail.InboundOrderRowNo,
                };
                await _outStockLockInfoService.Db.Insertable(newStockDetail).ExecuteCommandAsync();
                await _stockInfoDetailService.Db.Insertable(newStockDetail).ExecuteCommandAsync();

                // 4. åˆ›å»ºæ–°çš„出库锁定信息（新条码）
                // 8. åˆ›å»ºæ–°çš„出库锁定信息（新条码）
                var newLockInfo = new Dt_OutStockLockInfo
                {

                    OrderNo = lockInfo.OrderNo,
                    OrderDetailId = lockInfo.OrderDetailId,
                    BatchNo = lockInfo.BatchNo,
                    MaterielCode = lockInfo.MaterielCode,
                    MaterielName = lockInfo.MaterielName,
                    StockId = lockInfo.StockId,
                    OrderQuantity = remainingQty,
                    OriginalQuantity = remainingQty,
                    AssignQuantity = remainingQty, // æ–°æ¡ç åˆ†é…æ•°é‡
                    PickedQty = 0, // æ–°æ¡ç æœªæ‹£é€‰
                    OrderQuantity = request.SplitQuantity,
                    OriginalQuantity = request.SplitQuantity,
                    AssignQuantity = request.SplitQuantity,
                    PickedQty = 0,
                    LocationCode = lockInfo.LocationCode,
                    PalletCode = lockInfo.PalletCode,
                    TaskNum = lockInfo.TaskNum,
@@ -126,30 +294,33 @@
                    Unit = lockInfo.Unit,
                    SupplyCode = lockInfo.SupplyCode,
                    OrderType = lockInfo.OrderType,
                    CurrentBarcode = newBarcode, // æ–°æ¡ç 
                    CurrentBarcode = newBarcode,
                    OriginalLockQuantity = request.SplitQuantity,
                    IsSplitted = 1,
                    ParentLockId = lockInfo.Id // è®°å½•çˆ¶çº§é”å®šID
                    ParentLockId = lockInfo.Id
                };
                await _outStockLockInfoService.Db.Insertable(newLockInfo).ExecuteCommandAsync();

                // 5. æ›´æ–°åŽŸé”å®šä¿¡æ¯çš„分配数量（减少拆包数量）
                lockInfo.AssignQuantity = request.SplitQuantity;
                // 9. æ›´æ–°åŽŸé”å®šä¿¡æ¯çš„分配数量（减少拆包数量）
                lockInfo.AssignQuantity = remainingQty;
                lockInfo.IsSplitted = 1;
                await _outStockLockInfoService.Db.Updateable(lockInfo).ExecuteCommandAsync();

                // 6. è®°å½•æ‹†åŒ…历史（用于追踪）
                // 10. è®°å½•æ‹†åŒ…历史
                var splitHistory = new Dt_SplitPackageRecord
                {
                    FactoryArea = lockInfo.FactoryArea,
                    TaskNum = lockInfo.TaskNum,
                    OutStockLockInfoId = lockInfo.Id,
                    StockId = stockDetail?.StockId ?? 0,
                    StockId = baseStockDetail.StockId,
                    Operator = App.User.UserName,
                    IsReverted = false,
                    OriginalBarcode = lockInfo.CurrentBarcode,
                    OriginalBarcode = request.OriginalBarcode,
                    NewBarcode = newBarcode,
                    SplitQty = request.SplitQuantity,
                    RemainQuantity = lockInfo.OriginalQuantity - request.SplitQuantity,
                    RemainQuantity = remainingQty,
                    StockBeforeSplit = stockBeforeSplit, // è®°å½•æ‹†åŒ…前的库存数量
                    AssignBeforeSplit = assignBeforeSplit, // è®°å½•æ‹†åŒ…前的分配数量
                    MaterielCode = lockInfo.MaterielCode,
                    SplitTime = DateTime.Now,
                    OrderNo = request.OrderNo,
@@ -160,33 +331,11 @@

                _unitOfWorkManage.CommitTran();
                              
                try
                {
                    MaterielToMesDTO dto = new MaterielToMesDTO
                    {
                        batchNo = stockDetail.BatchNo,
                        factoryArea = stockDetail.FactoryArea,
                        materialCode = stockDetail.MaterielCode,
                        newmaterialCode = newBarcode,
                        oldmaterialCode = request.OriginalBarcode,
                        operationType = 1,
                        qty = remainingQty,
                        supplyCode = stockDetail.SupplyCode,
                        unit = stockDetail.BarcodeUnit,
                        warehouseCode = stockDetail.WarehouseCode,
                        reqCode = Guid.NewGuid().ToString(),
                        reqTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
                    };
                    _invokeMESService.NewMaterielToMes(dto);
                }
                catch(Exception ex)
                {
                    _logger.LogError("SplitPackage å›žä¼ MES:  " + ex.Message);
                }
                return WebResponseContent.Instance.OK("拆包成功", new
                return WebResponseContent.Instance.OK("拆包成功", new SplitPackageChainDto
                {
                    NewBarcode = newBarcode,
                    NewLockInfoId = newLockInfo.Id
                    NewLockInfoId = newLockInfo.Id,
                    RemainQuantity = remainingQty
                });
            }
            catch (Exception ex)
@@ -196,6 +345,95 @@
            }
        }

        public async Task<WebResponseContent> RevertSplitPackage(string originalBarcode)
        {
            try
            {
                _unitOfWorkManage.BeginTran();

                // 1. æŸ¥æ‰¾è¯¥æ¡ç ä½œä¸ºåŽŸå§‹æ¡ç çš„所有未撤销拆包记录，按时间倒序
                var splitRecords = await Db.Queryable<Dt_SplitPackageRecord>()
                        .Where(x => x.OriginalBarcode == originalBarcode && !x.IsReverted)
                        .OrderByDescending(x => x.SplitTime)
                        .ToListAsync();

                if (splitRecords == null || !splitRecords.Any())
                    return WebResponseContent.Instance.Error("未找到可撤销的拆包记录");

                // 2. æ£€æŸ¥æ‰€æœ‰æ–°æ¡ç æ˜¯å¦å·²æ‹£é€‰
                var newBarcodes = splitRecords.Select(x => x.NewBarcode).ToList();
                var newLockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => newBarcodes.Contains(x.CurrentBarcode))
                    .ToListAsync();

                var pickedBarcodes = newLockInfos.Where(x => x.Status == 2).Select(x => x.CurrentBarcode).ToList();
                if (pickedBarcodes.Any())
                    return WebResponseContent.Instance.Error($"以下条码已拣选，无法撤销拆包：{string.Join(",", pickedBarcodes)}");

                // 3. èŽ·å–原条码的锁定信息和库存信息
                var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.CurrentBarcode == originalBarcode)
                    .FirstAsync();

                if (originalLockInfo == null)
                    return WebResponseContent.Instance.Error("未找到原条码锁定信息");

                var originalStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.Barcode == originalBarcode && x.StockId == originalLockInfo.StockId)
                    .FirstAsync();

                if (originalStockDetail == null)
                    return WebResponseContent.Instance.Error("未找到原条码库存信息");

                // 4. æŸ¥æ‰¾ç¬¬ä¸€æ¬¡æ‹†åŒ…记录，获取拆包前的状态
                var firstSplitRecord = splitRecords.OrderBy(x => x.SplitTime).FirstOrDefault();
                if (firstSplitRecord == null)
                    return WebResponseContent.Instance.Error("未找到有效的拆包记录");

                // 5. æ¢å¤åŽŸæ¡ç åˆ°æ‹†åŒ…前的状态
                originalStockDetail.StockQuantity = firstSplitRecord.StockBeforeSplit;
                originalStockDetail.OutboundQuantity = firstSplitRecord.StockBeforeSplit;
                await _stockInfoDetailService.Db.Updateable(originalStockDetail).ExecuteCommandAsync();

                // 6. æ¢å¤åŽŸæ¡ç é”å®šä¿¡æ¯åˆ°æ‹†åŒ…前的状态
                originalLockInfo.AssignQuantity = firstSplitRecord.AssignBeforeSplit;
                originalLockInfo.OriginalQuantity = firstSplitRecord.AssignBeforeSplit;
                originalLockInfo.OrderQuantity = firstSplitRecord.AssignBeforeSplit;
                originalLockInfo.Status = (int)OutLockStockStatusEnum.出库中;
                originalLockInfo.IsSplitted = 0; // æ¢å¤ä¸ºæœªæ‹†åŒ…状态
                await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();

                // 7. åˆ é™¤æ‰€æœ‰æ–°æ¡ç çš„锁定信息
                await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
                    .Where(x => newBarcodes.Contains(x.CurrentBarcode))
                    .ExecuteCommandAsync();

                // 8. åˆ é™¤æ‰€æœ‰æ–°æ¡ç çš„库存记录
                await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
                    .Where(x => newBarcodes.Contains(x.Barcode))
                    .ExecuteCommandAsync();

                // 9. æ ‡è®°æ‰€æœ‰æ‹†åŒ…记录为已撤销
                foreach (var record in splitRecords)
                {
                    record.IsReverted = true;
                    record.RevertTime = DateTime.Now;
         
                    record.Status = (int)SplitPackageStatusEnum.已撤销;
                }
                await Db.Updateable(splitRecords).ExecuteCommandAsync();

                _unitOfWorkManage.CommitTran();

                return WebResponseContent.Instance.OK($"撤销拆包成功，共撤销{splitRecords.Count}次拆包，{originalBarcode}恢复为拆包前数量：{firstSplitRecord.StockBeforeSplit}");

            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error($"撤销拆包失败：{ex.Message}");
            }
        }
 
        //public async Task<WebResponseContent> RevertSplitPackage(string originalBarcode)
        //{
@@ -284,100 +522,18 @@
        //    }
        //}
 
        public async Task<WebResponseContent> RevertSplitPackage(string originalBarcode)
        {
            try
            {
                _unitOfWorkManage.BeginTran();

                // 1. æŸ¥æ‰¾æ‰€æœ‰æœªæ’¤é”€çš„拆包记录
                var splitRecords = await Db.Queryable<Dt_SplitPackageRecord>()
        // èŽ·å–可撤销的拆包记录列表
        public Dt_SplitPackageRecord GetRevertableSplitRecords(string originalBarcode)
        {
            var revertableRecords =   Db.Queryable<Dt_SplitPackageRecord>()
                        .Where(x => x.OriginalBarcode == originalBarcode && !x.IsReverted)
                        .OrderBy(x => x.SplitTime) // æŒ‰æ—¶é—´æ­£åºï¼Œä»Žæœ€æ—©å¼€å§‹æ’¤é”€
                        .ToListAsync();
                    .OrderBy(x => x.SplitTime)
                   .First();

                if (splitRecords == null || !splitRecords.Any())
                    return WebResponseContent.Instance.Error("未找到可撤销的拆包记录");

                // 2. æ£€æŸ¥æ‰€æœ‰æ–°æ¡ç æ˜¯å¦å·²æ‹£é€‰
                var newBarcodes = splitRecords.Select(x => x.NewBarcode).ToList();
                var newLockInfos = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => newBarcodes.Contains(x.CurrentBarcode))
                    .ToListAsync();

                var pickedBarcodes = newLockInfos.Where(x => x.Status == 2).Select(x => x.CurrentBarcode).ToList();
                if (pickedBarcodes.Any())
                    return WebResponseContent.Instance.Error($"以下条码已拣选，无法撤销：{string.Join(",", pickedBarcodes)}");

                // 3. èŽ·å–原条码信息
                var originalLockInfo = await _outStockLockInfoService.Db.Queryable<Dt_OutStockLockInfo>()
                    .Where(x => x.CurrentBarcode == originalBarcode)
                    .FirstAsync();

                if (originalLockInfo == null)
                    return WebResponseContent.Instance.Error("未找到原条码锁定信息");

                var originalStockDetail = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => x.Barcode == originalBarcode && x.StockId == originalLockInfo.StockId)
                    .FirstAsync();

                // 4. èŽ·å–所有新条码的库存记录
                var newStockDetails = await _stockInfoDetailService.Db.Queryable<Dt_StockInfoDetail>()
                    .Where(x => newBarcodes.Contains(x.Barcode))
                    .ToListAsync();

                // 5. è®¡ç®—总还原数量
                decimal totalRevertQty = newStockDetails.Sum(x => x.StockQuantity);

                // 6. è¿˜åŽŸåŽŸæ¡ç åº“存记录
                if (originalStockDetail != null)
                {
                    // åŽŸæ¡ç å½“前数量加上所有新条码的数量
                    originalStockDetail.StockQuantity += totalRevertQty;
                    originalStockDetail.OutboundQuantity += totalRevertQty;
                    await _stockInfoDetailService.Db.Updateable(originalStockDetail).ExecuteCommandAsync();
            return   revertableRecords ;
                }

                // 7. è¿˜åŽŸåŽŸæ¡ç é”å®šä¿¡æ¯
                decimal totalAssignQty = newLockInfos.Sum(x => x.AssignQuantity);
                originalLockInfo.AssignQuantity += totalAssignQty;
                if (originalLockInfo.OrderQuantity < originalLockInfo.AssignQuantity)
                {
                    originalLockInfo.AssignQuantity=originalLockInfo.OrderQuantity;
                }
                originalLockInfo.Status = (int)OutLockStockStatusEnum.出库中;
                originalLockInfo.IsSplitted = 0;
                await _outStockLockInfoService.Db.Updateable(originalLockInfo).ExecuteCommandAsync();

                // 8. åˆ é™¤æ‰€æœ‰æ–°æ¡ç çš„锁定信息
                await _outStockLockInfoService.Db.Deleteable<Dt_OutStockLockInfo>()
                    .Where(x => newBarcodes.Contains(x.CurrentBarcode))
                    .ExecuteCommandAsync();

                // 9. åˆ é™¤æ‰€æœ‰æ–°æ¡ç çš„库存记录
                await _stockInfoDetailService.Db.Deleteable<Dt_StockInfoDetail>()
                    .Where(x => newBarcodes.Contains(x.Barcode))
                    .ExecuteCommandAsync();

                // 10. æ ‡è®°æ‰€æœ‰æ‹†åŒ…记录为已撤销
                foreach (var record in splitRecords)
                {
                    record.IsReverted = true;
              
                }
                await Db.Updateable(splitRecords).ExecuteCommandAsync();

                _unitOfWorkManage.CommitTran();

                return WebResponseContent.Instance.OK($"撤销拆包成功，共还原{splitRecords.Count}次拆包，总数量：{totalRevertQty}");

            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return WebResponseContent.Instance.Error($"撤销拆包失败：{ex.Message}");
            }
        }
        // èŽ·å–拆包信息
        public async Task<WebResponseContent> GetSplitPackageInfo(string orderNo, string palletCode, string barcode)
        {