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

MicroServices/Business/Business.Application.Contracts/ResourceExamineManagement/IResourceExamineAppService.cs

@@ -36,7 +36,7 @@ namespace Business.ResourceExamineManagement
         Task<string> ReceiveResult(string ids, int type,string companyid);
 
         /// <summary>
-        /// 按日期范围工单检查
+        /// 自动下达
         /// </summary>
         /// <param name="input"></param>
         /// <returns></returns>
@@ -50,7 +50,7 @@ namespace Business.ResourceExamineManagement
         Task<string> SubstituteResourceCheck(int day, string workOrd);
 
         /// <summary>
-        /// 计划工单齐套检查
+        /// 计划工单资源检查
         /// </summary>
         /// <param name="workOrds"></param>
         /// <returns></returns>
@@ -99,7 +99,7 @@ namespace Business.ResourceExamineManagement
         Task<string> PrApprove(string ids);
 
         /// <summary>
-        /// 按工单检查
+        /// 手动按工单下达
         /// </summary>
         /// <param name="input"></param>
         /// <returns></returns>

MicroServices/Business/Business.Application/ResourceExamineManagement/CalcBomViewAppService.cs

@@ -259,6 +259,7 @@ namespace Business.ResourceExamineManagement
                         //根据成品属性来判断是自制还是委外还是外购，需要考虑这种场景
                         if (level1Dto.erp_cls == 1 && param.checkflag)
                         {
+                            //param.checkflag=true 销售订单产生工单
                             level1Dto.make_qty = level1Dto.lack_qty;
                             //生成主工单
                             GenerateMorderDto generateMorderDto = new GenerateMorderDto()

MicroServices/Business/Business.Application/ResourceExamineManagement/ProductionScheduleAppService.cs

@@ -709,10 +709,9 @@ namespace Business.ResourceExamineManagement
                                 //剩余可用工作时长不能满足清场时长
                                 else
                                 {
-                                    endTime = dto.EndTime;
                                     //还需排产的清场时间
                                     decimal qcTime = needTime - remainTime;
-                                    endTime.AddMinutes((double)qcTime);
+                                    endTime = dto.EndTime.AddMinutes((double)qcTime);
                                     remainTime = 0;
                                 }
                                 //最后一个工单的清场时长
@@ -797,7 +796,7 @@ namespace Business.ResourceExamineManagement
                             item.QtyWorked = item.QtyOrded;
                         }
                         //当天产能完全占用,且最后一个工单的清场时间刚好下班或者在下班后
-                        if (curPoint == null || endTime == dto.EndTime)
+                        if (endTime >= dto.EndTime)
                         {
                             sumTsTimes = 0;//排产完毕，特殊工单时长置0
                             //获取下一个工作日
@@ -965,17 +964,17 @@ namespace Business.ResourceExamineManagement
                                 });
                                 //当前工单已排产完成，已排产时间=工单生产时长，已排产数量=工单数量
                                 item.Worked = item.LbrVar;
