提交

pan

2025-11-27 1a1bc81ac1d9ad656e15b409122e23f7f3763293

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

@@ -336,71 +336,231 @@
        }


        public (List<Dt_StockInfo>, Dt_OutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>) AssignStockOutbound(Dt_OutboundOrderDetail outboundOrderDetail, List<StockSelectViewDTO> stockSelectViews)
        public (List<Dt_StockInfo>, Dt_OutboundOrderDetail, List<Dt_OutStockLockInfo>, List<Dt_LocationInfo>)
       AssignStockOutbound(Dt_OutboundOrderDetail outboundOrderDetail, List<StockSelectViewDTO> stockSelectViews)
        {
            // éªŒè¯ç”¨æˆ·é€‰æ‹©
            (bool, string) checkResult = CheckSelectStockDeital(outboundOrderDetail, stockSelectViews);
            if (!checkResult.Item1) throw new Exception(checkResult.Item2);

            Dt_OutboundOrder outboundOrder = _outboundOrderService.Repository.QueryFirst(x => x.Id == outboundOrderDetail.OrderId);
            var originalNeedQuantity = outboundOrderDetail.OrderQuantity - outboundOrderDetail.LockQuantity - outboundOrderDetail.MoveQty;

            var needQuantity = originalNeedQuantity;
            List<Dt_StockInfo> outStocks = new List<Dt_StockInfo>();
            List<Dt_OutStockLockInfo> outStockLockInfos = new List<Dt_OutStockLockInfo>();

            List<Dt_StockInfo> outStocks = _stockService.StockInfoService.GetStockInfosByPalletCodes(stockSelectViews.Select(x => x.PalletCode).ToList());
            var assignQuantity = 0m;
            outStocks.ForEach(x =>
            {
                x.Details.ForEach(v =>
                {
                    assignQuantity += v.StockQuantity - v.OutboundQuantity;
                });
            });
            decimal remainingNeedQuantity = originalNeedQuantity;
            decimal totalAssignedFromUserSelection = 0;

            outboundOrderDetail.LockQuantity += assignQuantity;
            outStocks.ForEach(x =>
            // æŒ‰å…ˆè¿›å…ˆå‡ºæŽ’序用户选择的库存
            var userSelectedStocks = _stockService.StockInfoService.GetStockInfosByPalletCodes(
                stockSelectViews.Select(x => x.PalletCode).ToList());

            var sortedUserSelectedStocks = userSelectedStocks
                .OrderBy(x => x.CreateDate)
                .ToList();

            // åˆ†é…ç”¨æˆ·é€‰æ‹©çš„库存
            foreach (var stock in sortedUserSelectedStocks)
            {
                x.Details.ForEach(v =>
                if (remainingNeedQuantity <= 0) break;

                // èŽ·å–用户对该托盘的选择数量
                var userSelection = stockSelectViews.FirstOrDefault(x => x.PalletCode == stock.PalletCode);
                if (userSelection == null) continue;

                // è®¡ç®—该托盘实际可用数量
                var availableQuantity = CalculateAvailableQuantity(stock, outboundOrderDetail.MaterielCode,
                    outboundOrderDetail.BatchNo, outboundOrderDetail.SupplyCode);

                // ç¡®å®šåˆ†é…æ•°é‡ï¼šå–用户选择数量、可用数量和剩余需求的最小值
                var assignQuantity = Math.Min(
                    Math.Min(userSelection.UseableQuantity, availableQuantity),
                    remainingNeedQuantity);

                if (assignQuantity <= 0) continue;

                // æ‰§è¡Œåˆ†é…
                var actualAssigned = AssignStockQuantity(stock, outboundOrderDetail, assignQuantity);
                if (actualAssigned > 0)
                {
                    v.OutboundQuantity = v.StockQuantity;
                });
            });
            needQuantity -= assignQuantity;
            if (outboundOrderDetail.OrderQuantity > outboundOrderDetail.LockQuantity)
                    outStocks.Add(stock);
                    totalAssignedFromUserSelection += actualAssigned;
                    remainingNeedQuantity -= actualAssigned;

                    // åˆ›å»ºé”å®šè®°å½•
                    var lockInfo = CreateOutStockLockInfo(outboundOrder, outboundOrderDetail, stock, actualAssigned);
                    outStockLockInfos.Add(lockInfo);
                }
            }

            // æ£€æŸ¥ç”¨æˆ·é€‰æ‹©æ˜¯å¦è‡³å°‘分配了一部分
            if (totalAssignedFromUserSelection <= 0)
            {
                List<Dt_StockInfo> stockInfos = _stockService.StockInfoService.GetUseableStocks(outboundOrderDetail.MaterielCode, outboundOrderDetail.BatchNo, "");
                stockInfos = stockInfos.Where(x => !stockSelectViews.Select(v => v.PalletCode).Contains(x.PalletCode)).ToList();
                var (autoAssignStocks, stockAllocations) = _stockService.StockInfoService.GetOutboundStocks(stockInfos, outboundOrderDetail.MaterielCode, needQuantity, out decimal residueQuantity);
                outboundOrderDetail.LockQuantity += needQuantity - residueQuantity;
                throw new Exception("用户选择的库存无法分配任何数量");
            }

            // å¦‚果用户选择的库存不够，自动分配剩余部分
            decimal autoAssignedQuantity = 0;
            if (remainingNeedQuantity > 0)
            {
                List<Dt_StockInfo> autoStocks = _stockService.StockInfoService.GetUseableStocks(
                    outboundOrderDetail.MaterielCode, outboundOrderDetail.BatchNo, "");

                // æŽ’除用户已选择的托盘
                autoStocks = autoStocks
                    .Where(x => !stockSelectViews.Select(v => v.PalletCode).Contains(x.PalletCode))
                    .ToList();

                var (autoAssignStocks, stockAllocations) = _stockService.StockInfoService.GetOutboundStocks(
                    autoStocks, outboundOrderDetail.MaterielCode, remainingNeedQuantity, out decimal residueQuantity);

                // æ£€æŸ¥è‡ªåŠ¨åˆ†é…ç»“æžœ
                autoAssignedQuantity = remainingNeedQuantity - residueQuantity;
                if (autoAssignedQuantity <= 0 && remainingNeedQuantity > 0)
                {
                    // éƒ¨åˆ†åˆ†é…æ˜¯å¯ä»¥æŽ¥å—的，记录警告但不报错
                    _logger.LogWarning($"自动分配失败，剩余需求{remainingNeedQuantity}无法满足");
                }
                else if (autoAssignedQuantity > 0)
                {
                outStocks.AddRange(autoAssignStocks);
                outboundOrderDetail.OrderDetailStatus = OrderDetailStatusEnum.AssignOver.ObjToInt();
                if (residueQuantity > 0)
                {
                    outboundOrderDetail.OrderDetailStatus = OrderDetailStatusEnum.AssignOverPartial.ObjToInt();

                    // ä¸ºè‡ªåŠ¨åˆ†é…çš„库存创建锁定记录
                    var autoLockInfos = CreateLockInfosForAutoAssign(outboundOrder, outboundOrderDetail, autoAssignStocks, stockAllocations);
                    outStockLockInfos.AddRange(autoLockInfos);
                }
            }

            List<Dt_OutStockLockInfo> outStockLockInfos = _outStockLockInfoService.GetOutStockLockInfos(outboundOrder, outboundOrderDetail, outStocks);
            // æ›´æ–°é”å®šæ•°é‡
            outboundOrderDetail.LockQuantity += totalAssignedFromUserSelection + autoAssignedQuantity;

            // æ›´æ–°çŠ¶æ€
            UpdateOrderDetailStatus(outboundOrderDetail, remainingNeedQuantity - autoAssignedQuantity);

            List<Dt_LocationInfo> locationInfos = _locationInfoService.GetLocationInfos(outStocks.Select(x => x.LocationCode).ToList());

            return (outStocks, outboundOrderDetail, outStockLockInfos, locationInfos);
        }
        private (bool, string) CheckSelectStockDeital(Dt_OutboundOrderDetail outboundOrderDetail, List<StockSelectViewDTO> stockSelectViews)

        // è¾…助方法
        private decimal CalculateAvailableQuantity(Dt_StockInfo stock, string materielCode, string batchNo, string supplyCode)
        {
            if (outboundOrderDetail == null)
            {
                return (false, "未找到出库单明细信息");
            }
            if (outboundOrderDetail.OrderDetailStatus != OrderDetailStatusEnum.New.ObjToInt() && outboundOrderDetail.OrderDetailStatus != OrderDetailStatusEnum.AssignOverPartial.ObjToInt())
            {
                return (false, "该明细不可操作");
            }
            //if (stockSelectViews.Sum(x => x.UseableQuantity) > outboundOrderDetail.OrderQuantity - outboundOrderDetail.LockQuantity - outboundOrderDetail.MoveQty)
            //{
            //    return (false, "选择数量超出单据数量");
            //}
            return (true, "成功");
            var relevantDetails = stock.Details
                .Where(d => d.MaterielCode == materielCode &&
                           (string.IsNullOrEmpty(batchNo) || d.BatchNo == batchNo) &&
                           (string.IsNullOrEmpty(supplyCode) || d.SupplyCode == supplyCode))
                .ToList();

            return relevantDetails.Sum(d => d.StockQuantity - d.OutboundQuantity);
        }

        private decimal AssignStockQuantity(Dt_StockInfo stock, Dt_OutboundOrderDetail detail, decimal assignQuantity)
        {
            decimal remainingAssign = assignQuantity;

            // æŒ‰å…ˆè¿›å…ˆå‡ºåˆ†é…åº“存明细
            var sortedDetails = stock.Details
                .Where(d => d.MaterielCode == detail.MaterielCode &&
                           d.BatchNo == detail.BatchNo &&
                           (d.StockQuantity - d.OutboundQuantity) > 0)
                .OrderBy(d => d.CreateDate)
                .ToList();

            foreach (var stockDetail in sortedDetails)
            {
                if (remainingAssign <= 0) break;

                var available = stockDetail.StockQuantity - stockDetail.OutboundQuantity;
                var assign = Math.Min(available, remainingAssign);

                stockDetail.OutboundQuantity += assign;
                remainingAssign -= assign;
            }

            return assignQuantity - remainingAssign; // è¿”回实际分配数量
        }

        private Dt_OutStockLockInfo CreateOutStockLockInfo(Dt_OutboundOrder outboundOrder, Dt_OutboundOrderDetail detail,
            Dt_StockInfo stock, decimal quantity)
        {
            var barcode = stock.Details
                .Where(d => !string.IsNullOrEmpty(d.Barcode))
                .Select(d => d.Barcode)
                .FirstOrDefault();

            return _outStockLockInfoService.GetOutStockLockInfo(outboundOrder, detail, stock, quantity, barcode);
        }

        private List<Dt_OutStockLockInfo> CreateLockInfosForAutoAssign(Dt_OutboundOrder outboundOrder,
            Dt_OutboundOrderDetail detail, List<Dt_StockInfo> stocks, Dictionary<int, decimal> allocations)
        {
            var lockInfos = new List<Dt_OutStockLockInfo>();

            foreach (var stock in stocks.OrderBy(x => x.CreateDate))
            {
                if (allocations.TryGetValue(stock.Id, out decimal quantity) && quantity > 0)
                {
                    var lockInfo = CreateOutStockLockInfo(outboundOrder, detail, stock, quantity);
                    lockInfos.Add(lockInfo);
                }
            }

            return lockInfos;
        }

        private void UpdateOrderDetailStatus(Dt_OutboundOrderDetail detail, decimal remainingQuantity)
        {
            if (remainingQuantity <= 0)
            {
                detail.OrderDetailStatus = OrderDetailStatusEnum.AssignOver.ObjToInt();
            }
            else
            {
                detail.OrderDetailStatus = OrderDetailStatusEnum.AssignOverPartial.ObjToInt();
            }
        }

        private (bool, string) CheckSelectStockDeital(Dt_OutboundOrderDetail outboundOrderDetail, List<StockSelectViewDTO> stockSelectViews)
        {
            var needQuantity = outboundOrderDetail.OrderQuantity - outboundOrderDetail.LockQuantity - outboundOrderDetail.MoveQty;

            if (needQuantity <= 0)
            {
                return (false, "出库单明细无需分配库存");
            }

            // æ£€æŸ¥æ€»é€‰æ‹©æ•°é‡æ˜¯å¦å¤§äºŽ0
            var totalSelected = stockSelectViews.Sum(x => x.UseableQuantity);
            if (totalSelected <= 0)
            {
                return (false, "用户选择的库存数量必须大于0");
            }

            // æ£€æŸ¥æ¯ä¸ªæ‰˜ç›˜çš„可用数量
            foreach (var selection in stockSelectViews)
            {
                if (selection.UseableQuantity <= 0)
                {
                    return (false, $"托盘[{selection.PalletCode}]的选择数量必须大于0");
                }

                var stock = _stockService.StockInfoService.GetStockInfoByPalletCode(selection.PalletCode);
                if (stock == null)
                {
                    return (false, $"托盘[{selection.PalletCode}]不存在");
                }

                var available = CalculateAvailableQuantity(stock, outboundOrderDetail.MaterielCode,
                    outboundOrderDetail.BatchNo, outboundOrderDetail.SupplyCode);

                if (available <= 0)
                {
                    return (false, $"托盘[{selection.PalletCode}]没有可用库存");
                }
            }

            return (true, "验证通过");
        }
    }
}