Merge branch 'dev' of http://123.60.180.165:4647/ZZYDOP/DOPCore into dev

MicroServices/Business/Business.Application/ReplenishmentManagement/ReplenishmentAppService.cs

@@ -59,6 +59,10 @@ namespace Business.Replenishment
         /// 采购明细表
         /// </summary>
         private readonly ISqlRepository<PurOrdDetail> _PurOrdDetail;
+        /// <summary>
+        /// 采购单表
+        /// </summary>
+        private readonly ISqlRepository<PurOrdMaster> _PurOrdMaster;
         private readonly ISqlRepository<MonthlyShipmentPlan> _monthlyShipmentPlan;
         private readonly ISqlRepository<MonthlyShipmentPlanHistory> _monthlyShipmentPlanHistory;
         private readonly ISqlRepository<GeneralizedCodeMaster> _generalizedCodeMaster;
@@ -330,6 +334,7 @@ namespace Business.Replenishment
             IRepository<ic_demandschedule, long> icdemandschedule,
             ISqlRepository<srm_polist_ds> srmpolistds,
             ISqlRepository<PurOrdDetail> PurOrdDetail,
+            ISqlRepository<PurOrdMaster> PurOrdMaster,
             IUnitOfWorkManager unitOfWorkManager)
         {
             _replenishmentROPWeekPlan = replenishmentROPWeekPlan;
@@ -424,6 +429,7 @@ namespace Business.Replenishment
             _icdemandschedule = icdemandschedule;
             _srmpolistds = srmpolistds;
             _PurOrdDetail = PurOrdDetail;
+            _PurOrdMaster = PurOrdMaster;
         }
         #endregion
 
@@ -6290,9 +6296,9 @@ namespace Business.Replenishment
                 Msg = "OK|没有需要生成的交货单";
                 return Msg;
             }
-            //获取货源清单数据(配额比例为0的排除)
+            //获取货源清单数据
             List<string> itemnums = demandplans.Select(p => p.itemnum).ToList();
-            var purchases = _srmPurchase.GetListAsync(p => p.factory_id.ToString() == domain && p.is_active == "否" && itemnums.Contains(p.number) && p.quota_rate > 0 && !p.IsDeleted).Result;
+            var purchases = _srmPurchase.GetListAsync(p => p.factory_id.ToString() == domain && p.is_active == "否" && itemnums.Contains(p.number) && !p.IsDeleted).Result;
             if (!purchases.Any())
             {
                 Msg = "NO|没有可用的货源清单";
@@ -6305,12 +6311,16 @@ namespace Business.Replenishment
                 Msg = "NO|没有可用的采购单";
                 return Msg;
             }
+            //获取采购单数据
+            List<PurOrdMaster> purOrdMasters = _PurOrdMaster.Select(p => p.Domain == domain && purOrdDetails.Select(m => m.PurOrd).Distinct().Contains(p.PurOrd)).ToList();
             //获取占用可用PO明细的交货单
             List<srm_polist_ds> dbPolistds = _srmpolistds.Select(p => purOrdDetails.Select(m => m.PurOrd).Contains(p.ponumber)).ToList();
 
             //生成交货单
             srm_polist_ds entity;
             List<srm_polist_ds> inserts = new List<srm_polist_ds>();
+            //当前交货计划转交货单数据
+            List<srm_polist_ds> curInserts = new List<srm_polist_ds>();
             //采购明细剩余未交数量
             decimal sumRestQty = 0m;
             //交货单占用数量