-                                item.QtyWorked = item.QtyWorked;
+                                item.QtyWorked = item.QtyOrded;
 
                                 beginTime = endTime;
                                 //当天可用生产时长还有剩余
                                 if (residueTime > 0)
                                 {
                                     //获取结束时间所处时间段
-                                    curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
+                                    curPoint = workPoints.FirstOrDefault(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                     if (endTime == curPoint.EndPoint)
                                     {
-                                        var nextPoint = workPoints.Find(p => p.Level == curPoint.Level + 1);
+                                        var nextPoint = workPoints.FirstOrDefault(p => p.Level == curPoint.Level + 1);
                                         endTime = nextPoint == null ? endTime : nextPoint.StartPoint;
                                     }
                                     beginTime = endTime;
@@ -1067,29 +1066,32 @@ namespace Business.ResourceExamineManagement
                     {
                         //获取特殊工单
                         secWOMasters = tsWorkOrds.Where(p => p.ProdLine == lineStart.Line && p.OrdDate.Value.Date == workStartTime.Date).OrderBy(p => p.OrdDate).ToList();
-                        foreach (var item in secWOMasters)
+                        if (secWOMasters.Any())
                         {
-                            var curOp = tsWoRoutings.Where(p => p.WorkOrd == item.WorkOrd).OrderByDescending(p => p.OP).First();
-                            workDtos.Add(new WorkOrdMstDto
+                            foreach (var item in secWOMasters)
                             {
-                                WorkOrd = item.WorkOrd,
-                                ItemNum = item.ItemNum,
-                                QtyOrded = item.QtyOrded,
-                                LbrVar = item.LbrVar * 60,
-                                Worked = 0,
-                                QtyWorked = 0,
-                                Op = curOp.OP,
-                                WaitTime = curOp.WaitTime * 60,
-                                PlanDate = item.OrdDate.Value
-                            });
-                            sumCleanTimes += curOp.WaitTime * 60;
+                                var curOp = tsWoRoutings.Where(p => p.WorkOrd == item.WorkOrd).OrderByDescending(p => p.OP).First();
+                                workDtos.Add(new WorkOrdMstDto
+                                {
+                                    WorkOrd = item.WorkOrd,
+                                    ItemNum = item.ItemNum,
+                                    QtyOrded = item.QtyOrded,
+                                    LbrVar = item.LbrVar * 60,
+                                    Worked = 0,
+                                    QtyWorked = 0,
+                                    Op = curOp.OP,
+                                    WaitTime = curOp.WaitTime * 60,
+                                    PlanDate = item.OrdDate.Value
+                                });
+                                sumCleanTimes += curOp.WaitTime * 60;
+                            }
+                            //获取最后一个特殊工单的清场时长
+                            var last = secWOMasters.Last();
+                            secCleanTime = tsWoRoutings.Where(p => p.WorkOrd == last.WorkOrd).OrderByDescending(p => p.OP).First().WaitTime * 60;
+                            //特殊工单待排产时长=前一天特殊工单到最后一个清场时长+新增的特殊工单生产时长+新增特殊工单除最后一个清场时长之外的清场时长之和
+                            sumTsTimes += (lstCleanTime + secWOMasters.Sum(p => p.LbrVar) * 60 + sumCleanTimes - secCleanTime);
+                            lstCleanTime = secCleanTime;
                         }
-                        //获取最后一个特殊工单的清场时长
-                        var last = secWOMasters.Last();
-                        secCleanTime = tsWoRoutings.Where(p => p.WorkOrd == last.WorkOrd).OrderByDescending(p => p.OP).First().WaitTime * 60;
-                        //特殊工单待排产时长=前一天特殊工单到最后一个清场时长+新增的特殊工单生产时长+新增特殊工单除最后一个清场时长之外的清场时长之和
-                        sumTsTimes += (lstCleanTime + secWOMasters.Sum(p => p.LbrVar) * 60 + sumCleanTimes - secCleanTime);
-                        lstCleanTime = secCleanTime;
                     }
                     //排产开始时，需要先减去产线准备时间(产线提前期满足的当天排产)
                     if (sumTimes < lineStart.setupTime * 60)
@@ -1097,7 +1099,7 @@ namespace Business.ResourceExamineManagement
                         //当天的可用生产时长能满足提前期
                         if (dto.EffTime > lineStart.setupTime * 60 - sumTimes)
                         {
-                            //当天剩余时长(分钟)
+                            //当天剩余时长(分钟)=当天可用上产时长-剩余产线准备时间
                             decimal residueTime = dto.EffTime - (lineStart.setupTime * 60 - sumTimes);
                             //产线提前期安排完之后，需要考虑当前是否存在特殊工单：
                             //1、如果当天是排产的最后一天，则先排完正常工单，再安排特殊工单；
@@ -1164,10 +1166,9 @@ namespace Business.ResourceExamineManagement
                                                 //剩余可用工作时长不能满足清场时长
                                                 else
                                                 {
-                                                    endTime = dto.EndTime;
                                                     //还需排产的清场时间
                                                     decimal qcTime = needTime - residueTime;
-                                                    endTime.AddMinutes((double)qcTime);
+                                                    endTime = dto.EndTime.AddMinutes((double)qcTime);
                                                     residueTime = 0;
                                                 }
                                             }
@@ -1259,7 +1260,7 @@ namespace Business.ResourceExamineManagement
                                             //处理正常工单开工时间
                                             workStartTime = endTime;
                                             //剩余产能继续排正常工单
-                                            sumAmount = Math.Floor(dto.Rate * (residueTime - sumTsTimes - lstCleanTime) / 60);
+                                            sumAmount = Math.Floor(dto.Rate * residueTime / 60);
                                             //记录生产周期
                                             curSequences.Add(new PeriodSequenceDet
                                             {
@@ -1387,10 +1388,6 @@ namespace Business.ResourceExamineManagement
                                                     //剩余生产时长
                                                     residueTime -= needTime;
                                                 }
-                                                //当前工单已排产完成，已排产时间=工单生产时长，已排产数量=工单数量
-                                                item.Worked = item.LbrVar;
-                                                item.QtyWorked = item.QtyWorked;
-
                                                 //处理特殊工单剩余时长减去当前工单待排产时长和清场时长
                                                 sumTsTimes -= (item.LbrVar - item.Worked + item.WaitTime);
                                                 //记录生产周期
@@ -1422,6 +1419,9 @@ namespace Business.ResourceExamineManagement
                                                     WorkEndTime = endTime,
                                                     CreateTime = DateTime.Now
                                                 });
+                                                //当前工单已排产完成，已排产时间=工单生产时长，已排产数量=工单数量
+                                                item.Worked = item.LbrVar;
+                                                item.QtyWorked = item.QtyOrded;
 
                                                 beginTime = endTime;
                                                 //当天可用生产时长还有剩余
@@ -1471,7 +1471,7 @@ namespace Business.ResourceExamineManagement
                                                     WorkDate = beginTime.Date,
                                                     WorkQty = qty,
                                                     WorkStartTime = beginTime,
-                                                    WorkEndTime = endTime,
+                                                    WorkEndTime = dto.EndTime,
                                                     CreateTime = DateTime.Now
                                                 });
                                                 item.Worked += residueTime;
