Merge remote-tracking branch 'origin/mode-min-unit' into mode-min-unit

cx-aps/cx-aps-common/src/main/java/com/rongwei/bscommon/sys/dao/ApsBlankOrderDao.java

@@ -162,7 +162,7 @@ public interface ApsBlankOrderDao extends BaseMapper<ApsBlankOrderDo> {
     void removeLockNextTwoDayProcessEqu(@Param("needScheduleDate") String needScheduleDate);
 
     List<ApsProcessOperationProcessEquChongpaiVo> selectNeedRescheduleEqu(@Param("needScheduleDate") String needScheduleDate,@Param("tenantId") String tenantId);
-    List<ApsProcessOperationProcessEquChongpaiVo> selectNeedRescheduleEqu2(@Param("needScheduleDate") String needScheduleDate,@Param("tenantId") String tenantId);
+    List<ApsProcessOperationProcessEquDo> selectNeedRescheduleEqu2(@Param("chongpaiStartDate") DateTime chongpaiStartDate, @Param("chongpaiEndDate") DateTime chongpaiEndDate, @Param("tenantId") String tenantId, @Param("workshopin") Integer workshopin, @Param("workshopcross") Integer workshopcross);
 
     List<ApsProcessOperationProcessEquDo> selectNeedRescheduleEqu3(@Param("chongpaiStartDate") DateTime chongpaiStartDate, @Param("chongpaiEndDate") DateTime chongpaiEndDate, @Param("tenantId") String tenantId, @Param("workshopin") Integer workshopin, @Param("workshopcross") Integer workshopcross);
 }

cx-aps/cx-aps-common/src/main/java/com/rongwei/bscommon/sys/dao/ApsProcessOperationProcessEquDao.java

@@ -122,6 +122,8 @@ public interface ApsProcessOperationProcessEquDao extends BaseMapper<ApsProcessO
 
     @Select("select apope.PLANSTARTDATE from aps_process_operation apo LEFT JOIN aps_process_operation_process_equ apope ON apo.ID = apope.PROCESSID AND apope.DELETED = 0 WHERE apo.DELETED = 0 AND apo.BLANKID = #{blankid} AND apo.PROCESS != '铸轧' ORDER BY apope.PLANSTARTDATE limit 1")
     Date getEarltPlanStartDate(@Param("blankid") String blankid);
+
+    List<String> selectEquByProcessId(@Param("processid") String processid);
 }
 
 

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

@@ -69,5 +69,5 @@ public interface ApsBlankOrderService extends IService<ApsBlankOrderDo> {
 
     R checkAddMaterial(AddMaterialReq req);
 
-    void apsScheduleRestart();
+    void apsScheduleRestart(Integer hour);
 }

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

@@ -124,6 +124,8 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
     private ApsProcessOperationProcessEquServiceImpl apsProcessOperationProcessEquServiceImpl;
     @Autowired
     private ApsProcessOperationProcessEquDao apsProcessOperationProcessEquDao;
+    @Autowired
+    private ApsProductionProcessesService apsProductionProcessesService;
 
 
     @Override
@@ -4129,7 +4131,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
     }
 
     @Override
