1

huangxiaoqiang

2025-12-18 9753fb2756f6b4e30ff79d901a7bb86145517c8b

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

@@ -1,6 +1,15 @@
using Newtonsoft.Json;
using AutoMapper;
using Dm.filter;
using MailKit.Search;
using Mapster;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using Org.BouncyCastle.Asn1.Ocsp;
using Org.BouncyCastle.Crypto;
using SqlSugar;
using System.Reflection.Emit;
using WIDESEA_BasicService;
using WIDESEA_Common.CommonEnum;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.OrderEnum;
using WIDESEA_Common.StockEnum;
@@ -9,6 +18,7 @@
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.CodeConfigEnum;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Basic;
using WIDESEA_DTO.CalcOut;
using WIDESEA_DTO.ReturnMES;
using WIDESEA_IBasicService;
@@ -21,7 +31,7 @@
{
    public partial class OutboundService : IOutboundService
    {

        private readonly IMapper _mapper;
        public IUnitOfWorkManage _unitOfWorkManage { get; }

        public IOutboundOrderDetailService OutboundOrderDetailService { get; }
@@ -42,9 +52,26 @@
        private readonly IRepository<Dt_LocationInfo> _locationInfoRepository;
        private readonly IRepository<Dt_StockQuantityChangeRecord> _stockChangeRepository;
        private readonly IRepository<Dt_StockInfoDetail_Hty> _stockDetailHistoryRepository;
        private readonly IFeedbackMesService _feedbackMesService;
        private readonly IRepository<Dt_Task> _taskRepository;
        private readonly ILocationInfoService _locationInfoService;
        private readonly IESSApiService _eSSApiService;

        public OutboundService(IUnitOfWorkManage unitOfWorkManage, IRepository<Dt_OutboundOrderDetail> detailRepository, IRepository<Dt_OutboundOrder> outboundRepository, IRepository<Dt_OutStockLockInfo> outboundLockInfoRepository, IRepository<Dt_StockInfo> stockInfoRepository, IRepository<Dt_StockInfoDetail> stockDetailRepository, IRepository<Dt_StockQuantityChangeRecord> stockChangeRepository, IRepository<Dt_StockInfoDetail_Hty> stockDetailHistoryRepository, IBasicService basicService, IOutboundOrderDetailService outboundOrderDetailService, IOutboundOrderService outboundOrderService, IOutStockLockInfoService outboundStockLockInfoService)
        private Dictionary<string, string> stations = new Dictionary<string, string>
        {
            {"2-1","2-9" },
            {"3-1","3-9" },
        };

        private Dictionary<string, string> movestations = new Dictionary<string, string>
        {
            {"2-1","2-5" },
            {"3-1","3-5" },
        };

        public OutboundService(IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IRepository<Dt_OutboundOrderDetail> detailRepository, IRepository<Dt_OutboundOrder> outboundRepository, IRepository<Dt_OutStockLockInfo> outboundLockInfoRepository, IRepository<Dt_StockInfo> stockInfoRepository, IRepository<Dt_StockInfoDetail> stockDetailRepository, IRepository<Dt_StockQuantityChangeRecord> stockChangeRepository, IRepository<Dt_StockInfoDetail_Hty> stockDetailHistoryRepository, IBasicService basicService, IOutboundOrderDetailService outboundOrderDetailService, IOutboundOrderService outboundOrderService, IOutStockLockInfoService outboundStockLockInfoService, IFeedbackMesService feedbackMesService, IRepository<Dt_Task> taskRepository, ILocationInfoService locationInfoService, IESSApiService eSSApiService)
        {
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
            Db = _unitOfWorkManage.GetDbClient();
            OutboundOrderDetailService = outboundOrderDetailService;
@@ -59,8 +86,13 @@
            _stockChangeRepository = stockChangeRepository;
            _stockDetailHistoryRepository = stockDetailHistoryRepository;
            _basicService = basicService;
            _feedbackMesService = feedbackMesService;
            _taskRepository = taskRepository;
            _locationInfoService = locationInfoService;
            _eSSApiService = eSSApiService;
        }

        #region å‡ºåº“分配
        /// <summary>
        /// åˆ†æ‹£å‡ºåº“操作
        /// </summary>
@@ -133,14 +165,18 @@

                    pickedDetails.AddRange(materielPickedDetails.PickedDetails);

                    decimal allallocatedQuantity = materielCalc.UnallocatedQuantity;
                    // æ›´æ–°å‡ºåº“单明细（增加锁定数量，不增加已出数量）
                    foreach (var detail in materielCalc.Details)
                    {
                        if (allallocatedQuantity <= 0) break;

                        decimal lockQuantity = (detail.OrderQuantity - detail.OverOutQuantity);
                        if (lockQuantity < materielCalc.UnallocatedQuantity)
                        {
                            detail.LockQuantity += lockQuantity; // å¢žåŠ é”å®šæ•°é‡ ä¸æ›´æ–° OverOutQuantity å’Œ OrderDetailStatus，因为还没有实际出库
                            outboundOrderDetails.Add(detail);
                            materielCalc.UnallocatedQuantity -= lockQuantity;
                        }
                        else
                        {
@@ -165,6 +201,9 @@

                // 7. æ›´æ–°åº“存详情
                UpdateOutStockLockInfo(outStockLockInfos);

                // 8. æ·»åŠ ä»»åŠ¡æ•°æ®
                _taskRepository.AddData(tasks);

                _unitOfWorkManage.CommitTran();

@@ -210,7 +249,7 @@

                if (outboundOrder.IsBatch == 1)
                {
                    selectedDetails = _detailRepository.QueryData(x => x.WarehouseCode == selectedDetails.First().WarehouseCode && x.MaterielCode == selectedDetails.First().MaterielCode && x.BatchNo == selectedDetails.First().BatchNo && x.SupplyCode == selectedDetails.First().SupplyCode);
                    selectedDetails = _detailRepository.QueryData(x => x.OrderId == selectedDetails.First().OrderId && x.WarehouseCode == selectedDetails.First().WarehouseCode && x.MaterielCode == selectedDetails.First().MaterielCode && x.BatchNo == selectedDetails.First().BatchNo && x.SupplyCode == selectedDetails.First().SupplyCode);
                }


@@ -262,6 +301,18 @@
                        return result;
                    }

                    decimal inputQuantity = request.OutboundQuantity.Value;
                    List<Dt_OutboundOrderDetail> outboundOrderDetails = new List<Dt_OutboundOrderDetail>();
                    foreach (var item in selectedDetails)
                    {
                        inputQuantity -= (item.OrderQuantity - item.MoveQty - item.LockQuantity);
                        outboundOrderDetails.Add(item);
                        if (inputQuantity <= 0)
                        {
                            break;
                        }
                    }

                    result.MaterielCalculations = new List<MaterielOutboundCalculationDTO>()
                    {
                        new MaterielOutboundCalculationDTO
@@ -276,9 +327,11 @@
                            AssignedQuantity = lockQuantity,
                            UnallocatedQuantity = request.OutboundQuantity.Value,
                            MovedQuantity = moveQuantity,
                            Details = selectedDetails
                            Details = outboundOrderDetails
                        }
                    };

                    outboundOrder.Details = outboundOrderDetails;
                }

                result.CanOutbound = true;
@@ -783,8 +836,335 @@
                return false;
            }
        }
        #endregion



        public WebResponseContent CompleteOutboundWithPallet(OutboundCompletePalletRequestDTO request)
        {
            WebResponseContent content = WebResponseContent.Instance;

            OutboundCompleteResponseDTO response = new();
            try
            {
                // 1. æ ¹æ®æ‰˜ç›˜å·æŸ¥æ‰¾åº“存信息
                Dt_StockInfo stockInfo = _stockInfoRepository.Db.Queryable<Dt_StockInfo>().Where(x => x.PalletCode == request.PalletCode).Includes(x => x.Details).First();
                if (stockInfo == null)
                {
                    response.Success = false;
                    response.Message = $"托盘号 {request.PalletCode} å¯¹åº”的库存不存在";
                    return WebResponseContent.Instance.Error(response.Message);
                }

                if (!stockInfo.Details.Any())
                {
                    response.Success = false;
                    response.Message = $"托盘 {request.PalletCode} å¯¹åº”的库存明细不存在";
                    return WebResponseContent.Instance.Error(response.Message);
                }

                bool isMatMixed = stockInfo.Details.GroupBy(x => new
                {
                    x.MaterielCode,
                    x.MaterielName,
                    x.BatchNo,
                    x.SupplyCode,
                    x.WarehouseCode
                }).Count() > 1;

                if (isMatMixed)
                {
                    response.Success = false;
                    response.Message = $"混料托盘 {request.PalletCode} ä¸èƒ½æ•´ç®±å‡ºåº“";
                    return WebResponseContent.Instance.Error(response.Message);
                }

                // 2. æŸ¥æ‰¾å‡ºåº“单信息
                Dt_OutboundOrder outboundOrder = _outboundRepository.QueryFirst(o => o.OrderNo == request.OrderNo);
                if (outboundOrder == null)
                {
                    response.Success = false;
                    response.Message = $"出库单 {request.OrderNo} ä¸å­˜åœ¨";
                    return WebResponseContent.Instance.Error(response.Message);
                }

                Dt_StockInfoDetail stockInfoDetail = stockInfo.Details.First();

                // 3. æŸ¥æ‰¾é”å®šè®°å½•
                Dt_OutStockLockInfo lockInfo = _outboundLockInfoRepository.QueryFirst(x =>
                    x.OrderNo == request.OrderNo &&
                    x.StockId == stockInfo.Id &&
                    x.MaterielCode == stockInfoDetail.MaterielCode &&
                    x.PalletCode == stockInfo.PalletCode);

                if (lockInfo == null || lockInfo.AssignQuantity <= 0)
                {
                    response.Success = false;
                    response.Message = $"该库存没有分配出库量，托盘号：{request.PalletCode}";
                    return WebResponseContent.Instance.Error(response.Message);
                }

                // æ‰¾å‡ºå·²åˆ†é…çš„订单明细Id
                List<int> detailIds = new List<int>();
                string[] ids = lockInfo.OrderDetailIds.Split(",");
                foreach (string id in ids)
                {
                    if (int.TryParse(id, out int detailId))
                    {
                        detailIds.Add(detailId);
                    }
                }
                // 4. æŸ¥æ‰¾å‡ºåº“单明细信息
                List<Dt_OutboundOrderDetail> outboundOrderDetails = FindMatchingOutboundDetails(outboundOrder.Id, stockInfoDetail, detailIds);
                if (!outboundOrderDetails.Any())
                {
                    response.Success = false;
                    response.Message = $"未找到匹配的出库单明细，物料：{stockInfoDetail.MaterielCode}，批次：{stockInfoDetail.BatchNo}";
                    return WebResponseContent.Instance.Error(response.Message);
                }

                decimal totalStockQuantity = stockInfo.Details.Sum(x => x.StockQuantity);

                // 5. è®¡ç®—实际出库量
                decimal actualOutboundQuantity = CalculateActualOutboundQuantity(stockInfo.Details, outboundOrderDetails, lockInfo);// éœ€å‡ºåº“量

                if (actualOutboundQuantity <= 0)
                {
                    decimal totalAllocatedQuantity = lockInfo.AllocatedQuantity;
                    decimal availableOutboundQuantity = lockInfo.AssignQuantity - totalAllocatedQuantity;
                    decimal detailRemainingQuantity = outboundOrderDetails.Sum(x => x.OrderQuantity - x.OverOutQuantity - x.MoveQty);

                    response.Success = false;
                    response.Message = $"无法出库，托盘号：{request.PalletCode}，库存量：{totalStockQuantity}，已出库：{totalAllocatedQuantity}，分配量：{lockInfo.AssignQuantity}，明细剩余：{detailRemainingQuantity}";
                    return WebResponseContent.Instance.Error(response.Message);
                }

                if (lockInfo.AssignQuantity != totalStockQuantity)
                {
                    response.Success = false;
                    response.Message = $"无法出库，托盘号：{request.PalletCode}，库存量：{totalStockQuantity}，分配量：{lockInfo.AssignQuantity}";
                    return WebResponseContent.Instance.Error(response.Message);
                }

                // 6. å¼€å¯äº‹åŠ¡
                _unitOfWorkManage.BeginTran();
                try
                {
                    // æ•´ç®±å‡ºåº“无需拆包
                    PerformFullOutboundOperation(stockInfo, request, lockInfo.TaskNum.GetValueOrDefault());


                    decimal allocatedQuantity = actualOutboundQuantity;
                    List<Dt_OutboundOrderDetail> updateDetails = new();
                    foreach (var item in outboundOrderDetails)
                    {
                        if (allocatedQuantity <= 0) break;


                        //if (item.OrderQuantity - item.MoveQty - item.OverOutQuantity >= allocatedQuantity)
                        //{
                        //    item.OverOutQuantity += allocatedQuantity;
                        //    allocatedQuantity = 0;
                        //}
                        //else
                        //{
                        //    allocatedQuantity -= (item.OrderQuantity - item.MoveQty - item.OverOutQuantity);
                        //    item.OverOutQuantity = item.OrderQuantity - item.MoveQty;
                        //}
                        List<Barcodes> barcodesList = new List<Barcodes>();
                        List<Dt_StockInfoDetail> stockInfoDetails = stockInfo.Details.Where((x => x.StockQuantity > x.OutboundQuantity)).ToList();
                        foreach (var stockDetail in stockInfoDetails)
                        {
                            if (item.LockQuantity - item.OverOutQuantity >= stockDetail.StockQuantity - stockInfoDetail.OutboundQuantity)
                            {
                                Barcodes barcodes = new Barcodes
                                {
                                    Barcode = stockDetail.Barcode,
                                    Qty = stockDetail.StockQuantity - stockInfoDetail.OutboundQuantity,
                                    SupplyCode = stockDetail?.SupplyCode ?? "",
                                    BatchNo = stockDetail?.BatchNo ?? "",
                                    Unit = stockDetail?.Unit ?? ""
                                };

                                stockDetail.StockQuantity = stockInfoDetail.OutboundQuantity;
                                barcodesList.Add(barcodes);
                            }
                            else
                            {
                                Barcodes barcodes = new Barcodes
                                {
                                    Barcode = stockDetail.Barcode,
                                    Qty = item.LockQuantity - item.OverOutQuantity,
                                    SupplyCode = stockDetail?.SupplyCode ?? "",
                                    BatchNo = stockDetail?.BatchNo ?? "",
                                    Unit = stockDetail?.Unit ?? ""
                                };
                                stockInfoDetail.OutboundQuantity += item.LockQuantity - item.OverOutQuantity;
                                barcodesList.Add(barcodes);
                            }
                        }

                        decimal barcodeQuantity = allocatedQuantity;

                        if (item.LockQuantity - item.OverOutQuantity >= allocatedQuantity)
                        {
                            item.OverOutQuantity += allocatedQuantity;
                            item.CurrentDeliveryQty += allocatedQuantity;
                            allocatedQuantity = 0;
                        }
                        else
                        {
                            barcodeQuantity = item.LockQuantity - item.OverOutQuantity;
                            allocatedQuantity -= (item.LockQuantity - item.OverOutQuantity);
                            item.OverOutQuantity = item.LockQuantity;
                            item.CurrentDeliveryQty = item.LockQuantity;
                        }

                        updateDetails.Add(item);


                        if (!string.IsNullOrEmpty(item.ReturnJsonData))
                        {
                            barcodesList.AddRange(JsonConvert.DeserializeObject<List<Barcodes>>(item.ReturnJsonData) ?? new List<Barcodes>());
                        }

                        JsonSerializerSettings settings = new JsonSerializerSettings
                        {
                            ContractResolver = new CamelCasePropertyNamesContractResolver()
                        };
                        item.ReturnJsonData = JsonConvert.SerializeObject(barcodesList, settings);
                    }

                    lockInfo.SortedQuantity = lockInfo.SortedQuantity + actualOutboundQuantity;

                    if (lockInfo.SortedQuantity == lockInfo.AssignQuantity)
                    {
                        _outboundLockInfoRepository.DeleteAndMoveIntoHty(lockInfo, WIDESEA_Core.Enums.OperateTypeEnum.自动完成);
                    }
                    else
                    {
                        // æ›´æ–°é”å®šè®°å½•
                        _outboundLockInfoRepository.UpdateData(lockInfo);
                    }

                    // æ›´æ–°å‡ºåº“单明细的已出库数量
                    _detailRepository.UpdateData(updateDetails);

                    // æ›´æ–°é”å®šè®°å½•çš„累计已出库数量（需要更新该托盘该物料的所有相关记录）
                    //UpdateLockInfoAllocatedQuantity(stockInfo.Id, stockDetail.MaterielCode, stockDetail.BatchNo, actualOutboundQuantity);

                    // æäº¤äº‹åŠ¡
                    _unitOfWorkManage.CommitTran();

                    response.Success = true;
                    response.Message = "出库完成";
                    response.UpdatedDetails = updateDetails;

                    // æ£€æŸ¥å‡ºåº“单是否完成
                    if (CheckOutboundOrderCompleted(request.OrderNo))
                    {
                        UpdateOutboundOrderStatus(request.OrderNo, OutOrderStatusEnum.出库完成.ObjToInt());


                        //todo: å›žä¼ MES
                    }
                }
                catch (Exception ex)
                {
                    _unitOfWorkManage.RollbackTran();
                    response.Success = false;
                    response.Message = $"出库处理失败：{ex.Message}";
                    return WebResponseContent.Instance.Error(ex.Message);
                }

                content = WebResponseContent.Instance.OK(data: response);
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error("处理出库完成失败：" + ex.Message);
            }
            return content;
        }

        /// <summary>
        /// è®¡ç®—实际出库数量
        /// </summary>
        private decimal CalculateActualOutboundQuantity(List<Dt_StockInfoDetail> stockDetails, List<Dt_OutboundOrderDetail> outboundDetails, Dt_OutStockLockInfo lockInfo)
        {
            decimal availableOutboundQuantity = lockInfo.AssignQuantity;
            decimal detailRemainingQuantity = outboundDetails.Sum(x => x.OrderQuantity - x.OverOutQuantity - x.MoveQty);//outboundDetail.OrderQuantity - outboundDetail.OverOutQuantity;

            return Math.Min(
                Math.Min(availableOutboundQuantity, detailRemainingQuantity),
                stockDetails.Sum(x => x.StockQuantity));
        }

        /// <summary>
        /// æ‰§è¡Œå®Œæ•´å‡ºåº“操作（不拆包）
        /// </summary>
        private void PerformFullOutboundOperation(Dt_StockInfo stockInfo, OutboundCompletePalletRequestDTO request, int taskNum)
        {
            List<Dt_StockInfoDetail_Hty> historyRecords = new List<Dt_StockInfoDetail_Hty>();
            List<Dt_StockQuantityChangeRecord> changeRecords = new List<Dt_StockQuantityChangeRecord>();
            foreach (var item in stockInfo.Details)
            {
                // ä¿å­˜åº“存明细到历史记录
                Dt_StockInfoDetail_Hty historyRecord = new Dt_StockInfoDetail_Hty
                {
                    SourceId = item.Id,
                    OperateType = "出库完成",
                    InsertTime = DateTime.Now,
                    StockId = item.StockId,
                    MaterielCode = item.MaterielCode,
                    MaterielName = item.MaterielName,
                    OrderNo = item.OrderNo,
                    BatchNo = item.BatchNo,
                    ProductionDate = item.ProductionDate,
                    EffectiveDate = item.EffectiveDate,
                    SerialNumber = item.SerialNumber,
                    StockQuantity = item.StockQuantity,
                    OutboundQuantity = item.StockQuantity,
                    Status = item.Status,
                    Unit = item.Unit,
                    InboundOrderRowNo = item.InboundOrderRowNo,
                    SupplyCode = item.SupplyCode,
                    FactoryArea = item.FactoryArea,
                    WarehouseCode = item.WarehouseCode,
                    Barcode = item.Barcode,
                    Remark = $"整箱出库完成删除，条码：{request.PalletCode}，原数量：{item.StockQuantity}，出库数量：{item.StockQuantity}，操作者：{request.Operator}"
                };
                historyRecords.Add(historyRecord);

                // è®°å½•åº“存变动
                Dt_StockQuantityChangeRecord changeRecord = new Dt_StockQuantityChangeRecord
                {
                    StockDetailId = item.Id,
                    PalleCode = stockInfo.PalletCode,
                    MaterielCode = item.MaterielCode,
                    MaterielName = item.MaterielName,
                    BatchNo = item.BatchNo,
                    OriginalSerilNumber = item.Barcode,
                    NewSerilNumber = "",
                    OrderNo = request.OrderNo,
                    TaskNum = taskNum,
                    ChangeType = (int)StockChangeTypeEnum.Outbound,
                    ChangeQuantity = -item.StockQuantity,
                    BeforeQuantity = item.StockQuantity,
                    AfterQuantity = 0,
                    SupplyCode = item.SupplyCode,
                    WarehouseCode = item.WarehouseCode,
                    Remark = $"整箱出库完成删除库存明细，条码：{request.PalletCode}，出库数量：{item.StockQuantity}，操作者：{request.Operator}"
                };
                changeRecords.Add(changeRecord);
            }
            _stockDetailHistoryRepository.AddData(historyRecords);

            // åˆ é™¤åº“存明细记录
            _stockDetailRepository.DeleteData(stockInfo.Details);
            _stockChangeRepository.AddData(changeRecords);
        }

        #region æ‹£é€‰
        /// <summary>
        /// å‡ºåº“完成处理（扫描条码扣减库存）
        /// </summary>