@@ -1536,11 +1536,14 @@ namespace Business.ResourceExamineManagement
                                 decimal residueQty = workOrd.QtyOrded - sumQty;
                                 //剩余数量生产需要时长(分钟)
                                 decimal workTime = Math.Ceiling(residueQty / dto.Rate * 60);
+                                //处理工作时长:防止相上取整导致时间大于剩余可用时长
+                                workTime = workTime >= residueTime ? residueTime : workTime;
+                                //排产结束时间
+                                DateTime workEndTime = workStartTime;
                                 var curPoint = workPoints.Find(p => p.StartPoint <= workStartTime && workStartTime <= p.EndPoint);
                                 span = curPoint.EndPoint - workStartTime;
                                 //当天工作时间段的有效生产时间
                                 decimal effMins = (decimal)span.TotalMinutes;
-                                DateTime workEndTime = workStartTime;
                                 //当前工作时间段即可满足产能
                                 if (effMins >= workTime)
                                 {
@@ -1608,7 +1611,7 @@ namespace Business.ResourceExamineManagement
                                     }
                                     residueTime -= workTime;
                                 }
-
+                                
                                 //记录生产周期
                                 curSequences.Add(new PeriodSequenceDet
                                 {
@@ -1708,10 +1711,9 @@ namespace Business.ResourceExamineManagement
                                                     //剩余可用工作时长不能满足清场时长
                                                     else
                                                     {
-                                                        endTime = dto.EndTime;
                                                         //还需排产的清场时间
                                                         decimal qcTime = needTime - restTime;
-                                                        endTime.AddMinutes((double)qcTime);
+                                                        endTime = dto.EndTime.AddMinutes((double)qcTime);
                                                         restTime = 0;
                                                     }
                                                     //最后一个工单的清场时长
@@ -1917,10 +1919,9 @@ namespace Business.ResourceExamineManagement
                                                     });
                                                     //当前工单已排产完成，已排产时间=工单生产时长，已排产数量=工单数量
                                                     item.Worked = item.LbrVar;
-                                                    item.QtyWorked = item.QtyWorked;
+                                                    item.QtyWorked = item.QtyOrded;
 
                                                     beginTime = endTime;
-                                                    curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                                     if (restTime > 0)
                                                     {
                                                         curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
@@ -1931,6 +1932,7 @@ namespace Business.ResourceExamineManagement
                                                             {
                                                                 endTime = nextPoint.StartPoint;
                                                             }
+                                                            beginTime = endTime;
                                                         }
                                                     }
                                                     //当天产能已全部用完
@@ -1970,14 +1972,14 @@ namespace Business.ResourceExamineManagement
                                                         WorkDate = beginTime.Date,
                                                         WorkQty = qty,
                                                         WorkStartTime = beginTime,
-                                                        WorkEndTime = endTime,
+                                                        WorkEndTime = dto.EndTime,
                                                         CreateTime = DateTime.Now
                                                     });
                                                     item.Worked += restTime;
                                                     item.QtyWorked += qty;
-                                                    restTime = 0m;
                                                     //特殊工单剩余待排产时长(分钟)
                                                     sumTsTimes -= restTime;
+                                                    restTime = 0m;
                                                     break;
                                                 }
                                             }