-    public void apsScheduleRestart() {
+    public void apsScheduleRestart(Integer hour) {
         ApsUtils.checkScheduling(null);
         String needScheduleDate = "";
         DateTime nowDate = DateUtil.date();
@@ -4150,6 +4152,9 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             //计算重排开始时间和结束时间
             DateTime chongpaiStartDate = DateUtil.parseDate(needScheduleDate);
             DateTime chongpaiEndDate = DateUtil.endOfDay(chongpaiStartDate);
+            if (ObjectUtil.isNotEmpty(hour)) {
+                chongpaiEndDate = DateUtil.offsetHour(chongpaiStartDate, hour);
+            }
 
             //将实际完工时间大于明天的作业挪到实际完工时间
             this.baseMapper.updateFinishDateAboutProcessEqu(needScheduleDate);
@@ -4157,90 +4162,196 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
 //            List<ApsProcessOperationProcessEquChongpaiVo> list = this.baseMapper.selectNeedRescheduleEqu(needScheduleDate, CXCommonUtils.getCurrentUserFactoryId(null));
             //排程设置
             ApsScheduleConfigDo apsScheduleConfigDo = apsScheduleConfigService.getById("1");
-            //查询需要重排的所有明细信息
-            List<ApsProcessOperationProcessEquDo> needScheduleList = this.baseMapper.selectNeedRescheduleEqu3(chongpaiStartDate, chongpaiEndDate, CXCommonUtils.getCurrentUserFactoryId(null), apsScheduleConfigDo.getWorkshopin(), apsScheduleConfigDo.getWorkshopcross());
-            List<String> needScheduleIdList = needScheduleList.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
-            //查询需要重排的所有坯料计划ID
-            List<String> blankIdList = needScheduleList.stream().map(ApsProcessOperationProcessEquDo::getBlankid).distinct().collect(Collectors.toList());
-            //查询所有基准
-            List<ApsProcessOperationProcessEquDo> allProcessEquList = apsProcessOperationProcessEquService.list(new LambdaQueryWrapper<ApsProcessOperationProcessEquDo>().in(ApsProcessOperationProcessEquDo::getBlankid, blankIdList));
-            List<String> allProcessEquIdList = allProcessEquList.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
-            //查询所有工序作业基准
-            List<ApsProcessOperationDo> allProcessList = apsProcessOperationService.list(new LambdaQueryWrapper<ApsProcessOperationDo>().in(ApsProcessOperationDo::getBlankid, blankIdList));
-            List<String> allProcessIdList = allProcessList.stream().map(ApsProcessOperationDo::getId).distinct().collect(Collectors.toList());
-            //查询所有工序作业对应的可选设备
-            List<ApsProcessOperationEquDo> processOperationEquDoList = apsProcessOperationEquService.list(new LambdaQueryWrapper<ApsProcessOperationEquDo>().in(ApsProcessOperationEquDo::getBlankid, blankIdList));
-
-            //所有需要解锁的明细集合
-            List<ApsProcessOperationProcessEquDo> needUnLockList = new LinkedList<>(needScheduleList);
-            //所有不需要解锁的明细集合
-            List<ApsProcessOperationProcessEquDo> notNeedUnLockList = new LinkedList<>();
-
-            for (ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo : needScheduleList) {
-                //前道作业明细ID不为空
-                if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getPreviousprocessesids())) {
-                    //如果不存在重排之中，但存在基准之中
-                    if (!needScheduleIdList.contains(apsProcessOperationProcessEquDo.getPreviousprocessesids())
-                            && allProcessEquIdList.contains(apsProcessOperationProcessEquDo.getPreviousprocessesids())) {
-                        String previousprocessesid = apsProcessOperationProcessEquDo.getPreviousprocessesids();
-                        //当前明细对应的工序作业
-                        ApsProcessOperationDo nowProcess = allProcessList.stream().filter(item -> apsProcessOperationProcessEquDo.getProcessid().equals(item.getId())).findFirst().orElse(null);
-                        //循环寻找前道明细
-                        while (true) {
-                            if (StringUtils.isBlank(previousprocessesid)) {
+            //冷轧重排
+            lenzhaChongpai(chongpaiStartDate, chongpaiEndDate, apsScheduleConfigDo);
+            //退火重排
+            tuihuoChongpai(chongpaiStartDate, chongpaiEndDate, apsScheduleConfigDo);
+
+        }
+    }
+
+    private void tuihuoChongpai(DateTime chongpaiStartDate, DateTime chongpaiEndDate, ApsScheduleConfigDo apsScheduleConfigDo) {
+        //退火重排
+        //查询在重排时间段的所有作业明细信息,只包括：成退、中退、小卷成退
+        List<ApsProcessOperationProcessEquDo> needScheduleList = this.baseMapper.selectNeedRescheduleEqu2(chongpaiStartDate, chongpaiEndDate, CXCommonUtils.getCurrentUserFactoryId(null), apsScheduleConfigDo.getWorkshopin(), apsScheduleConfigDo.getWorkshopcross());
+        if (needScheduleList.isEmpty()) {
+            log.info("未查询到退火作业明细，结束排程");
+            return;
+        }
+        List<String> needScheduleIdList = needScheduleList.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
+        List<String> blankIdList = needScheduleList.stream().map(item -> item.getBlankid()).distinct().collect(Collectors.toList());
+        //查询基准明细
+        List<ApsProcessOperationProcessEquDo> allProcessEquList = apsProcessOperationProcessEquService.list(new LambdaQueryWrapper<ApsProcessOperationProcessEquDo>().in(ApsProcessOperationProcessEquDo::getBlankid, blankIdList));
+        List<String> allProcessEquIdList = allProcessEquList.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
+        //查询所有工序作业基准
+        List<ApsProcessOperationDo> allProcessList = apsProcessOperationService.list(new LambdaQueryWrapper<ApsProcessOperationDo>().in(ApsProcessOperationDo::getBlankid, blankIdList));
+        List<String> allProcessIdList = allProcessList.stream().map(ApsProcessOperationDo::getId).distinct().collect(Collectors.toList());
+
+
+        //所有需要解锁的明细集合
+        List<ApsProcessOperationProcessEquDo> needUnLockList = new LinkedList<>(needScheduleList);
+        //所有不需要解锁的明细集合
+        List<ApsProcessOperationProcessEquDo> notNeedUnLockList = new LinkedList<>();
+
+        //查找前道
+        for (ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo : needScheduleList) {
+            String previousProcessId = apsProcessOperationProcessEquDo.getPreviousprocessesids();
+            if (ObjectUtil.isNotEmpty(previousProcessId)) {
+                //不在重排中，但在基准中，不解锁加入排程服务
+                if (!needScheduleIdList.contains(previousProcessId)
+                        && allProcessEquIdList.contains(previousProcessId)) {
+                    ApsProcessOperationProcessEquDo previousEqu = allProcessEquList.stream().filter(item -> previousProcessId.equals(item.getId())).findFirst().orElse(null);
+                    if (ObjectUtil.isNotEmpty(previousEqu)) {
+                        notNeedUnLockList.add(previousEqu);
+                    }
+                }
+            }
+        }
+
+        //查询工序类别为：精整 的工序
+        List<ApsProductionProcessesDo> jzProcessList = apsProductionProcessesService.list(new LambdaQueryWrapper<ApsProductionProcessesDo>().eq(ApsProductionProcessesDo::getProcesscategory, "精整"));
+        List<String> jzProcessNameList = jzProcessList.stream().map(ApsProductionProcessesDo::getProductprocessname).distinct().collect(Collectors.toList());
+        for (ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo : needScheduleList) {
+            if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getNextprocessesids())) {
+                for (String nextProcessId : apsProcessOperationProcessEquDo.getNextprocessesids().split(",")) {
+                    //不在重排中，但在基准中，如果是 精整工序，需要解锁加入排程
+                    if (!needScheduleIdList.contains(nextProcessId)
+                            && allProcessEquIdList.contains(nextProcessId)) {
+                        //查询后道的明细
+                        ApsProcessOperationProcessEquDo nextEqu = allProcessEquList.stream().filter(item -> nextProcessId.equals(item.getId())).findFirst().orElse(null);
+                        if (ObjectUtil.isNotEmpty(nextEqu)) {
+                            //查询后道的工序作业
+                            ApsProcessOperationDo nextProcess = allProcessList.stream().filter(item -> nextEqu.getProcessid().equals(item.getId())).findFirst().orElse(null);
+                            if (jzProcessNameList.contains(nextProcess.getProcess())) {
+                                needUnLockList.add(nextEqu);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        //需要解锁的明细ID
+        List<String> needUnLockProcessEquIdList = needUnLockList.stream().map(ApsProcessOperationProcessEquDo::getId).distinct().collect(Collectors.toList());
+        //需要解锁的作业ID
+        List<String> needUnLockProcessIdList = needUnLockList.stream().map(ApsProcessOperationProcessEquDo::getProcessid).distinct().collect(Collectors.toList());
+        //不需要解锁的作业ID
+        List<String> notNeedUnLockProcessIdList = notNeedUnLockList.stream().map(ApsProcessOperationProcessEquDo::getProcessid).distinct().collect(Collectors.toList());
+        log.info("退火解锁的作业明细：{}", needUnLockList);
+        log.info("退火解锁的作业明细ID：{}", needUnLockProcessEquIdList);
+        log.info("退火解锁的作业ID：{}", needUnLockProcessIdList);
+        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)
+        );
+
+        //重新排程
+        String scheduletype = apsScheduleConfigDo.getScheduletype();
+        ApsTypeVo apsTypeVo = BeanUtil.toBean(scheduletype, ApsTypeVo.class);
+        apsTypeVo.setMixIf("default");
+        apsTypeVo.setThMergeMode("thMergeBf");
+        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 void lenzhaChongpai(DateTime chongpaiStartDate, DateTime chongpaiEndDate, ApsScheduleConfigDo apsScheduleConfigDo) {
+        //查询需要重排的所有明细信息
+        List<ApsProcessOperationProcessEquDo> needScheduleList = this.baseMapper.selectNeedRescheduleEqu3(chongpaiStartDate, chongpaiEndDate, CXCommonUtils.getCurrentUserFactoryId(null), apsScheduleConfigDo.getWorkshopin(), apsScheduleConfigDo.getWorkshopcross());
+        if (needScheduleList.isEmpty()) {
+            log.info("未查询到冷轧作业明细，结束排程");
+            return;
+        }
+        List<String> needScheduleIdList = needScheduleList.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
+        //查询需要重排的所有坯料计划ID
+        List<String> blankIdList = needScheduleList.stream().map(ApsProcessOperationProcessEquDo::getBlankid).distinct().collect(Collectors.toList());
+        //查询所有基准
+        List<ApsProcessOperationProcessEquDo> allProcessEquList = apsProcessOperationProcessEquService.list(new LambdaQueryWrapper<ApsProcessOperationProcessEquDo>().in(ApsProcessOperationProcessEquDo::getBlankid, blankIdList));
+        List<String> allProcessEquIdList = allProcessEquList.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
+        //查询所有工序作业基准
+        List<ApsProcessOperationDo> allProcessList = apsProcessOperationService.list(new LambdaQueryWrapper<ApsProcessOperationDo>().in(ApsProcessOperationDo::getBlankid, blankIdList));
+        List<String> allProcessIdList = allProcessList.stream().map(ApsProcessOperationDo::getId).distinct().collect(Collectors.toList());
+        //查询所有工序作业对应的可选设备
+        List<ApsProcessOperationEquDo> processOperationEquDoList = apsProcessOperationEquService.list(new LambdaQueryWrapper<ApsProcessOperationEquDo>().in(ApsProcessOperationEquDo::getBlankid, blankIdList));
+
+        //所有需要解锁的明细集合
+        List<ApsProcessOperationProcessEquDo> needUnLockList = new LinkedList<>(needScheduleList);
+        //所有不需要解锁的明细集合
+        List<ApsProcessOperationProcessEquDo> notNeedUnLockList = new LinkedList<>();
+
+        for (ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo : needScheduleList) {
+            //前道作业明细ID不为空
+            if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getPreviousprocessesids())) {
+                //如果不存在重排之中，但存在基准之中
+                if (!needScheduleIdList.contains(apsProcessOperationProcessEquDo.getPreviousprocessesids())
+                        && allProcessEquIdList.contains(apsProcessOperationProcessEquDo.getPreviousprocessesids())) {
+                    String previousprocessesid = apsProcessOperationProcessEquDo.getPreviousprocessesids();
+                    //当前明细对应的工序作业
+                    ApsProcessOperationDo nowProcess = allProcessList.stream().filter(item -> apsProcessOperationProcessEquDo.getProcessid().equals(item.getId())).findFirst().orElse(null);
+                    //循环寻找前道明细
+                    while (true) {
+                        if (StringUtils.isBlank(previousprocessesid)) {
+                            break;
+                        }
+                        if (ObjectUtil.isEmpty(nowProcess)) {
+                            break;
+                        }
+                        //上一个明细
+                        String finalPreviousprocessesid = previousprocessesid;
+                        ApsProcessOperationProcessEquDo previousEqu = allProcessEquList.stream().filter(item -> finalPreviousprocessesid.equals(item.getId())).findFirst().orElse(null);
+                        if (ObjectUtil.isNotEmpty(previousEqu)) {
+                            //上一个明细的工序作业
+                            ApsProcessOperationDo previousProcess = allProcessList.stream().filter(item -> previousEqu.getProcessid().equals(item.getId())).findFirst().orElse(null);
+                            if (ObjectUtil.isEmpty(previousProcess)) {
                                 break;
                             }
-                            if (ObjectUtil.isEmpty(nowProcess)) {
+                            //如果前道工序是 铸轧或退火  或者 前道明细不是 “待开工”，不解锁，但要传入排程
+                            if (Arrays.asList("铸轧", "成退", "小卷成退", "中退").contains(previousProcess.getProcess())
+                                    || !"待开工".equals(previousEqu.getWorkstatus())) {
+                                notNeedUnLockList.add(previousEqu);
                                 break;
                             }
-                            //上一个明细
-                            String finalPreviousprocessesid = previousprocessesid;
-                            ApsProcessOperationProcessEquDo previousEqu = allProcessEquList.stream().filter(item -> finalPreviousprocessesid.equals(item.getId())).findFirst().orElse(null);
-                            if (ObjectUtil.isNotEmpty(previousEqu)) {
-                                //上一个明细的工序作业
-                                ApsProcessOperationDo previousProcess = allProcessList.stream().filter(item -> previousEqu.getProcessid().equals(item.getId())).findFirst().orElse(null);
-                                if (ObjectUtil.isEmpty(previousProcess)) {
-                                    break;
-                                }
-                                //如果前道工序是 铸轧或退火  或者 前道明细不是 “待开工”，不解锁，但要传入排程
-                                if (Arrays.asList("铸轧", "成退", "小卷成退", "中退").contains(previousProcess.getProcess())
-                                        || !"待开工".equals(previousEqu.getWorkstatus())) {
-                                    notNeedUnLockList.add(previousEqu);
-                                    break;
-                                }
-                                //如果本道工序和前道工序 的工序类型相同，并且最小等待时间为空/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())
-                                                    && equDo.getRollerid().equals(equDo2.getRollerid())) {
-                                                have = true;
-                                                break;
-                                            }
-                                        }
-                                    }
-                                    //存在相同
+                            //如果本道工序和前道工序 的工序类型相同，并且最小等待时间为空/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) {
-                                        needUnLockList.add(previousEqu);
-                                        if (ObjectUtil.isNotEmpty(previousEqu.getPreviousprocessesids())) {
-                                            previousprocessesid = previousEqu.getPreviousprocessesids();
-                                            nowProcess = previousProcess;
-                                        } else {
+                                        break;
+                                    }
+                                    for (ApsProcessOperationEquDo equDo2 : previousEquList) {
+                                        if (equDo.getResourceid().equals(equDo2.getResourceid())
+                                                && equDo.getRollerid().equals(equDo2.getRollerid())) {
+                                            have = true;
                                             break;
                                         }
+                                    }
+                                }
+                                //存在相同
+                                if (have) {
+                                    needUnLockList.add(previousEqu);
+                                    if (ObjectUtil.isNotEmpty(previousEqu.getPreviousprocessesids())) {
+                                        previousprocessesid = previousEqu.getPreviousprocessesids();
+                                        nowProcess = previousProcess;
                                     } else {
-                                        notNeedUnLockList.add(previousEqu);
                                         break;
                                     }
                                 } else {
@@ -4248,82 +4359,55 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                                     break;
                                 }
                             } else {
+                                notNeedUnLockList.add(previousEqu);
                                 break;
                             }
+                        } else {
+                            break;
                         }
                     }
                 }
-                //后道明细不为空
-                if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getNextprocessesids())) {
-                    getNextProcess(apsProcessOperationProcessEquDo.getNextprocessesids(), needScheduleList, needScheduleIdList, allProcessEquList, allProcessEquIdList, needUnLockList, allProcessList);
-                }
             }
-            //需要解锁的明细ID
-            List<String> needUnLockProcessEquIdList = needUnLockList.stream().map(ApsProcessOperationProcessEquDo::getId).distinct().collect(Collectors.toList());
-            //需要解锁的作业ID
-            List<String> needUnLockProcessIdList = needUnLockList.stream().map(ApsProcessOperationProcessEquDo::getProcessid).distinct().collect(Collectors.toList());
-            //不需要解锁的作业ID
-            List<String> notNeedUnLockProcessIdList = notNeedUnLockList.stream().map(ApsProcessOperationProcessEquDo::getProcessid).distinct().collect(Collectors.toList());
-            log.info("解锁的作业明细：{}", needUnLockList);
-            log.info("解锁的作业明细ID：{}", needUnLockProcessEquIdList);
-            log.info("解锁的作业ID：{}", needUnLockProcessIdList);
-            log.info("不用解锁，但需要传入排程的作业明细：{}", notNeedUnLockList);
-            log.info("不用解锁，但需要传入排程的作业ID：{}", notNeedUnLockProcessIdList);
-            //解锁
-            apsProcessOperationProcessEquService.update(
-                    new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
-                            .set(ApsProcessOperationProcessEquDo::getLockmark, "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);
+            //后道明细不为空
+            if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getNextprocessesids())) {
+                getNextProcess(apsProcessOperationProcessEquDo.getNextprocessesids(), needScheduleList, needScheduleIdList, allProcessEquList, allProcessEquIdList, needUnLockList, allProcessList);
+            }
+        }
+        //需要解锁的明细ID
+        List<String> needUnLockProcessEquIdList = needUnLockList.stream().map(ApsProcessOperationProcessEquDo::getId).distinct().collect(Collectors.toList());
+        //需要解锁的作业ID
+        List<String> needUnLockProcessIdList = needUnLockList.stream().map(ApsProcessOperationProcessEquDo::getProcessid).distinct().collect(Collectors.toList());
+        //不需要解锁的作业ID
+        List<String> notNeedUnLockProcessIdList = notNeedUnLockList.stream().map(ApsProcessOperationProcessEquDo::getProcessid).distinct().collect(Collectors.toList());
+        log.info("解锁的作业明细：{}", needUnLockList);
+        log.info("解锁的作业明细ID：{}", needUnLockProcessEquIdList);
+        log.info("解锁的作业ID：{}", needUnLockProcessIdList);
+        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)
+        );
+
+        String scheduletype = apsScheduleConfigDo.getScheduletype();
+        ApsTypeVo apsTypeVo = BeanUtil.toBean(scheduletype, ApsTypeVo.class);
 //            apsTypeVo.setMixIf("mix");
 //            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);
