1

wankeda

2026-01-27 a474060ae47fc4c807120b2a6178e8d8f84c0863

 WMS/WIDESEA_WMSServer/WIDESEA_InboundService/Base/InboundOrderService.cs

@@ -443,7 +443,7 @@
                {
                    stockInfo = new Dt_StockInfo()
                    {
                        BatchNo ="",
                        BatchNo = "",
                        PalletCode = palletCode,
                        PalletType = GetPalletType(warehouse, palletCode),//GetPalletType(warehouse, palletCode)
                        IsFull = true,
@@ -552,7 +552,8 @@
        /// </summary>
        /// <param name="materielGroupDTO"></param>
        /// <returns></returns>
        public WebResponseContent CPMaterielGroup(SaveModel saveModel)
        #region
        public WebResponseContent CP1MaterielGroup(SaveModel saveModel)
        {
            WebResponseContent content = new WebResponseContent();
            try
@@ -850,6 +851,281 @@

            return content;
        }
        #endregion


        public WebResponseContent CPMaterielGroup(SaveModel saveModel)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                var orderNo = saveModel.MainData["orderNo"].ToString();
                var palletCode = saveModel.MainData["palletCode"].ToString();
                var warehouseId = saveModel.MainData["warehouseId"].ObjToInt();
                var serialNumbers = new List<string>();
                var quantities = new List<decimal>();
                var lotNos = new List<string>();
                var materielCodes = new List<string>();
                // 获取仓库信息
                Dt_Warehouse warehouse = _warehouseService.Repository.QueryFirst(x => x.WarehouseId == warehouseId);
                if (warehouse == null)
                {
                    return WebResponseContent.Instance.Error($"未找到该仓库信息");
                }

                // 获取入库单信息
                Dt_InboundOrder inboundOrder = BaseDal.Db.Queryable<Dt_InboundOrder>()
                    .Where(x => x.OrderNo == orderNo && x.WarehouseId == warehouse.WarehouseId)
                    .Includes(x => x.Details)
                    .First();

                if (inboundOrder == null || inboundOrder.Details == null || inboundOrder.Details.Count <= 0)
                {
                    return WebResponseContent.Instance.Error($"未找到入库单信息");
                }

                // 批量查询所有相关箱号的CP入库单明细
                List<Dt_CPInboundOrderDetail> CPinboundOrderDetails = BaseDal.Db.Queryable<Dt_CPInboundOrderDetail>()
                    .LeftJoin<Dt_InboundOrderDetail>((cp, d) => cp.OrderDetailId == d.Id)
                    .LeftJoin<Dt_InboundOrder>((cp, d, o) => d.OrderId == o.Id)
                    .Where((cp, d, o) =>
                        o.OrderNo == orderNo &&
                        o.WarehouseId == warehouse.WarehouseId
                    )
                    .Select((cp, d, o) => cp)
                    .ToList();

                //float totalQty = CPinboundOrderDetails.Sum(x => x.QtyOfpcs);


                // 按照箱号分组，用于后续处理
                var boxCodesToCheck = CPinboundOrderDetails
                    .Select(x => x.BoxCode)
                    .Where(bc => !string.IsNullOrEmpty(bc))
                    .Distinct()
                    .ToList();


                // 3. 查询这些箱号是否已存在于库存中
                var existingStockBoxCodes = _stockRepository.StockInfoRepository.Db
                    .Queryable<Dt_StockInfo>()
                    .LeftJoin<Dt_StockInfoDetail>((s, d) => s.Id == d.StockId)
                    .LeftJoin<Dt_StockInfoDetailCP>((s, d, cp) => d.Id == cp.StockDetailId)
                    .Where((s, d, cp) => boxCodesToCheck.Contains(cp.BoxCode) && !string.IsNullOrEmpty(cp.BoxCode))
                    .Select((s, d, cp) => cp.BoxCode)
                    .Distinct()
                    .ToList();

                // 4. 检查是否有重复
                if (existingStockBoxCodes.Any())
                {
                    return WebResponseContent.Instance.Error($"以下箱号已在库存中：{string.Join(",", existingStockBoxCodes)}");
                }

                // 获取所有相关的入库单明细ID
                var orderDetailIds = CPinboundOrderDetails.Select(x => x.OrderDetailId).Distinct().ToList();

                // 查询对应的入库单明细
                List<Dt_InboundOrderDetail> inboundOrderDetails = BaseDal.Db.Queryable<Dt_InboundOrderDetail>()
                    .Where(x => orderDetailIds.Contains(x.Id))
                    .ToList();

                if (inboundOrderDetails.Sum(x => x.OrderQuantity) <= inboundOrderDetails.Sum(x => x.ReceiptQuantity))
                {
                    return WebResponseContent.Instance.Error($"此单据已全部组盘完成");
                }

                // 按订单明细ID分组，检查每个明细的所有箱号是否都扫描了
                var detailsByOrderDetailId = CPinboundOrderDetails
                    .GroupBy(x => x.OrderDetailId)
                    .ToDictionary(g => g.Key, g => g.ToList());

                // 获取相关的订单明细
                List<Dt_InboundOrderDetail> orderDetails = new List<Dt_InboundOrderDetail>();
                List<Dt_InboundOrderDetail> detailsToUpdate = new List<Dt_InboundOrderDetail>();

                // 检查每个订单明细是否完成了所有箱号的扫描
                foreach (var kvp in detailsByOrderDetailId)
                {
                    int orderDetailId = kvp.Key;
                    var cpDetails = kvp.Value;

                    // 获取订单明细
                    var orderDetail = inboundOrder.Details.FirstOrDefault(x => x.Id == orderDetailId);
                    if (orderDetail == null)
                    {
                        orderDetail = BaseDal.Db.Queryable<Dt_InboundOrderDetail>()
                            .First(x => x.Id == orderDetailId);
                    }

                    if (orderDetail == null)
                    {
                        return WebResponseContent.Instance.Error($"未找到订单明细ID：{orderDetailId}");
                    }

                    orderDetails.Add(orderDetail);

                    // 标记该明细为已完成组盘
                    orderDetail.OrderDetailStatus = OrderDetailStatusEnum.GroupAndInbound.ObjToInt();
                    var recqty = orderDetail.ReceiptQuantity;
                    float totalQty = cpDetails.Sum(item => item.QtyOfpcs);
                    orderDetail.ReceiptQuantity = (decimal)totalQty + recqty; // 收货数量等于订单数量

                    detailsToUpdate.Add(orderDetail);
                }



                // 检查托盘是否已存在
                Dt_StockInfo stockInfo = _stockRepository.StockInfoRepository.Db
                    .Queryable<Dt_StockInfo>()
                    .Where(x => x.PalletCode == palletCode)
                    .First();

                if (stockInfo == null)
                {
                    // 创建新托盘
                    stockInfo = new Dt_StockInfo()
                    {
                        BatchNo = "", // 使用入库单批次号
                        PalletCode = palletCode,
                        PalletType = GetPalletType(warehouse, palletCode),
                        IsFull = true,
                        StockStatus = (int)StockStatusEmun.组盘暂存,
                        Creater = "WMS",
                        CreateDate = DateTime.Now,
                        MaterialType = (int)InventoryMaterialType.原材料,
                        Materialweight = 0,
                        Wlstatus = (int)InventoryMaterialStatus.合格,
                        Mgeneratetime = DateTime.Now,
                        WarehouseId = warehouse.WarehouseId,
                        System = inboundOrder.System,
                        Details = new List<Dt_StockInfoDetail>()
                    };
                }
                else
                {
                    // 如果托盘已存在，检查是否已经是组盘暂存状态
                    if (stockInfo.StockStatus != (int)StockStatusEmun.组盘暂存)
                    {
                        return WebResponseContent.Instance.Error($"托盘号重复,该托盘已组过物料");
                    }
                }

                List<Dt_CPInboundOrderDetail> cPInboundOrderDetail = new List<Dt_CPInboundOrderDetail>();
                // 创建库存明细 - 按订单明细创建
                foreach (var orderDetail in orderDetails)
                {
                    // 获取该明细对应的所有箱号
                    var detailBoxCodes = detailsByOrderDetailId[orderDetail.Id]
                        .Select(x => x.BoxCode)
                        .ToList();

                    cPInboundOrderDetail = BaseDal.Db.Queryable<Dt_CPInboundOrderDetail>().Where(x => detailBoxCodes.Contains(x.BoxCode)).ToList();

                    List<Dt_StockInfoDetailCP> stockInfoDetailCP = new List<Dt_StockInfoDetailCP>();
                    foreach (var item in cPInboundOrderDetail)
                    {
                        Dt_StockInfoDetailCP stockInfoDetailCP1 = new Dt_StockInfoDetailCP()
                        {
                            BoxId = item.BoxId,
                            BoxCode = item.BoxCode,
                            DateCode = item.DateCode,
                            JobId = item.JobId,
                            PartNum = item.PartNum,
                            QtyOfpcs = item.QtyOfpcs,
                            QtyOfxout = item.QtyOfxout,
                            CPStockDetailStatus = (int)StockStatusEmun.组盘暂存,
                            Creater = "上游WMS",
                        };
                        stockInfoDetailCP.Add(stockInfoDetailCP1);

                        item.CPOrderDetailStatus = InOrderStatusEnum.入库中.ObjToInt();
                    }

                    // 创建库存明细
                    Dt_StockInfoDetail stockInfoDetail = new Dt_StockInfoDetail()
                    {
                        MaterielCode = orderDetail.MaterielCode,
                        MaterielName = orderDetail.MaterielName,
                        OrderNo = inboundOrder.OrderNo,
                        BatchNo = orderDetail.BatchNo,
                        SupplierBatch = orderDetail.SupplierBatch,
                        LinId = orderDetail.LinId,
                        StockQuantity = (decimal)cPInboundOrderDetail.Sum(item => item.QtyOfpcs),
                        Status = (int)StockStatusEmun.组盘暂存,
                        Creater = "WMS",
                        CreateDate = DateTime.Now,
                        Id = orderDetail.LinId.ObjToInt(),
                        //DeliveryNote = orderDetail.DeliveryNote,
                        MaterieSpec = orderDetail.MaterieSpec,
                        StockDetails = stockInfoDetailCP,
                        OrinalLocation = orderDetail.OrinalLocation
                    };

                    if (stockInfo.Id > 0)
                    {
                        stockInfoDetail.StockId = stockInfo.Id;
                    }
                    stockInfo.Details.Add(stockInfoDetail);
                }

                // 检查入库单是否所有明细都已完成组盘
                bool allDetailsCompleted = inboundOrder.Details.All(x =>
                    detailsToUpdate.Any(d => d.Id == x.Id) ||
                    x.OrderDetailStatus == OrderDetailStatusEnum.GroupAndInbound.ObjToInt());



                // 事务处理
                _unitOfWorkManage.BeginTran();
                try
                {
                    if (stockInfo.Id == 0)
                    {
                        _stockRepository.StockInfoRepository.Db.InsertNav(stockInfo)
                            .Include(x => x.Details).ThenInclude(x => x.StockDetails)
                            .ExecuteCommand();
                    }
                    else
                    {
                        _stockRepository.StockInfoRepository.Db.UpdateNav(stockInfo)
                            .Include(x => x.Details, new UpdateNavOptions()
                            {
                                OneToManyInsertOrUpdate = true
                            }).ThenInclude(x => x.StockDetails)
                            .ExecuteCommand();
                    }

                    // 更新订单明细
                    if (detailsToUpdate.Count > 0)
                    {
                        _inboundRepository.InboundOrderDetailRepository.UpdateData(detailsToUpdate);
                    }

                    // 更新订单
                    _inboundRepository.InboundOrderRepository.UpdateData(inboundOrder);

                    _cPInboundOrderDetailRepository.UpdateData(cPInboundOrderDetail);

                    _unitOfWorkManage.CommitTran();

                    content = WebResponseContent.Instance.OK("组盘成功");
                }
                catch (Exception ex)
                {
                    _unitOfWorkManage.RollbackTran();
                    throw new Exception($"组盘事务处理失败：{ex.Message}", ex);
                }
            }
            catch (Exception ex)
            {
                content = WebResponseContent.Instance.Error($"组盘失败：{ex.Message}");
            }

            return content;
        }

        public string ReceiveWMSTaskin = WIDESEA_Core.Helper.AppSettings.Configuration["ReceiveWMSTaskin"];
        /// <summary>
        /// 组盘合托