@@ -2044,7 +2046,7 @@ namespace Business.ResourceExamineManagement
                                     if (item.WorkOrd == lastWork.WorkOrd)
                                     {
                                         //最后一个工单的生产时长+清场时长
-                                        needTime = lastWork.QtyOrded - lastWork.QtyWorked + lastWork.WaitTime;
+                                        needTime = lastWork.LbrVar - lastWork.Worked + lastWork.WaitTime;
                                         //剩余可用工作时长满足最后一个特殊工单的生产时长+清场时长
                                         if (residueTime >= needTime)
                                         {
@@ -2072,10 +2074,9 @@ namespace Business.ResourceExamineManagement
                                         //剩余可用工作时长不能满足清场时长
                                         else
                                         {
-                                            endTime = dto.EndTime;
                                             //还需排产的清场时间
                                             decimal qcTime = needTime - residueTime;
-                                            endTime.AddMinutes((double)qcTime);
+                                            endTime = dto.EndTime.AddMinutes((double)qcTime);
                                             residueTime = 0;
                                         }
                                         //最后一个工单的清场时长
@@ -2165,12 +2166,19 @@ namespace Business.ResourceExamineManagement
                                     item.Worked = item.LbrVar;
                                     item.QtyWorked = item.QtyOrded;
                                 }
+                                //排产完毕，特殊工单时长置0
+                                sumTsTimes = 0;
+                                //当天特殊工单全部排产完成
+                                isFullPC = true;
+                                //特殊工单排产完成，最后一个工单的清场时长置0
+                                lstCleanTime = 0m;
 
                                 //剩余可用生产时长
                                 residueTime = residueTime < 0 ? 0 : residueTime;
                                 //特殊工单处理完成，剩余生产时长大于0且还有正常工单待排产，则继续排正常工单
                                 if (residueTime > 0 && sumQty < workOrd.QtyOrded)
                                 {
+                                    workStartTime = beginTime;//排产开始时间
                                     //剩余产能继续排正常工单
                                     decimal sumAmount = Math.Floor(dto.Rate * residueTime / 60);
                                     //如果剩余产能不能满足正常工单，剩余产能全部排产
@@ -2214,20 +2222,20 @@ namespace Business.ResourceExamineManagement
                                     //剩余产能满足正常工单待排产数量，此时需要排清场时长
                                     else
                                     {
-                                        workStartTime = beginTime;
                                         //剩余需要排产的数量
                                         decimal residueQty = workOrd.QtyOrded - sumQty;
                                         //剩余数量生产需要时长(分钟)
                                         decimal workTime = Math.Ceiling(residueQty / dto.Rate * 60);
+                                        //处理剩余需要生产时长：防止向上取整导致超过residueTime
+                                        workTime = workTime > residueTime ? residueTime : workTime;
                                         curPoint = workPoints.Find(p => p.StartPoint <= workStartTime && workStartTime <= p.EndPoint);
                                         span = curPoint.EndPoint - workStartTime;
                                         //当天工作时间段的有效生产时间
                                         decimal effMins = (decimal)span.TotalMinutes;
-                                        DateTime workEndTime = workStartTime;
                                         //当前工作时间段即可满足产能
                                         if (effMins >= workTime)
                                         {
-                                            workEndTime = workStartTime.AddMinutes((double)workTime);
+                                            endTime = workStartTime.AddMinutes((double)workTime);
                                         }
                                         else
                                         {
@@ -2239,7 +2247,7 @@ namespace Business.ResourceExamineManagement
                                             {
                                                 if (p.WorkMinutes >= nextMins)
                                                 {
-                                                    workEndTime = p.StartPoint.AddMinutes((double)nextMins);
+                                                    endTime = p.StartPoint.AddMinutes((double)nextMins);
                                                     break;
                                                 }
                                                 nextMins -= p.WorkMinutes;
@@ -2319,7 +2327,7 @@ namespace Business.ResourceExamineManagement
                                             WorkDate = workStartTime.Date,
                                             WorkQty = residueQty,
                                             WorkStartTime = workStartTime,
-                                            WorkEndTime = workEndTime,
+                                            WorkEndTime = endTime,
                                             CreateTime = DateTime.Now
                                         });
                                     }
@@ -2329,12 +2337,6 @@ namespace Business.ResourceExamineManagement
                                     workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                                     isFstDay = false;
                                 }
-                                //排产完毕，特殊工单时长置0
-                                sumTsTimes = 0;
-                                //当天特殊工单全部排产完成
-                                isFullPC = true;
-                                //特殊工单排产完成，最后一个工单的清场时长置0
-                                lstCleanTime = 0m;
                             }
                             //当天的可用产能不满特殊工单生产时长,则当天产能全部排特殊工单(至少最后一个特殊工单的生产时长不能满足)
                             else
@@ -2456,7 +2458,7 @@ namespace Business.ResourceExamineManagement
                                         });
                                         //当前工单已排产完成，已排产时间=工单生产时长，已排产数量=工单数量
                                         item.Worked = item.LbrVar;
-                                        item.QtyWorked = item.QtyWorked;
+                                        item.QtyWorked = item.QtyOrded;
 
                                         beginTime = endTime;
                                         //当天可用生产时长还有剩余
@@ -2466,7 +2468,7 @@ namespace Business.ResourceExamineManagement
                                             curPoint = workPoints.Find(p => p.StartPoint <= endTime && endTime <= p.EndPoint);
                                             if (endTime == curPoint.EndPoint)
                                             {
-                                                var nextPoint = workPoints.Find(p => p.Level == curPoint.Level + 1);
+                                                var nextPoint = workPoints.FirstOrDefault(p => p.Level == curPoint.Level + 1);
                                                 endTime = nextPoint == null ? endTime : nextPoint.StartPoint;
                                             }
                                             beginTime = endTime;
@@ -2508,7 +2510,7 @@ namespace Business.ResourceExamineManagement
                                             WorkDate = beginTime.Date,
                                             WorkQty = qty,
                                             WorkStartTime = beginTime,
-                                            WorkEndTime = endTime,
+                                            WorkEndTime = dto.EndTime,
                                             CreateTime = DateTime.Now
                                         });
                                         item.Worked += residueTime;