-
-//            //退火重排
-//            //查询在重排时间段的所有作业明细信息,只包括：成退、中退、小卷成退
-//            List<ApsProcessOperationProcessEquChongpaiVo> list2 = this.baseMapper.selectNeedRescheduleEqu2(needScheduleDate, CXCommonUtils.getCurrentUserFactoryId(null));
-//            if (list2.isEmpty()) {
-//                log.info("未查询到退火作业明细，结束排程");
-//                return;
-//            }
-//            //需要解锁的明细ID
-//            List<String> needUnLockProcessEquIdList2 = list2.stream().map(ApsProcessOperationProcessEquChongpaiVo::getId).distinct().collect(Collectors.toList());
-//            //需要解锁的作业ID
-//            List<String> needUnLockProcessIdList2 = list2.stream().map(ApsProcessOperationProcessEquChongpaiVo::getProcessid).distinct().collect(Collectors.toList());
-//            log.info("解锁的退火作业明细：{}", list2);
-//            log.info("解锁的退火作业明细ID：{}", needUnLockProcessEquIdList2);
-//            log.info("解锁的退火作业ID：{}", needUnLockProcessIdList2);
-//            //解锁
-//            apsProcessOperationProcessEquService.update(
-//                    new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
-//                            .set(ApsProcessOperationProcessEquDo::getLockmark, "n")
-//                            .in(ApsProcessOperationProcessEquDo::getId, needUnLockProcessEquIdList2));
-//            apsProcessOperationService.update(
-//                    new LambdaUpdateWrapper<ApsProcessOperationDo>()
-//                            .set(ApsProcessOperationDo::getLockmark, "n")
-//                            .in(ApsProcessOperationDo::getId, needUnLockProcessIdList2)
-//            );
-//            //重新排程
-//            apsTypeVo.setMixIf("default");
-//            apsTypeVo.setThMergeMode("thMergeBf");
-//            apsService.apsSchedule(new ArrayList<>(), apsTypeVo, null, needUnLockProcessIdList);
-
+        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);
 
