aps-调度重排

cx-aps/cx-aps-common/src/main/java/com/rongwei/bscommon/sys/service/impl/ApsBlankOrderServiceImpl.java

@@ -4163,9 +4163,9 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             //排程设置
             ApsScheduleConfigDo apsScheduleConfigDo = apsScheduleConfigService.getById("1");
             //冷轧重排
-//            lenzhaChongpai(chongpaiStartDate, chongpaiEndDate, apsScheduleConfigDo);
+            lenzhaChongpai(chongpaiStartDate, chongpaiEndDate, apsScheduleConfigDo);
             //退火重排
-            tuihuoChongpai(chongpaiStartDate, chongpaiEndDate, apsScheduleConfigDo);
+//            tuihuoChongpai(chongpaiStartDate, chongpaiEndDate, apsScheduleConfigDo);
 
         }
     }
@@ -4294,6 +4294,9 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         //所有不需要解锁的明细集合
         List<ApsProcessOperationProcessEquDo> notNeedUnLockList = new LinkedList<>();
 
+        //调度之前的连续开始，需要推导后续连续去清除需要解锁的明细
+        List<ApsProcessOperationProcessEquDo> cleanNeedUnLockList = new LinkedList<>();
+
         for (ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo : needScheduleList) {
             //前道作业明细ID不为空
             if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getPreviousprocessesids())) {
@@ -4336,50 +4339,25 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                                 notNeedUnLockList.add(previousEqu);
                                 canUnLock = false;
                             } else {
+                                //判断是否连续
+                                boolean isConnect = isConnectProcess(nowProcess, previousProcess, processOperationEquDoList);
                                 //如果连续
-                                //如果本道工序和前道工序 的工序类型相同，并且最小等待时间为空/0，并且可选设备和辊相同 ，加入待解锁集合
-                                if (nowProcess.getProcess().equals(previousProcess.getProcess())
-                                        && (nowProcess.getMinflowwaitmin() == null || nowProcess.getMinflowwaitmin().intValue() == 0)) {
-                                    //对比确认是否存在相同的设备和辊
-                                    boolean have = false;
-                                    //查询当前工序作业的可选设备
-                                    String nowProcessId = nowProcess.getId();
-                                    List<ApsProcessOperationEquDo> nowEquList = processOperationEquDoList.stream().filter(item -> item.getMainid().equals(nowProcessId)).collect(Collectors.toList());
-                                    //查询前道工序作业的可选设备
-                                    List<ApsProcessOperationEquDo> previousEquList = processOperationEquDoList.stream().filter(item -> item.getMainid().equals(previousProcess.getId())).collect(Collectors.toList());
-                                    for (ApsProcessOperationEquDo equDo : nowEquList) {
-                                        if (have) {
-                                            break;
-                                        }
-                                        for (ApsProcessOperationEquDo equDo2 : previousEquList) {
-                                            if (equDo.getResourceid().equals(equDo2.getResourceid())) {
-                                                if (ObjectUtil.isEmpty(equDo.getRollerid()) && ObjectUtil.isEmpty(equDo2.getRollerid())) {
-                                                    have = true;
-                                                    break;
-                                                } else if (ObjectUtil.isNotEmpty(equDo.getRollerid()) && ObjectUtil.isNotEmpty(equDo2.getRollerid())) {
-                                                    if (equDo.getRollerid().equals(equDo2.getRollerid())) {
-                                                        have = true;
-                                                        break;
-                                                    }
-                                                }
-                                            }
-                                        }
+                                if (isConnect) {
+                                    //如果连续的上一道在重排开始时间之前，不解锁，并且不解锁后道与其连续的
+                                    if (previousEqu.getPlanstartdate().before(chongpaiStartDate)) {
+                                        cleanNeedUnLockList.add(previousEqu);
+                                        previousprocessesid = previousEqu.getPreviousprocessesids();
+                                        nowProcess = previousProcess;
+                                        canUnLock = false;
+                                        continue;
                                     }
-                                    //存在相同
-                                    if (have) {
-                                        needUnLockList.add(previousEqu);
-                                        if (ObjectUtil.isNotEmpty(previousEqu.getPreviousprocessesids())) {
-                                            previousprocessesid = previousEqu.getPreviousprocessesids();
-                                            nowProcess = previousProcess;
-                                            canUnLock = false;
-                                        } else {
-                                            break;
-                                        }
-                                    } else {
+                                    needUnLockList.add(previousEqu);
+                                    if (ObjectUtil.isNotEmpty(previousEqu.getPreviousprocessesids())) {
                                         previousprocessesid = previousEqu.getPreviousprocessesids();
                                         nowProcess = previousProcess;
-                                        notNeedUnLockList.add(previousEqu);
                                         canUnLock = false;
+                                    } else {
+                                        break;
                                     }
                                 } else {
                                     previousprocessesid = previousEqu.getPreviousprocessesids();
@@ -4405,6 +4383,17 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                 getNextProcess(apsProcessOperationProcessEquDo.getNextprocessesids(), needScheduleList, needScheduleIdList, allProcessEquList, allProcessEquIdList, needUnLockList, allProcessList);
             }
         }
+        //查询需要清除的明细及其后续 连续的明细
+        for (ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo : cleanNeedUnLockList) {
+            if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getNextprocessesids())) {
+                notNeedUnLockList.add(apsProcessOperationProcessEquDo);
+                getCleanNextProcess(apsProcessOperationProcessEquDo,apsProcessOperationProcessEquDo.getNextprocessesids(), allProcessEquList, allProcessEquIdList, notNeedUnLockList, allProcessList,processOperationEquDoList);
+            }
+        }
+
+        //需要解锁的明细ID过滤掉所有不需要解锁的明细ID
+        needUnLockList.removeAll(notNeedUnLockList);
+
         //需要解锁的明细ID
         List<String> needUnLockProcessEquIdList = needUnLockList.stream().map(ApsProcessOperationProcessEquDo::getId).distinct().collect(Collectors.toList());
         //需要解锁的作业ID
@@ -4417,29 +4406,101 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         log.info("不用解锁，但需要传入排程的作业明细：{}", notNeedUnLockList);
         log.info("不用解锁，但需要传入排程的作业ID：{}", notNeedUnLockProcessIdList);
         //解锁
-        apsProcessOperationProcessEquService.update(
-                new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
-                        .set(ApsProcessOperationProcessEquDo::getLockmarkdetail, "n")
-                        .in(ApsProcessOperationProcessEquDo::getId, needUnLockProcessEquIdList));
-        apsProcessOperationService.update(
-                new LambdaUpdateWrapper<ApsProcessOperationDo>()
-                        .set(ApsProcessOperationDo::getLockmark, "n")
-                        .in(ApsProcessOperationDo::getId, needUnLockProcessIdList)
-        );
+//        apsProcessOperationProcessEquService.update(
+//                new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
+//                        .set(ApsProcessOperationProcessEquDo::getLockmarkdetail, "n")
+//                        .in(ApsProcessOperationProcessEquDo::getId, needUnLockProcessEquIdList));
+//        apsProcessOperationService.update(
+//                new LambdaUpdateWrapper<ApsProcessOperationDo>()
+//                        .set(ApsProcessOperationDo::getLockmark, "n")
+//                        .in(ApsProcessOperationDo::getId, needUnLockProcessIdList)
+//        );
+//
+//        String scheduletype = apsScheduleConfigDo.getScheduletype();
+//        ApsTypeVo apsTypeVo = BeanUtil.toBean(scheduletype, ApsTypeVo.class);
+//        apsTypeVo.setMixIf("default");
+//        apsTypeVo.setThMergeMode("notThMergeBf");
+//        apsTypeVo.setConstraintMode("lz");
+//        apsTypeVo.setScheduleType("dd");
+//        //重新排程
+//        //组装需要传入排程的工序作业ID
+//        needUnLockProcessIdList.addAll(notNeedUnLockProcessIdList);
+//        needUnLockProcessIdList = needUnLockProcessIdList.stream().distinct().collect(Collectors.toList());
+//        log.info("所有传入冷轧排程的作业ID：{}", needUnLockProcessIdList);
+//        apsService.apsSchedule(new ArrayList<>(), apsTypeVo, null, needUnLockProcessIdList);
 
-        String scheduletype = apsScheduleConfigDo.getScheduletype();
-        ApsTypeVo apsTypeVo = BeanUtil.toBean(scheduletype, ApsTypeVo.class);
-        apsTypeVo.setMixIf("default");
-        apsTypeVo.setThMergeMode("notThMergeBf");
-        apsTypeVo.setConstraintMode("lz");
-        apsTypeVo.setScheduleType("dd");
-        //重新排程
-        //组装需要传入排程的工序作业ID
-        needUnLockProcessIdList.addAll(notNeedUnLockProcessIdList);
-        needUnLockProcessIdList = needUnLockProcessIdList.stream().distinct().collect(Collectors.toList());
-        log.info("所有传入冷轧排程的作业ID：{}", needUnLockProcessIdList);
-        apsService.apsSchedule(new ArrayList<>(), apsTypeVo, null, needUnLockProcessIdList);
+    }
+
+    private boolean isConnectProcess(ApsProcessOperationDo nowProcess, ApsProcessOperationDo previousProcess, List<ApsProcessOperationEquDo> processOperationEquDoList) {
+        //如果本道工序和前道工序 的工序类型相同，并且最小等待时间为空/0，并且可选设备和辊相同 ，加入待解锁集合
+        if (nowProcess.getProcess().equals(previousProcess.getProcess())
+                && (nowProcess.getMinflowwaitmin() == null || nowProcess.getMinflowwaitmin().intValue() == 0)) {
+            //对比确认是否存在相同的设备和辊
+            boolean have = false;
+            //查询当前工序作业的可选设备
+            String nowProcessId = nowProcess.getId();
+            List<ApsProcessOperationEquDo> nowEquList = processOperationEquDoList.stream().filter(item -> item.getMainid().equals(nowProcessId)).collect(Collectors.toList());
+            //查询前道工序作业的可选设备
+            List<ApsProcessOperationEquDo> previousEquList = processOperationEquDoList.stream().filter(item -> item.getMainid().equals(previousProcess.getId())).collect(Collectors.toList());
+            for (ApsProcessOperationEquDo equDo : nowEquList) {
+                if (have) {
+                    break;
+                }
+                for (ApsProcessOperationEquDo equDo2 : previousEquList) {
+                    if (equDo.getResourceid().equals(equDo2.getResourceid())) {
+                        if (ObjectUtil.isEmpty(equDo.getRollerid()) && ObjectUtil.isEmpty(equDo2.getRollerid())) {
+                            have = true;
+                            break;
+                        } else if (ObjectUtil.isNotEmpty(equDo.getRollerid()) && ObjectUtil.isNotEmpty(equDo2.getRollerid())) {
+                            if (equDo.getRollerid().equals(equDo2.getRollerid())) {
+                                have = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            //存在相同
+            if (have) {
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+
+    }
 
+    private void getCleanNextProcess(ApsProcessOperationProcessEquDo nowEqu,String nextprocessesids, List<ApsProcessOperationProcessEquDo> allProcessEquList, List<String> allProcessEquIdList, List<ApsProcessOperationProcessEquDo> notNeedUnLockList, List<ApsProcessOperationDo> allProcessList,List<ApsProcessOperationEquDo> processOperationEquDoList) {
+        if (ObjectUtil.isEmpty(nextprocessesids)) {
+            return;
+        }
+        for (String nextProcessEquId : nextprocessesids.split(",")) {
+            //如果是连续，增加不解锁
+            //下一个明细
+            ApsProcessOperationProcessEquDo nextEqu = allProcessEquList.stream().filter(item -> item.getId().equals(nextProcessEquId)).findFirst().orElse(null);
+            if (ObjectUtil.isNotEmpty(nextEqu)) {
+                //查询对应明细的工序作业
+                ApsProcessOperationDo nextProcess = allProcessList.stream().filter(item -> item.getId().equals(nextEqu.getProcessid())).findFirst().orElse(null);
+                //当前作业
+                ApsProcessOperationDo nowProcess = allProcessList.stream().filter(item -> item.getId().equals(nowEqu.getProcessid())).findFirst().orElse(null);
+                //判断是否连续
+                boolean isConnect = isConnectProcess(nextProcess, nowProcess, processOperationEquDoList);
+                //是连续
+                if (isConnect){
+                    //下道不解锁，继续迭代
+                    notNeedUnLockList.add(nowEqu);
+                    if (ObjectUtil.isNotEmpty(nextEqu.getNextprocessesids())) {
+                        String nextNewProcessesids = nextEqu.getNextprocessesids();
+                        getCleanNextProcess(nextEqu,nextNewProcessesids, allProcessEquList, allProcessEquIdList, notNeedUnLockList, allProcessList,processOperationEquDoList);
+                    }
+                }else {
+                    //结束迭代
+                    return;
+                }
+            }
+        }
     }
 
     //迭代处理寻找下道明细