@@ -2558,7 +2560,7 @@ namespace Business.ResourceExamineManagement
                                             if (item.WorkOrd == lastWork.WorkOrd) 
                                             {
                                                 //最后一个工单的生产时长+清场时长
-                                                needTime = lastWork.QtyOrded - lastWork.QtyWorked + lastWork.WaitTime;
+                                                needTime = lastWork.LbrVar - lastWork.Worked + lastWork.WaitTime;
                                                 //剩余可用工作时长满足最后一个特殊工单的生产时长+清场时长
                                                 if (residueTime >= needTime)
                                                 {
@@ -2586,10 +2588,9 @@ namespace Business.ResourceExamineManagement
                                                 //剩余可用工作时长不能满足清场时长
                                                 else
                                                 {
-                                                    endTime = dto.EndTime;
                                                     //还需排产的清场时间
                                                     decimal qcTime = needTime - residueTime;
-                                                    endTime.AddMinutes((double)qcTime);
+                                                    endTime = dto.EndTime.AddMinutes((double)qcTime);
                                                     residueTime = 0;
                                                 }
                                                 //最后一个工单的清场时长
@@ -2845,7 +2846,7 @@ namespace Business.ResourceExamineManagement
                                                 });
                                                 //当前工单已排产完成，已排产时间=工单生产时长，已排产数量=工单数量
                                                 item.Worked = item.LbrVar;
-                                                item.QtyWorked = item.QtyWorked;
+                                                item.QtyWorked = item.QtyOrded;
 
                                                 beginTime = endTime;
                                                 if (residueTime > 0)
@@ -2896,7 +2897,7 @@ namespace Business.ResourceExamineManagement
                                                     WorkDate = beginTime.Date,
                                                     WorkQty = qty,
                                                     WorkStartTime = beginTime,
-                                                    WorkEndTime = endTime,
+                                                    WorkEndTime = dto.EndTime,
                                                     CreateTime = DateTime.Now
                                                 });
                                                 item.Worked += residueTime;
@@ -2951,6 +2952,7 @@ namespace Business.ResourceExamineManagement
                                     //继续排下一个工作日
                                     workStartTime = GetNextWorkDay((int)workStartTime.DayOfWeek, workStartTime, mLCalendars);
                                     isFstDay = false;
+                                    isFullPC = true;
                                 }
                             }
                             //剩余产能满足正常工单待排产数量，此时需要排清场时长
@@ -2968,6 +2970,8 @@ namespace Business.ResourceExamineManagement
                                     decimal residueQty = workOrd.QtyOrded - sumQty;
                                     //剩余数量生产需要时长(分钟)
                                     workTime = Math.Ceiling(residueQty / dto.Rate * 60);
+                                    //处理需要生产时长
+                                    workTime = workTime >= residueTime ? residueTime : workTime;
                                     var curPoint = workPoints.Find(p => p.StartPoint <= workStartTime && workStartTime <= p.EndPoint);
                                     span = curPoint.EndPoint - workStartTime;
                                     //当天工作时间段的有效生产时间
@@ -3110,7 +3114,7 @@ namespace Business.ResourceExamineManagement
                                                 if (item.WorkOrd == lastWork.WorkOrd)
                                                 {
                                                     //最后一个工单的生产时长+清场时长
-                                                    needTime = lastWork.QtyOrded - lastWork.QtyWorked + lastWork.WaitTime;
+                                                    needTime = lastWork.LbrVar - lastWork.Worked + lastWork.WaitTime;
                                                     //剩余可用工作时长满足最后一个特殊工单的生产时长+清场时长
                                                     if (residueTime >= needTime)
                                                     {
@@ -3139,10 +3143,9 @@ namespace Business.ResourceExamineManagement
                                                     //剩余可用工作时长不能满足清场时长
                                                     else
                                                     {
-                                                        endTime = dto.EndTime;
                                                         //还需排产的清场时间
                                                         decimal qcTime = needTime - residueTime;
-                                                        endTime.AddMinutes((double)qcTime);
+                                                        endTime = dto.EndTime.AddMinutes((double)qcTime);
                                                         residueTime = 0;
                                                     }
                                                     //最后一个工单的清场时长
@@ -3352,7 +3355,7 @@ namespace Business.ResourceExamineManagement
                                                     });
                                                     //当前工单已排产完成，已排产时间=工单生产时长，已排产数量=工单数量
                                                     item.Worked = item.LbrVar;
-                                                    item.QtyWorked = item.QtyWorked;
+                                                    item.QtyWorked = item.QtyOrded;
 
                                                     beginTime = endTime;
                                                     if (residueTime > 0)
@@ -3402,7 +3405,7 @@ namespace Business.ResourceExamineManagement
                                                         WorkDate = beginTime.Date,
                                                         WorkQty = qty,
                                                         WorkStartTime = beginTime,
-                                                        WorkEndTime = endTime,
+                                                        WorkEndTime = dto.EndTime,
                                                         CreateTime = DateTime.Now
                                                     });
                                                     item.Worked += residueTime;

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

@@ -26,6 +26,7 @@ using System.Threading.Tasks;
 using Volo.Abp.Application.Services;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Domain.Repositories;
+using Volo.Abp.Json.SystemTextJson;
 using Volo.Abp.MultiTenancy;
 using Volo.Abp.ObjectMapping;
 using Volo.Abp.Uow;
@@ -2252,7 +2253,7 @@ namespace Business.ResourceExamineManagement
 
 
         /// <summary>
-        /// 计划工单齐套检查
+        /// 计划工单资源检查
         /// </summary>
         /// <param name="input"></param>
         /// <returns></returns>