@@ -879,16 +1259,16 @@
                    return WebResponseContent.Instance.Error($"无法出库，条码：{request.Barcode}，库存：{stockDetail.StockQuantity}，已出库：{totalAllocatedQuantity}，分配量：{lockInfo.AssignQuantity}，明细剩余：{detailRemainingQuantity}");
                }

                if (actualOutboundQuantity + lockInfo.SortedQuantity > lockInfo.AssignQuantity)
                {
                    response.Success = false;
                    response.Message = $"无法出库，条码：{request.Barcode}，库存：{stockDetail.StockQuantity}，出库量{actualOutboundQuantity + lockInfo.SortedQuantity}大于分配量{lockInfo.AssignQuantity}";
                    return WebResponseContent.Instance.Error($"无法出库，条码：{request.Barcode}，库存：{stockDetail.StockQuantity}，出库量{actualOutboundQuantity + lockInfo.SortedQuantity}大于分配量{lockInfo.AssignQuantity}");
                }
                //if (actualOutboundQuantity + lockInfo.SortedQuantity > lockInfo.AssignQuantity)
                //{
                //    response.Success = false;
                //    response.Message = $"无法出库，条码：{request.Barcode}，库存：{stockDetail.StockQuantity}，出库量{actualOutboundQuantity + lockInfo.SortedQuantity}大于分配量{lockInfo.AssignQuantity}";
                //    return WebResponseContent.Instance.Error($"无法出库，条码：{request.Barcode}，库存：{stockDetail.StockQuantity}，出库量{actualOutboundQuantity + lockInfo.SortedQuantity}大于分配量{lockInfo.AssignQuantity}");
                //}

                // 8. åˆ¤æ–­æ˜¯å¦éœ€è¦æ‹†åŒ…（当出库数量小于库存数量时需要拆包）
                bool isUnpacked = actualOutboundQuantity < stockDetail.StockQuantity;
                string newBarcode = string.Empty;
                List<MaterialCodeReturnDTO> returnDTOs = new List<MaterialCodeReturnDTO>();

                // 9. å¼€å¯äº‹åŠ¡
                _unitOfWorkManage.BeginTran();