-        }
     }
 
     //迭代处理寻找下道明细

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

@@ -603,8 +603,9 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
         //工序作业ID
         String processid = apsProcessOperationProcessEquDo.getProcessid();
         //查询工艺步骤指定的可选设备
-        List<ApsProcessOperationEquDo> processOperationEquDos = apsProcessOperationEquService.list(new LambdaQueryWrapper<ApsProcessOperationEquDo>().eq(ApsProcessOperationEquDo::getMainid, processid));
-        long count = processOperationEquDos.stream().filter(item -> item.getResourceid().equals(apsProcessOperationProcessEquDo.getProcessdeviceid())).count();
+        List<String> processOperationEquList = this.baseMapper.selectEquByProcessId(processid);
+//        List<ApsProcessOperationEquDo> processOperationEquDos = apsProcessOperationEquService.list(new LambdaQueryWrapper<ApsProcessOperationEquDo>().eq(ApsProcessOperationEquDo::getMainid, processid));
+        long count = processOperationEquList.stream().filter(item -> item.equals(apsProcessOperationProcessEquDo.getProcessdeviceid())).count();
         String newConflictdes = apsProcessOperationProcessEquDo.getConflictdes();
         if (count <= 0) {
             //如果加工设备不是工艺步骤指定的可选设备，记录冲突：加工设备不是工艺要求的可选设备

cx-aps/cx-aps-common/src/main/resources/mybatis/ApsBlankOrderDao.xml

@@ -419,26 +419,30 @@
         WHERE
             apo.DELETED = 0
           AND apo.PROCESS NOT IN ( '铸轧', '成退', '中退', '小卷成退' )
-          AND apope.PLANSTARTDATE >= DATE_SUB('2025-02-12', INTERVAL 1 DAY)
+          AND apope.PLANSTARTDATE >= DATE_SUB(#{needScheduleDate}, INTERVAL 1 DAY)
           and apope.WORKSTATUS = '待开工'
           AND apope.TENANTID = #{tenantId}
     </select>
     <select id="selectNeedRescheduleEqu2"
-            resultType="com.rongwei.bsentity.vo.ApsProcessOperationProcessEquChongpaiVo">
-        SELECT
-            apope.*,
-            IFNULL(apo.MINFLOWWAITMIN,0) AS 'minflowwaitmin',
-            aci.TENANTID AS 'deviceFactory'
+            resultType="com.rongwei.bsentity.domain.ApsProcessOperationProcessEquDo">
+        SELECT apope.*
         FROM
-            aps_process_operation apo
-                LEFT JOIN aps_process_operation_process_equ apope ON apo.ID = apope.PROCESSID AND apope.DELETED = 0
-                LEFT JOIN asp_check_items aci ON apope.PROCESSDEVICEID = aci.ID AND aci.DELETED = 0
+            aps_process_operation_process_equ apope
+                join aps_process_operation apo on apo.ID = apope.PROCESSID
+                left join aps_process_operation_process_equ preapope on apope.PREVIOUSPROCESSESIDS = preapope.id AND preapope.DELETED = '0'
         WHERE
-            apo.DELETED = 0
-          AND apo.PROCESS IN ( '成退', '中退', '小卷成退' )
-          AND apope.PLANSTARTDATE >= #{needScheduleDate}
+            apope.deleted = '0' AND apo.DELETED = '0'
+          and apope.TENANTID = #{tenantId}
+          and apo.PROCESS in ('中退','成退','小卷成退')
           and apope.WORKSTATUS = '待开工'
-          AND apope.TENANTID = #{tenantId}
+          and apope.PLANSTARTDATE >= #{chongpaiStartDate} -- 调度开始时间之后开工
+          AND (apope.PLANSTARTDATE &lt;= #{chongpaiEndDate} -- 调度结束时间之前开工
+            OR date_add(preapope.PLANENDDATE, -- 前道计划完工时间 + 流转时间
+            INTERVAL GREATEST(ifnull(apo.MINFLOWWAITMIN,0), -- 最小流转等待时间
+            if(apope.PROCESSWORKSHOPID!=preapope.PROCESSWORKSHOPID,#{workshopcross}, -- 车间流转时间
+            if(apope.PROCESSDEVICEID!=preapope.PROCESSDEVICEID,#{workshopin},0))) MINUTE -- 机台流转时间
+            ) &lt;= #{chongpaiEndDate} -- 调度结束时间之前可以开工
+            )
     </select>
     <select id="selectNeedRescheduleEqu3"
             resultType="com.rongwei.bsentity.domain.ApsProcessOperationProcessEquDo">
@@ -446,7 +450,7 @@
         FROM
         aps_process_operation_process_equ apope
         join aps_process_operation apo on apo.ID = apope.PROCESSID
-        left join aps_process_operation_process_equ preapope on preapope.PREVIOUSPROCESSESIDS = apope.id AND preapope.DELETED = '0'
+        left join aps_process_operation_process_equ preapope on apope.PREVIOUSPROCESSESIDS = preapope.id AND preapope.DELETED = '0'
         WHERE
         apope.deleted = '0' AND apo.DELETED = '0'
         and apope.TENANTID = #{tenantId}

cx-aps/cx-aps-common/src/main/resources/mybatis/ApsProcessOperationProcessEquDao.xml

@@ -577,4 +577,8 @@
             AND apope.PLANSTARTDATE > #{date1}
             AND apope.PLANENDDATE < #{date2}
     </select>
+    <select id="selectEquByProcessId" resultType="java.lang.String">
+        select DISTINCT IF(apoe.RESOURCETYPE = '设备',apoe.RESOURCEID,a.EQUIPMENTID) AS 'EQUIPMENTID' from aps_process_operation_equ apoe LEFT JOIN (select arg.ID,are.EQUIPMENTID from aps_resource_group arg LEFT JOIN aps_resources_equipment are ON arg.ID = are.MAINID AND arg.DELETED = 0 where arg.DELETED = 0) a ON apoe.RESOURCEID = a.ID
+        where apoe.MAINID = #{processid}
+    </select>
 </mapper>

cx-aps/cx-aps-server/src/main/java/com/rongwei/bsserver/controller/ApsBlankOrderController.java

@@ -61,8 +61,8 @@ public class ApsBlankOrderController {
      * 自动调度
      */
     @GetMapping("/apsScheduleRestart")
-    public R apsScheduleRestart() {
-        apsBlankOrderService.apsScheduleRestart();
+    public R apsScheduleRestart(@RequestParam(required = false) Integer hour) {
+        apsBlankOrderService.apsScheduleRestart(hour);
         return R.ok();
     }