@@ -2383,21 +2384,50 @@ namespace Business.ResourceExamineManagement
             }
         }
 
+        /// <summary>
+        /// 范围内工单齐套检查
+        /// </summary>
+        /// <param name="domain"></param>
+        /// <param name="userAccount"></param>
+        /// <returns></returns>
+        public async Task<string> OrderCompleteInspection(string domain, string userAccount)
+        {
+            var workords = _workOrdMaster.Select(s => s.Domain == domain && (s.Status == "r" || string.IsNullOrEmpty(s.Status) == true)).ToList();
+            List<mes_morder> morders = _mysql_mes_morder.GetListAsync(x => x.factory_id.ToString() == domain && workords.Select(s => s.WorkOrd).Contains(x.morder_no) && (x.morder_state == MorderEnum.Initial_state || x.morder_state == MorderEnum.Xd_state) && !x.IsDeleted).Result;
+            if (morders.Any())
+            {
+                var rst = await OrderResourceCheck(morders, domain, userAccount);
+                if (rst == "ok")
+                {
+                    try
+                    {
+                        await _mysql_mes_morder.UpdateManyAsync(morders);
+                    }
+                    catch (Exception e)
+                    {
+                        new NLogHelper("ResourceExamineAppService").WriteLog("OrderCompleteInspection", "工单齐套检查失败：" + e.Message, _currentTenant.Id.ToString());
+                    }
+                }
+                else {
+                    return rst;
+                }
+            }
+            return "ok";
+        }
+
+
 
         /// <summary>
-        /// 按工单齐套检查
+        /// 原材料在库检查
         /// </summary>
         /// <param name="input"></param>
         /// <returns></returns>
-        public async Task<string> OrderResourceCheck(List<mes_morder> mo_Mes_Morders,string domain, string userAccount, bool WordOrdXd=false)
+        public async Task<string> OrderResourceCheck(List<mes_morder> mo_Mes_Morders,string domain, string userAccount)
         {
             List<mes_morder> checkMo = new List<mes_morder>();
             //只做库存是否齐套检查
             if (mo_Mes_Morders.Any())
             {
-                List<mes_morder> updateList = new List<mes_morder>();
-                List<mes_morder> xdupdateList = new List<mes_morder>();
-
                 //检查工单是否已经下了领料单
                 var nbrList = _nbrMaster.Select(a => a.Domain == domain && a.Type == "SM" && mo_Mes_Morders.Select(c => c.morder_no).Contains(a.WorkOrd));
                 foreach (var mo in mo_Mes_Morders)
@@ -2427,30 +2457,17 @@ namespace Business.ResourceExamineManagement
                             //工单状态为  “备料中”
                             mo.MaterialSituation = MorderEnum.Preparation;
                         }
-                        updateList.Add(mo);
                         //完成时间已经过去，则不做处理
                     }
                     else {
                         checkMo.Add(mo);
                     }
                 }
-
-                string workords = "";
-
                 if (checkMo.Any())
                 {
                     var rtn = await OrderKittingCheck(checkMo);
                     if (rtn != null && rtn.examines != null)
                     {
-                        var sysSet = _generalizedCodeMaster.Select(s => s.FldName == "SystemConfig" && s.Val == "WorkOrderLockPeriod" && s.Domain == domain).ToList();
-                        decimal lookDay = 0;
-                        if (sysSet.Any())
-                        {
-                            //锁定期
-                            lookDay = sysSet[0].UDeci1;
-                        }
-                        lookDay = lookDay == 0 ? 7 : lookDay;
-                        DateTime lookTime = DateTime.Now.Date.AddDays((double)lookDay);
                         //循环处理工单
                         foreach (var cmo in checkMo)
                         {
@@ -2463,7 +2480,7 @@ namespace Business.ResourceExamineManagement
                                     //如果有缺料
                                     if (bce.is_use && bce.stock_state == 0)
                                     {
-                                        //如果当前数据没有子级，则代表原材料
+                                        //如果当前数据没有子级，则代表原材料齐套
                                         if (exm.BomChildExamineList.Where(s => s.parent_id == bce.fid).Count() == 0)
                                         {
                                             flag = false;
@@ -2479,67 +2496,15 @@ namespace Business.ResourceExamineManagement
                             if (flag)
                             {
                                 //锁定期内生产备料单，并且更新为备料中，锁定期外的则更新成仓库齐套。
-                                if (cmo.moentry_sys_stime.GetValueOrDefault().Date <= lookTime)
-                                {
-                                    //生成领料单
-                                    workords += "," + cmo.morder_no;
-                                    cmo.MaterialSituation = MorderEnum.Preparation;
-                                    cmo.morder_state = MorderEnum.Xd_state;
-                                    updateList.Add(cmo);
-                                }
-                                else {
-                                    cmo.MaterialSituation = MorderEnum.CarehouseComplete;
-                                    if (WordOrdXd)
-                                    {
-                                        workords += "," + cmo.morder_no;
-                                        cmo.MaterialSituation = MorderEnum.Preparation;
-                                        cmo.morder_state = MorderEnum.Xd_state;
-                                        xdupdateList.Add(cmo);
-                                    }
-                                    else {
-                                        updateList.Add(cmo);
-                                    }
-                                }
+                                cmo.MaterialSituation = MorderEnum.CarehouseComplete;
                             }
                             else
                             {
                                 //工单状态为  “仓库不齐套”
                                 cmo.MaterialSituation = MorderEnum.NoCarehouseComplete;
-                                if (WordOrdXd)
-                                {
-                                    workords += "," + cmo.morder_no;
-                                    cmo.morder_state = MorderEnum.Xd_state;
-                                    cmo.MaterialSituation = MorderEnum.Part;
-                                    xdupdateList.Add(cmo);
-                                }
-                                else
-                                {
-                                    updateList.Add(cmo);
-                                }
                             }
                         }
                     }
-                    /*OrderResourceViewDto result = DataPackage(rtn);
-                    result.DayBulletinBoardList = result.DayBulletinBoardList.OrderByDescending(d => d.day).ToList();
-                    //保存检查结果
-                    SaveExamineResult(result.KittingCheckResultList, result.DayBulletinBoardList, 1);*/
-                }
-                _businessDbContext.BulkUpdate(updateList);
-                if (workords.Length > 0)
-                {
-                    workords = workords.Substring(1, workords.Length - 1);
-                    //如果生成领料单，需清理掉当前工单的占用，然后根据领料单的数据，来生成工单的占用
-                    var rst = await CreatePickBill(workords, domain, userAccount);
-                    if (rst != "ok")
-                    {
-                        return rst;
-                    }
-                    _businessDbContext.BulkUpdate(xdupdateList);
-                    var insertList = GetCopyOP(workords, domain);
-                    if (insertList.Any())
-                    {
-                        _periodSequenceDet.Insert(insertList);
-                    }
                 }
                 return "ok";
             }
@@ -2629,7 +2594,7 @@ namespace Business.ResourceExamineManagement
         }
 
         /// <summary>