@@ -956,7 +1232,6 @@
                                            };

                    var response = HttpHelper.Post<MomRequestContent>(ReceiveWMSTaskin, houseSyncretism, "立库入库数量回传WMS");
                    // 判断Success的值
                    if (!response.Success)
                    {
                        throw new Exception($"操作失败: {response.Message ?? "未提供错误信息"}");
@@ -971,6 +1246,7 @@
                    _stockRepository.StockInfoDetailRepository.DeleteData(sameItem.SourceItem);
                }
                _stockRepository.StockInfoRepository.UpdateData(targetstockInfo);
                _stockRepository.StockInfoDetailRepository.UpdateData(targetstockInfo.Details);
                _stockRepository.StockInfoRepository.DeleteData(stockInfo);

                _unitOfWorkManage.CommitTran();
@@ -1011,6 +1287,15 @@
        public int GetPalletType(Dt_Warehouse warehouse, string palletCode)
        {

            if (warehouse.WarehouseCode == WarehouseEnum.SC01_DW.ObjToString())
            {
                Dt_PalletTypeInfo palletTypeInfo = _palletTypeInfoRepository.QueryFirst(x => x.CodeStartStr == palletCode.Substring(0, 2));
                if (palletTypeInfo == null)
                {
                    throw new Exception($"托盘号错误");
                }
                return palletTypeInfo.PalletType;
            }
            if (warehouse.WarehouseCode == WarehouseEnum.SC01_BC.ObjToString())
            {
                Dt_PalletTypeInfo palletTypeInfo = _palletTypeInfoRepository.QueryFirst(x => x.CodeStartStr == palletCode.Substring(0, 3));
@@ -1020,6 +1305,7 @@
                }
                return palletTypeInfo.PalletType;
            }

            //else if (warehouse.WarehouseCode == WarehouseEnum.HA152.ObjToString())
            //{
            //    Dt_PalletTypeInfo palletTypeInfo = _palletTypeInfoRepository.QueryFirst(x => x.CodeStartStr == palletCode.Substring(0, 2));