@@ -899,7 +1279,7 @@
                    // æ ¹æ®æ˜¯å¦æ‹†åŒ…执行不同的操作
                    if (isUnpacked)
                    {
                        newBarcode = PerformUnpackOperation(stockDetail, stockInfo, actualOutboundQuantity, request, beforeQuantity, lockInfo.TaskNum.GetValueOrDefault());
                        returnDTOs = PerformUnpackOperation(stockDetail, stockInfo, actualOutboundQuantity, request, beforeQuantity, lockInfo.TaskNum.GetValueOrDefault());
                    }
                    else
                    {
@@ -924,6 +1304,8 @@
                        //    item.OverOutQuantity = item.OrderQuantity - item.MoveQty;
                        //}

                        decimal barcodeQuantity = allocatedQuantity;

                        if (item.LockQuantity - item.OverOutQuantity >= allocatedQuantity)
                        {
                            item.OverOutQuantity += allocatedQuantity;
@@ -932,6 +1314,7 @@
                        }
                        else
                        {
                            barcodeQuantity = item.LockQuantity - item.OverOutQuantity;
                            allocatedQuantity -= (item.LockQuantity - item.OverOutQuantity);
                            item.OverOutQuantity = item.LockQuantity;
                            item.CurrentDeliveryQty = item.LockQuantity;
@@ -943,7 +1326,7 @@
                        Barcodes barcodes = new Barcodes
                        {
                            Barcode = request.Barcode,
                            Qty = actualOutboundQuantity,
                            Qty = barcodeQuantity,
                            SupplyCode = stockDetail?.SupplyCode ?? "",
                            BatchNo = stockDetail?.BatchNo ?? "",
                            Unit = stockDetail?.Unit ?? ""
@@ -993,19 +1376,20 @@
                        BeforeQuantity = beforeQuantity,
                        AfterQuantity = isUnpacked ? actualOutboundQuantity : 0,
                        ChangeQuantity = -actualOutboundQuantity,
                        IsUnpacked = isUnpacked
                        IsUnpacked = isUnpacked,
                        MaterialCodes = returnDTOs
                    };

                    response.Success = true;
                    response.Message = isUnpacked ? $"拆包出库完成，已生成新条码：{newBarcode}" : "出库完成";
                    response.Message = "出库完成";
                    response.ScannedDetail = scannedDetail;
                    response.UpdatedDetails = updateDetails;
                    response.NewBarcode = newBarcode;

                    // æ£€æŸ¥å‡ºåº“单是否完成
                    if (CheckOutboundOrderCompleted(request.OrderNo))
                    {
                        UpdateOutboundOrderStatus(request.OrderNo, OutOrderStatusEnum.出库完成.ObjToInt());


                        //todo: å›žä¼ MES
                    }
@@ -1074,10 +1458,16 @@
        /// <param name="beforeQuantity"></param>
        /// <param name="taskNum"></param>
        /// <returns></returns>
        private string PerformUnpackOperation(Dt_StockInfoDetail stockDetail, Dt_StockInfo stockInfo,
        private List<MaterialCodeReturnDTO> PerformUnpackOperation(Dt_StockInfoDetail stockDetail, Dt_StockInfo stockInfo,
            decimal actualOutboundQuantity, OutboundCompleteRequestDTO request, decimal beforeQuantity, int taskNum)
        {
            string newBarcode = GenerateNewBarcode();

            string remark = $"拆包记录，原条码：{request.Barcode}，原数量：{stockDetail.StockQuantity}，出库条码：{newBarcode}， å‡ºåº“数量：{actualOutboundQuantity}，回库条码：{request.Barcode}，回库数量：{stockDetail.StockQuantity - actualOutboundQuantity},操作者：{request.Operator}";

            List<Dt_MaterialCodeInfo> materialCodeInfos = CreateMaterialCodeInfos(stockDetail, newBarcode, actualOutboundQuantity, remark);

            List<MaterialCodeReturnDTO> returnDTOs = _mapper.Map<List<MaterialCodeReturnDTO>>(materialCodeInfos);

            // ä¿å­˜åŽŸå§‹åº“存明细到历史记录
            Dt_StockInfoDetail_Hty originalHistoryRecord = new Dt_StockInfoDetail_Hty
@@ -1138,7 +1528,7 @@
            };
            _stockChangeRepository.AddData(unpackChangeRecord);

            return newBarcode;
            return returnDTOs;
        }

        /// <summary>
@@ -1214,6 +1604,64 @@
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="stockDetail"></param>
        /// <param name="newBarcode"></param>
        /// <param name="splitQuantity"></param>
        /// <param name="afterQuantity"></param>
        /// <param name="remark"></param>
        /// <returns></returns>
        private List<Dt_MaterialCodeInfo> CreateMaterialCodeInfos(Dt_StockInfoDetail stockDetail, string newBarcode, decimal splitQuantity, string remark)
        {
            List<Dt_MaterialCodeInfo> materialCodeInfos = new List<Dt_MaterialCodeInfo>();

            Dt_MaterielInfo? materielInfo = _basicService.MaterielInfoService.Repository.QueryFirst(x => x.MaterielCode == stockDetail.MaterielCode);

            Dt_MaterialCodeInfo outMaterialCodeInfo = new Dt_MaterialCodeInfo()
            {
                AfterQuantity = splitQuantity,
                BatchNo = stockDetail.BatchNo,
                FactoryArea = stockDetail.FactoryArea,
                MaterialName = materielInfo?.MaterielName ?? stockDetail.MaterielName,
                MaterialSpec = materielInfo?.MaterielSpec ?? "",
                MaterialCode = stockDetail.MaterielCode,
                NewBarcode = newBarcode,
                OldBarcode = stockDetail.Barcode,
                OriginalQuantity = stockDetail.StockQuantity,
                PruchaseOrderNo = stockDetail.OrderNo,
                SuplierCode = stockDetail.SupplyCode,
                Unit = stockDetail.Unit,
                Date = DateTime.Now.ToString("yyyy-MM-dd"),
                Remark = remark
            };
            materialCodeInfos.Add(outMaterialCodeInfo);

            Dt_MaterialCodeInfo returnMaterialCodeInfo = new Dt_MaterialCodeInfo()
            {
                AfterQuantity = stockDetail.StockQuantity - splitQuantity,
                BatchNo = stockDetail.BatchNo,
                FactoryArea = stockDetail.FactoryArea,
                MaterialName = materielInfo?.MaterielName ?? stockDetail.MaterielName,
                MaterialSpec = materielInfo?.MaterielSpec ?? "",
                MaterialCode = stockDetail.MaterielCode,
                NewBarcode = stockDetail.Barcode,
                OldBarcode = stockDetail.Barcode,
                OriginalQuantity = stockDetail.StockQuantity,
                PruchaseOrderNo = stockDetail.OrderNo,
                SuplierCode = stockDetail.SupplyCode,
                Unit = stockDetail.Unit,
                Date = DateTime.Now.ToString("yyyy-MM-dd"),
                Remark = remark
            };

            materialCodeInfos.Add(returnMaterialCodeInfo);

            _basicService.MaterielCodeInfoService.Repository.AddData(materialCodeInfos);
            return materialCodeInfos;
        }

        /// <summary>
        /// æ›´æ–°è¯¥æ‰˜ç›˜è¯¥ç‰©æ–™çš„所有锁定记录的累计已出库数量
        /// </summary>
        /// <param name="stockId">库存ID</param>
@@ -1255,5 +1703,123 @@
            // æ£€æŸ¥æ‰€æœ‰æ˜Žç»†çš„已出数量是否都等于单据数量
            return details.All(x => x.OverOutQuantity >= x.OrderQuantity - x.MoveQty);
        }

        #endregion

        #region å–空箱
        public async Task<WebResponseContent> EmptyBox(string palletCode)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                var stock = await _stockInfoRepository.Db.Queryable<Dt_StockInfo>().Includes(x=>x.Details).Where(x => x.PalletCode == palletCode).FirstAsync();

                if (stock == null)
                {
                    return content.Error($"未找到托盘{palletCode}库存信息");
                }
                if (stock.Details.Count > 0)
                {
                    return content.Error($"托盘{palletCode}还存在库存信息不允许取走");
                }
                Dt_StockInfo_Hty stockInfo_Hty = stock.Adapt<Dt_StockInfo_Hty>();
                stockInfo_Hty.SourceId = stock.Id;
                stockInfo_Hty.OperateType = "取空箱";
                stockInfo_Hty.InsertTime = DateTime.Now;
                
                _unitOfWorkManage.BeginTran();
                await _outboundRepository.Db.InsertNav(stockInfo_Hty).IncludesAllFirstLayer().ExecuteCommandAsync();
                await _stockInfoRepository.DeleteDataByIdAsync(stock.Id);
                _unitOfWorkManage.CommitTran();
                return content.OK();
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return content.Error(ex.Message);
            }
        }

        #endregion

        #region
        public async Task<WebResponseContent> ReturnToWarehouse(string palletCode, string OrderNo, string station)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                var stock = await _stockInfoRepository.Db.Queryable<Dt_StockInfo>().Includes(x => x.Details).Where(x => x.PalletCode == palletCode).FirstAsync();

                if (stock == null)
                {
                    return content.Error($"未找到托盘{palletCode}库存信息不允许回库");
                }

                if (stock.Details.Count <= 0)
                {
                    stock.PalletType = (int)PalletTypeEnum.Empty;
                    stock.StockStatus = (int)StockStatusEmun.组盘暂存;
                    stock.LocationCode = "";
                }
                else if (stock.Details.Count > 0)
                {
                    Dt_OutStockLockInfo lockInfo = _outboundLockInfoRepository.QueryFirst(x =>
                       x.OrderNo == OrderNo &&
                       x.StockId == stock.Id &&
                       x.PalletCode == palletCode);

                    if (lockInfo != null && lockInfo.SortedQuantity != lockInfo.AssignQuantity)
                    {
                        return content.Error($"托盘{palletCode}库存未拣选完不允许回库");
                    }
                    stock.StockStatus = (int)StockStatusEmun.组盘暂存;
                    stock.LocationCode = "";
                }

                var task = await _taskRepository.Db.Queryable<Dt_Task>()
                    .Where(x => x.PalletCode == palletCode)
                    .FirstAsync();

                if (task != null)
                {
                    return content.Error($"托盘{palletCode}存在任务回库失败!");
                }

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

                var newTask = new Dt_Task()
                {
                    CurrentAddress = stations[station],
                    Grade = 0,
                    PalletCode = palletCode,
                    NextAddress = "",
                    OrderNo = OrderNo,
                    Roadway = newLocation.RoadwayNo,
                    SourceAddress = stations[station],
                    TargetAddress = newLocation.LocationCode,
                    TaskStatus = (int)TaskStatusEnum.New,
                    TaskType = stock.Details.Count > 0 ? (int)TaskTypeEnum.InPick : (int)TaskTypeEnum.InEmpty,
                    PalletType = stock.PalletType,
                    WarehouseId = stock.WarehouseId
                };
                _stockInfoRepository.UpdateData(stock);
                _taskRepository.AddData(newTask);

                //var moveResult = await _eSSApiService.MoveContainerAsync(new MoveContainerRequest
                //{
                //    slotCode = movestations[station],
                //    containerCode = palletCode
                //});
                return content.OK();

            }
            catch (Exception ex)
            {
                return content.Error(ex.Message);
            }
        }

        #endregion
    }
}