-        /// 范围内工单齐套检查并下达
+        /// 自动下达
         /// </summary>
         /// <param name="startime"></param>
         /// <param name="endtime"></param>
@@ -2647,12 +2612,58 @@ namespace Business.ResourceExamineManagement
             {
                 DateTime.TryParse(startime, out etime);
             }
-
-            var periodSd = _periodSequenceDet.Select(s => s.Domain == domain && (s.Status == "" || s.Status == "r") && stime <= s.PlanDate && s.PlanDate <= etime).ToList();
+            //根据排产日计划来获取
+            var periodSd = _periodSequenceDet.Select(s => s.Domain == domain && string.IsNullOrEmpty(s.Status) == true && stime <= s.PlanDate && s.PlanDate <= etime).ToList();
             if (periodSd.Any())
             {
-                List<mes_morder> mo_Mes_Morders = _mysql_mes_morder.GetListAsync(x => domain == x.factory_id.ToString() && periodSd.Select(s => s.WorkOrds).Contains(x.morder_no) && (x.morder_state == MorderEnum.Initial_state || x.morder_state == MorderEnum.Xd_state) && !x.IsDeleted).Result;
-                return await OrderResourceCheck(mo_Mes_Morders, domain, userAccount);
+                List<mes_morder> morders = _mysql_mes_morder.GetListAsync(x => domain == x.factory_id.ToString() && periodSd.Select(s => s.WorkOrds).Contains(x.morder_no) && (x.morder_state == MorderEnum.Initial_state || x.morder_state == MorderEnum.Xd_state) && !x.IsDeleted).Result;
+                if (!morders.Any())
+                {
+                    return "没有需要下达的工单";
+                }
+                var rst = await OrderResourceCheck(morders, domain, userAccount);
+                if (rst == "ok")
+                {
+                    var sysSet = _generalizedCodeMaster.Select(s => s.FldName == "SystemConfig" && s.Val == "WorkOrderLockPeriod" && s.Domain == domain).ToList();
+                    decimal lookDay = 0;
+                    if (sysSet.Any())
+                    {
+                        //锁定期
+                        lookDay = sysSet[0].UDeci1;
+                    }
+                    lookDay = lookDay == 0 ? 7 : lookDay;
+                    DateTime lookTime = DateTime.Now.Date.AddDays((double)lookDay);
+
+                    string workords = "";
+                    foreach (var mo in morders)
+                    {
+                        if (mo.MaterialSituation == MorderEnum.CarehouseComplete && mo.morder_state == MorderEnum.Initial_state && mo.moentry_sys_stime.GetValueOrDefault().Date <= lookTime)
+                        {
+                            workords += "," + mo.morder_no;
+                            mo.morder_state = MorderEnum.Xd_state;
+                        }
+                    }
+                    await _mysql_mes_morder.UpdateManyAsync(morders);
+                    if (workords.Length > 0)
+                    {
+                        workords = workords.Substring(1, workords.Length - 1);
+                        //如果生成领料单，需清理掉当前工单的占用，然后根据领料单的数据，来生成工单的占用
+                        var pickRst = await CreatePickBill(workords, domain, userAccount);
+                        if (pickRst != "ok")
+                        {
+                            return pickRst;
+                        }
+                        var insertList = GetCopyOP(workords, domain);
+                        if (insertList.Any())
+                        {
+                            _periodSequenceDet.Insert(insertList);
+                        }
+                    }
+                    return "ok";
+                }
+                else {
+                    return rst;
+                }
             }
             else { 
                 return "没有需要下达的工单";
@@ -2660,7 +2671,7 @@ namespace Business.ResourceExamineManagement
         }
 
         /// <summary>