@@ -6321,26 +6331,33 @@ namespace Business.Replenishment
             decimal restQty = 0m;
             foreach (var item in demandplans)
             {
+                curInserts = new List<srm_polist_ds>();
                 //获取当前交货计划物料对应的货源清单
                 var curChaes = purchases.Where(p => p.number == item.itemnum).OrderByDescending(p=>p.quota_rate).ToList();
-                //获取当前交货计划物料对应的可用采购单明细数据
-                var curPurDtls = purOrdDetails.Where(p => p.ItemNum == item.itemnum).OrderBy(p=>p.DueDate).ToList();
-                //数据库中当前采购单明细被交货单占用情况
-                var curDbOccupys = dbPolistds.Where(p => curPurDtls.Select(m => m.PurOrd).Contains(p.ponumber) && p.itemnum == item.itemnum).ToList();
-                //本次计算中采购单明细被交货单占用情况
-                var curCalcOccupys = inserts.Where(p => curPurDtls.Select(m => m.PurOrd).Contains(p.ponumber) && p.itemnum == item.itemnum).ToList();
-                #region 校验
                 //校验1：如果当前物料没有维护货源清单，则跳过
                 if (!curChaes.Any())
                 {
                     continue;
                 }
-                //校验2：如果当前物料没有可用的采购明细，则跳过
+                //校验2：如果当前物料对应货源清单的供应商配额之和不为100%，则跳过
+                if (curChaes.Sum(p => p.quota_rate.GetValueOrDefault()) != 100)
+                {
+                    continue;
+                }
+                //获取当前交货计划物料对应的可用采购单明细数据
+                var curPurDtls = purOrdDetails.Where(p => p.ItemNum == item.itemnum).OrderBy(p=>p.DueDate).ToList();
+                //校验3：如果当前物料没有可用的采购明细，则跳过
                 if (!curPurDtls.Any())
                 {
                     continue;
                 }
-                //校验3：如果当前物料对应的采购明细可用数量不满足，则跳过
+                //当前采购明细对应的采购单
+                var curPurMsts = purOrdMasters.Where(p => curPurDtls.Select(m => m.PurOrd).Distinct().Contains(p.PurOrd)).ToList();
+                //数据库中当前采购单明细被交货单占用情况
+                var curDbOccupys = dbPolistds.Where(p => curPurDtls.Select(m => m.PurOrd).Contains(p.ponumber) && p.itemnum == item.itemnum).ToList();
+                //本次计算中采购单明细被交货单占用情况
+                var curCalcOccupys = inserts.Where(p => curPurDtls.Select(m => m.PurOrd).Contains(p.ponumber) && p.itemnum == item.itemnum).ToList();
+                //校验4：如果当前物料对应的采购明细可用数量不满足，则跳过
                 //采购单明细的剩余未交数量：采购明细的需求数量-已交数量
                 sumRestQty = curPurDtls.Sum(p => p.QtyOrded - p.RctQty);
                 //交货单占用数量:交货单的剩余需要采购数量
@@ -6353,17 +6370,17 @@ namespace Business.Replenishment
                 {
                     continue;
                 }
-                #endregion
-
+                //标志位
+                bool flag = false;
                 //当前交货计划已分配数量
                 decimal allQty = 0m;
-                //当前供应商分配数量数量
+                //当前供应商分配数量
                 decimal needQty = 0m;
                 //当前供应商已分配数量合计
                 decimal sumNeedQty = 0m;
                 //当前供应商剩余需要分配数量
                 decimal remainQty = 0m;
-                //存在货源清单，采购单明细可用数量满足当前交货计划，则先计算供应商配额，然后，再占用采购单明细可用数量
+                //存在货源清单，采购单明细可用数量满足当前交货计划，则先计算供应商配额，计算当前供应商对应的采购明细是否满足配额，若满足则占用采购单明细可用数量
                 foreach (var pch in curChaes)
                 {
                     //如果交货计划已分配数量>=交货计划净需求数量,则终止
@@ -6374,14 +6391,44 @@ namespace Business.Replenishment
                     //供应商占用数量置0
                     sumNeedQty = 0m;
                     //计算当前供应商分配数量
-                    needQty = item.tosechedqty * pch.quota_rate.GetValueOrDefault();
+                    needQty = item.tosechedqty * pch.quota_rate.GetValueOrDefault() / 100.00m;
                     //如果交货计划剩余数量小于按照供应商配额计算的数量，则当前供应商需分配数量为交货计划剩余数量
                     if (item.tosechedqty - allQty < needQty)
                     {
                         needQty = item.tosechedqty - allQty;
                     }
-                    //按照采购单明细数据交货日期从小到大开始占用
-                    foreach (var pud in curPurDtls)
+                    //获取当前供应商对应的采购单明细数据，按照交货日期从小到大开始占用
+                    var pchPurMsts = curPurMsts.Where(p => p.Supp == pch.supplier_number).ToList();
+                    if (!pchPurMsts.Any())
+                    {
+                        //当前供应商没有可用采购单，则当前交货计划无法转交货单
+                        flag = true;
+                        break;
+                    }
+                    var pchPurDtls = curPurDtls.Where(p => pchPurMsts.Select(m => m.PurOrd).Contains(p.PurOrd)).ToList();
+                    if (!pchPurDtls.Any())
+                    {
+                        //当前供应商没有可用采购单明细，则当前交货计划无法转交货单
+                        flag = true;
+                        break;
+                    }
+                    //校验当前供应商的采购明细剩余可用数量是否满足供应商的配额
+                    //采购单明细剩余可用数量
+                    sumRestQty = pchPurDtls.Sum(p => p.QtyOrded - p.RctQty);
+                    //交货单占用数量:交货单的剩余需要采购数量
+                    sumDbOccupy = curDbOccupys.Where(p=> pchPurDtls.Select(m => m.PurOrd).Contains(p.ponumber)).Sum(p => p.restqty);
+                    //本次计算交货单占用数量:本次计算交货单的需求数量
+                    sumCurOccupy = curCalcOccupys.Where(p => pchPurDtls.Select(m => m.PurOrd).Contains(p.ponumber)).Sum(p => p.schedqty);
+                    //剩余可用数量
+                    restQty = sumRestQty - sumDbOccupy - sumCurOccupy;
+                    if (restQty < sumNeedQty)
+                    {
+                        //当前供应商可用采购单明细不足，则当前交货计划无法转交货单
+                        flag = true;
+                        break;
+                    }
+
+                    foreach (var pud in pchPurDtls)
                     {
                         if (sumNeedQty >= needQty)
                         {
@@ -6447,7 +6494,7 @@ namespace Business.Replenishment
                         entity.createtime = DateTime.Now;
                         entity.createuser = user;
                         entity.remarks = "";
-                        inserts.Add(entity);
+                        curInserts.Add(entity);
 
                         //当前交货计划已分配数量累加
                         allQty += xqQty;
@@ -6455,6 +6502,12 @@ namespace Business.Replenishment
                         sumNeedQty += xqQty;
                     }
                 }
+                //标志位为true，则当前交货计划无法转交货单
+                if (flag)
+                {
+                    break;
+                }
+                inserts.AddRange(curInserts);
             }
 
             if (inserts.Any())

MicroServices/Business/Business.Application/ResourceExamineManagement/ResourceExamineAppService.cs

@@ -3383,8 +3383,8 @@ namespace Business.ResourceExamineManagement
 
             //删除同步Mysql后旧数据
             await DeleteMySqlOldData(sentrys);
-            List<string> tsWork = new List<string> { "试制工单", "TCN工单", "返工工单" };
-            List<mo_ic_bom> boms = _ic_bom.GetListAsync(p => mo_Mes_Morders.Where(x=> !tsWork.Contains(x.morder_type)).Select(m => m.bom_number).Contains(p.bom_number) && p.factory_id == param.factoryId && p.company_id == param.company_id && !p.IsDeleted).Result.ToList();
+            
+            List<mo_ic_bom> boms = _ic_bom.GetListAsync(p => mo_Mes_Morders.Select(m => m.bom_number).Contains(p.bom_number) && p.factory_id == param.factoryId && p.company_id == param.company_id && !p.IsDeleted).Result.ToList();
 
             //物料bom
             List<mo_ic_bom> bomlist = new List<mo_ic_bom>();
@@ -3419,6 +3419,7 @@ namespace Business.ResourceExamineManagement
             AsyncItemStockFromWMS(pretreatments);
 
             //增加特殊工单的预处理结果，因为特殊工单是自定义物料清单
+            List<string> tsWork = new List<string> { "试制工单", "返工工单" };
             var specialWork = mo_Mes_Morders.Where(x => tsWork.Contains(x.morder_type)).ToList();
             pretreatments.AddRange(_mysql_b_bom_pretreatment.GetListAsync(s => specialWork.Select(c => c.Id).ToList().Contains(s.sourceid)).Result);
 
@@ -3487,18 +3488,19 @@ namespace Business.ResourceExamineManagement
 
                 //获取当前物料bom数据
                 List<b_bom_pretreatment> itemPrelist = new List<b_bom_pretreatment>();
-                var childBom = boms.Where(p => p.bom_number == item.bom_number).FirstOrDefault();
-                if (childBom != null)
+                //通过工单ID读取，考虑特殊工单的预处理
+                itemPrelist = pretreatments.Where(s => s.sourceid == item.Id).ToList();
+                if (!itemPrelist.Any())
                 {
-                    itemPrelist = pretreatments.Where(s => s.sourceid == childBom.mysql_id).ToList();
-                }
-                else {
-                    itemPrelist = pretreatments.Where(s => s.sourceid == item.Id).ToList();
+                    var childBom = boms.Where(p => p.bom_number == item.bom_number).FirstOrDefault();
+                    if (childBom != null)
+                    {
+                        itemPrelist = pretreatments.Where(s => s.sourceid == childBom.mysql_id).ToList();
+                    }
+                    else {
+                        continue;
+                    }
                 }
-                /*if (tsWork.Contains(item.morder_type))
-                {
-                    itemPrelist = pretreatments.Where(s => s.sourceid == item.Id).ToList();
-                }*/
                 if (!itemPrelist.Any())
                 {
                     continue;
@@ -4156,7 +4158,8 @@ namespace Business.ResourceExamineManagement
                             CreateUser = user?.Name,
                             UpdateUser = user?.Name,
                             UM = find.UM,
-                            LotSerial = typed ? a.LotSerial : ""
+                            LotSerial = typed ? a.LotSerial : "",
+                            ItemName = find.Descr
                         });
                         i++;
                     }

MicroServices/Business/Business.Domain/StructuredDB/MES/IC/NbrDetail.cs

@@ -144,5 +144,11 @@ namespace Business.Domain
         /// </summary>
         [Comment("工单已发料数量")]
         public decimal QtyRec { get; set; }
+
+        /// <summary>
+        /// 物料名称
+        /// </summary>
+        [Comment("物料名称")]
+        public string ItemName { get; set; }
     }
 }