-        /// 工单齐套检查并下达
+        /// 手动按工单下达
         /// </summary>
         /// <param name="startime"></param>
         /// <param name="endtime"></param>
@@ -2670,14 +2681,45 @@ namespace Business.ResourceExamineManagement
         {
             if (!string.IsNullOrEmpty(workord))
             {
-                List<mes_morder> mo_Mes_Morders = _mysql_mes_morder.GetListAsync(x => domain == x.factory_id.ToString() && x.morder_no == workord && !x.IsDeleted).Result;
-                if (mo_Mes_Morders.Any())
+                List<mes_morder> morders = _mysql_mes_morder.GetListAsync(x => domain == x.factory_id.ToString() && x.morder_no == workord && !x.IsDeleted).Result;
+                if (morders.Any())
                 {
-                    if (!string.IsNullOrEmpty(mo_Mes_Morders[0].morder_state) && mo_Mes_Morders[0].morder_state != MorderEnum.Initial_state)
+                    if (!string.IsNullOrEmpty(morders[0].morder_state) && morders[0].morder_state != MorderEnum.Initial_state)
                     {
-                        return "工单信息为"+ mo_Mes_Morders[0].morder_state + ",不允许下达。";
+                        return "工单信息为"+ morders[0].morder_state + ",不允许下达。";
+                    }
+                    var rst = await OrderResourceCheck(morders, domain, userAccount);
+                    if (rst == "ok")
+                    {
+                        try
+                        {
+                            morders[0].morder_state = MorderEnum.Xd_state;
+                            morders[0].MaterialSituation = morders[0].MaterialSituation == MorderEnum.NoCarehouseComplete ? MorderEnum.Part : morders[0].MaterialSituation;
+
+                            //如果生成领料单，需清理掉当前工单的占用，然后根据领料单的数据，来生成工单的占用
+                            var pickRst = await CreatePickBill(morders[0].morder_no, domain, userAccount);
+                            if (pickRst != "ok")
+                            {
+                                return pickRst;
+                            }
+                            await _mysql_mes_morder.UpdateManyAsync(morders);
+                            //复制子工序
+                            var insertList = GetCopyOP(morders[0].morder_no, domain);
+                            if (insertList.Any())
+                            {
+                                _periodSequenceDet.Insert(insertList);
+                            }
+                            return "ok";
+                        }
+                        catch (Exception e)
+                        {
+                            return "下达失败，请联系管理员。";
+                        }
+                    }
+                    else
+                    {
+                        return rst;
                     }
-                    return await OrderResourceCheck(mo_Mes_Morders, domain, userAccount, true);
                 }
                 else {
                     return "工单信息不存在，请重新检查。";
@@ -2756,7 +2798,8 @@ namespace Business.ResourceExamineManagement
         /// <returns></returns>
         public async Task<string> SubstituteResourceCheck(int day, string workOrd)
         {
-            List<mes_morder> mo_Mes_Morders = new List<mes_morder>();
+            //先屏蔽此功能，暂未使用
+            /*List<mes_morder> mo_Mes_Morders = new List<mes_morder>();
             if (day == 0)
             {
                 List<string> workOrds = workOrd.Split(",").ToList();
@@ -2781,7 +2824,8 @@ namespace Business.ResourceExamineManagement
             }
             else {
                 return JsonConvert.SerializeObject("没有需要检查的工单");
-            }
+            }*/
+            return "ok";
         }
 
         /// <summary>

MicroServices/Business/Business.HttpApi/Controllers/ResourceExamineController.cs

@@ -69,7 +69,7 @@ namespace Business.Controllers
         }
 
         /// <summary>
-        /// 齐套检查下达
+        /// 自动下达
         /// </summary>
         /// <param name="input"></param>
         /// <returns></returns>
@@ -93,7 +93,7 @@ namespace Business.Controllers
         }
 
         /// <summary>
-        /// 计划工单齐套检查
+        /// 计划工单资源检查
         /// </summary>
         /// <param name="workOrd"></param>
         /// <returns></returns>
@@ -175,6 +175,13 @@ namespace Business.Controllers
             return _ResourceExamineAppService.PrApprove(ids);
         }
 
+        /// <summary>
+        /// 手动按工单下达
+        /// </summary>
+        /// <param name="workord"></param>
+        /// <param name="domain"></param>
+        /// <param name="userAccount"></param>
+        /// <returns></returns>
         [HttpGet]
         [Route("ProduceWorkOrdKittingCheck")]
         public Task<string> ProduceWorkOrdKittingCheck(string workord, string domain, string userAccount)