aps-调度重排

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

@@ -1,5 +1,6 @@
 package com.rongwei.bscommon.sys.dao;
 
+import cn.hutool.core.date.DateTime;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
@@ -161,4 +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> 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/service/impl/ApsBlankOrderServiceImpl.java

@@ -2,6 +2,7 @@ package com.rongwei.bscommon.sys.service.impl;
 
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.collection.ListUtil;
 import cn.hutool.core.date.DateField;
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.date.DateUtil;
@@ -735,7 +736,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
      */
     @Override
     public void blankOrderAps(List<ApsBlankOrderVo> apsBlankOrders) {
-        apsService.apsSchedule(apsBlankOrders, null, null,null);
+        apsService.apsSchedule(apsBlankOrders, null, null, null);
     }
 
     /**
@@ -745,7 +746,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
      */
     @Transactional(rollbackFor = Exception.class)
     @Override
-    public void apsAfter(ProductionScheduleRetVo productionScheduleRetVo, List<ApsBlankOrderVo> apsBlankOrders, SysUserVo currentUser,ApsTypeVo apsType) {
+    public void apsAfter(ProductionScheduleRetVo productionScheduleRetVo, List<ApsBlankOrderVo> apsBlankOrders, SysUserVo currentUser, ApsTypeVo apsType) {
         // 先删除所有作业的明细
         List<String> blankids = CollUtil.distinct(productionScheduleRetVo.getProcesses().stream().map(v -> v.getProduceOrder().get(0).getId()).collect(Collectors.toList()));
 //        List<String> blankids = apsBlankOrders.stream().map(v -> v.getId()).collect(Collectors.toList());
@@ -982,7 +983,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
      */
     @Transactional(rollbackFor = Exception.class)
     @Override
-    public void ddApsAfter(ProductionScheduleRetVo productionScheduleRetVo, List<ApsBlankOrderVo> apsBlankOrders, SysUserVo currentUser,ApsTypeVo apsType) {
+    public void ddApsAfter(ProductionScheduleRetVo productionScheduleRetVo, List<ApsBlankOrderVo> apsBlankOrders, SysUserVo currentUser, ApsTypeVo apsType) {
         // 先删除所有作业的明细
         List<String> blankids = CollUtil.distinct(productionScheduleRetVo.getProcesses().stream().map(v -> v.getProduceOrder().get(0).getId()).collect(Collectors.toList()));
         // 查询坯料计划所有已存在的作业明细
@@ -3427,7 +3428,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
     public void insertSchedule(Map<String, Object> params) {
         List<ApsBlankOrderVo> apsBlankOrders = apsBlankOrderDao.getByOrderBlanckId(params.get("PRODUCTIONORDERID").toString(), params.get("BLANKORDERID").toString());
         if (apsBlankOrders != null && apsBlankOrders.size() > 0) {
-            apsService.apsSchedule(apsBlankOrders, new ApsTypeVo(), null,null);
+            apsService.apsSchedule(apsBlankOrders, new ApsTypeVo(), null, null);
         }
     }
 
@@ -4152,89 +4153,98 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
 
             //将实际完工时间大于明天的作业挪到实际完工时间
             this.baseMapper.updateFinishDateAboutProcessEqu(needScheduleDate);
-            //查询在重排时间前一天之后的所有作业明细信息,不包括：铸轧、成退、中退、小卷成退
-            List<ApsProcessOperationProcessEquChongpaiVo> list = this.baseMapper.selectNeedRescheduleEqu(needScheduleDate, CXCommonUtils.getCurrentUserFactoryId(null));
-            //查询重排时间的所有作业明细
-            List<ApsProcessOperationProcessEquChongpaiVo> needScheduleList = list.stream().filter(item ->
-                    item.getPlanstartdate().compareTo(chongpaiStartDate) >= 0
-                            && item.getPlanstartdate().compareTo(chongpaiEndDate) <= 0
-            ).collect(Collectors.toList());
-            //查询重排时间前一天的所有作业明细
-            List<ApsProcessOperationProcessEquChongpaiVo> beforeScheduleList = list.stream().filter(item -> item.getPlanstartdate().compareTo(chongpaiStartDate) < 0).collect(Collectors.toList());
-            //重排时间前一天的所有作业明细ID
-            List<String> beforeScheduleIdList = beforeScheduleList.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
-            //查询重排时间后的所有作业明细
-            List<ApsProcessOperationProcessEquChongpaiVo> afterScheduleList = list.stream().filter(item -> item.getPlanstartdate().compareTo(chongpaiEndDate) > 0).collect(Collectors.toList());
-            //重排时间后的所有作业明细ID
-            List<String> afterScheduleIdList = beforeScheduleList.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
-
+//            //查询在重排时间前一天之后的所有作业明细信息,不包括：铸轧、成退、中退、小卷成退
+//            List<ApsProcessOperationProcessEquChongpaiVo> list = this.baseMapper.selectNeedRescheduleEqu(needScheduleDate, CXCommonUtils.getCurrentUserFactoryId(null));
             //排程设置
             ApsScheduleConfigDo apsScheduleConfigDo = apsScheduleConfigService.getById("1");
-            //分析重排时间之后的作业明细，将（可以开工时间）为重排时间的加入
-            for (ApsProcessOperationProcessEquChongpaiVo apsProcessOperationProcessEquDo : afterScheduleList) {
-                //如果有前道明细
-                if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getPreviousprocessesids())) {
-                    //查询前道明细
-                    ApsProcessOperationProcessEquChongpaiVo previousEqu = needScheduleList.stream().filter(item -> item.getId().equals(apsProcessOperationProcessEquDo.getPreviousprocessesids())).findFirst().orElse(null);
-                    //前道明细不为null
-                    if (ObjectUtil.isNotEmpty(previousEqu)) {
-                        //当前明细对应作业的最小流转时间
-                        long minReturnTime = apsProcessOperationProcessEquDo.getMinflowwaitmin().longValue();
-                        //确定使用哪个最小流转时间
-                        /*
-                         * 如果作业明细加工设备相同，则该作业最小流转时间=取其大（排程设置的机台流转时间，作业的最小流转等待时间）
-                         * 如果作业明细加工车间不同，则该作业最小流转时间=取其大（排程设置的车间流转时间，作业的最小流转等待时间）
-                         * 如果作业明细加工工厂不同，则该作业最小流转时间=取其大（排程设置的工厂流转时间，作业的最小流转等待时间）
-                         */
-                        //作业明细加工设备不相同
-                        if (!previousEqu.getProcessdeviceid().equals(apsProcessOperationProcessEquDo.getProcessdeviceid())) {
-                            if (apsScheduleConfigDo.getWorkshopin().longValue() > minReturnTime) {
-                                minReturnTime = apsScheduleConfigDo.getWorkshopin().longValue();
-                            }
-                        }
-                        //作业明细加工车间不同
-                        if (!previousEqu.getProcessworkshopid().equals(apsProcessOperationProcessEquDo.getProcessworkshopid())) {
-                            if (apsScheduleConfigDo.getWorkshopcross().longValue() > minReturnTime) {
-                                minReturnTime = apsScheduleConfigDo.getWorkshopcross().longValue();
-                            }
-                        }
-                        if (!previousEqu.getDeviceFactory().equals(apsProcessOperationProcessEquDo.getDeviceFactory())) {
-                            if (apsScheduleConfigDo.getFactorycross().longValue() > minReturnTime) {
-                                minReturnTime = apsScheduleConfigDo.getFactorycross().longValue();
-                            }
-                        }
-                        //可以开工时间 = 前道明细计划完工时间+最小流转时间
-                        DateTime canStartDate = DateUtil.offsetMinute(previousEqu.getPlanenddate(), Integer.parseInt(String.valueOf(minReturnTime)));
-                        //可以开工时间 <= 重排结束时间，放入重排
-                        if (canStartDate.isBeforeOrEquals(chongpaiEndDate)) {
-                            needScheduleList.add(apsProcessOperationProcessEquDo);
-                        }
-                    }
-                }
-            }
+            //查询需要重排的所有明细信息
+            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<ApsProcessOperationProcessEquChongpaiVo> needUnLockList = new LinkedList<>(needScheduleList);
+            List<ApsProcessOperationProcessEquDo> needUnLockList = new LinkedList<>(needScheduleList);
+            //所有不需要解锁的明细集合
+            List<ApsProcessOperationProcessEquDo> notNeedUnLockList = new LinkedList<>();
 
-            for (ApsProcessOperationProcessEquChongpaiVo apsProcessOperationProcessEquDo : needScheduleList) {
+            for (ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo : needScheduleList) {
                 //前道作业明细ID不为空
                 if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getPreviousprocessesids())) {
-                    //如果存在
-                    if (beforeScheduleIdList.contains(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;
-                            ApsProcessOperationProcessEquChongpaiVo previousEqu = beforeScheduleList.stream().filter(item -> finalPreviousprocessesid.equals(item.getId())).findFirst().orElse(null);
+                            ApsProcessOperationProcessEquDo previousEqu = allProcessEquList.stream().filter(item -> finalPreviousprocessesid.equals(item.getId())).findFirst().orElse(null);
                             if (ObjectUtil.isNotEmpty(previousEqu)) {
-                                needUnLockList.add(previousEqu);
-                                if (ObjectUtil.isNotEmpty(previousEqu.getPreviousprocessesids())) {
-                                    previousprocessesid = previousEqu.getPreviousprocessesids();
+                                //上一个明细的工序作业
+                                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;
+                                            }
+                                        }
+                                    }
+                                    //存在相同
+                                    if (have) {
+                                        needUnLockList.add(previousEqu);
+                                        if (ObjectUtil.isNotEmpty(previousEqu.getPreviousprocessesids())) {
+                                            previousprocessesid = previousEqu.getPreviousprocessesids();
+                                            nowProcess = previousProcess;
+                                        } else {
+                                            break;
+                                        }
+                                    } else {
+                                        notNeedUnLockList.add(previousEqu);
+                                        break;
+                                    }
                                 } else {
+                                    notNeedUnLockList.add(previousEqu);
                                     break;
                                 }
                             } else {
@@ -4245,31 +4255,31 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                 }
                 //后道明细不为空
                 if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getNextprocessesids())) {
-                    getNextProcess(apsProcessOperationProcessEquDo.getNextprocessesids(),afterScheduleList,afterScheduleIdList,needUnLockList);
+                    getNextProcess(apsProcessOperationProcessEquDo.getNextprocessesids(), needScheduleList, needScheduleIdList, allProcessEquList, allProcessEquIdList, needUnLockList);
                 }
             }
             //需要解锁的明细ID
-            List<String> needUnLockProcessEquIdList = needUnLockList.stream().map(ApsProcessOperationProcessEquChongpaiVo::getId).distinct().collect(Collectors.toList());
+            List<String> needUnLockProcessEquIdList = needUnLockList.stream().map(ApsProcessOperationProcessEquDo::getId).distinct().collect(Collectors.toList());
             //需要解锁的作业ID
-            List<String> needUnLockProcessIdList = needUnLockList.stream().map(ApsProcessOperationProcessEquChongpaiVo::getProcessid).distinct().collect(Collectors.toList());
-            log.info("解锁的作业明细：{}",needUnLockList);
-            log.info("解锁的作业明细ID：{}",needUnLockProcessEquIdList);
-            log.info("解锁的作业ID：{}",needUnLockProcessIdList);
+            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));
+                            .set(ApsProcessOperationProcessEquDo::getLockmark, "n")
+                            .in(ApsProcessOperationProcessEquDo::getId, needUnLockProcessEquIdList));
             apsProcessOperationService.update(
                     new LambdaUpdateWrapper<ApsProcessOperationDo>()
                             .set(ApsProcessOperationDo::getLockmark, "n")
-                            .in(ApsProcessOperationDo::getId,needUnLockProcessIdList)
+                            .in(ApsProcessOperationDo::getId, needUnLockProcessIdList)
             );
 
-//            //解锁明天有开工作业明细的坯料计划的所有作业明细
-//            this.baseMapper.removeLockNextDayProcessEqu(needScheduleDate);
-//            //解锁后天开工的所有作业明细
-//            this.baseMapper.removeLockNextTwoDayProcessEqu(needScheduleDate);
             String scheduletype = apsScheduleConfigDo.getScheduletype();
             ApsTypeVo apsTypeVo = BeanUtil.toBean(scheduletype, ApsTypeVo.class);
 //            apsTypeVo.setMixIf("mix");
@@ -4277,28 +4287,65 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
 //            apsTypeVo.setConstraintMode("lz");
             apsTypeVo.setScheduleType("dd");
             //重新排程
-            apsService.apsSchedule(new ArrayList<>(), apsTypeVo, null,needUnLockProcessIdList);
+            //组装需要传入排程的工序作业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);
+
+
         }
     }
 
     //迭代处理寻找下道明细
     private void getNextProcess(String nextprocessesids,
-                                List<ApsProcessOperationProcessEquChongpaiVo> afterScheduleList,
-                                List<String> afterScheduleIdList,
-                                List<ApsProcessOperationProcessEquChongpaiVo> needUnLockList) {
+                                List<ApsProcessOperationProcessEquDo> needScheduleList,
+                                List<String> needScheduleIdList,
+                                List<ApsProcessOperationProcessEquDo> allProcessEquList,
+                                List<String> allProcessEquIdList,
+                                List<ApsProcessOperationProcessEquDo> needUnLockList) {
         if (ObjectUtil.isEmpty(nextprocessesids)) {
             return;
         }
         for (String nextProcessEquId : nextprocessesids.split(",")) {
-            //如果存在
-            if (afterScheduleIdList.contains(nextProcessEquId)) {
+            //如果重排不存在 但是基准存在，加入待解锁
+            if (!needScheduleIdList.contains(nextProcessEquId) && allProcessEquIdList.contains(nextProcessEquId)) {
                 //下一个明细
-                ApsProcessOperationProcessEquChongpaiVo nextEqu = afterScheduleList.stream().filter(item -> item.getId().equals(nextProcessEquId)).findFirst().orElse(null);
+                ApsProcessOperationProcessEquDo nextEqu = allProcessEquList.stream().filter(item -> item.getId().equals(nextProcessEquId)).findFirst().orElse(null);
                 if (ObjectUtil.isNotEmpty(nextEqu)) {
                     needUnLockList.add(nextEqu);
                     if (ObjectUtil.isNotEmpty(nextEqu.getPreviousprocessesids())) {
                         String nextNewProcessesids = nextEqu.getPreviousprocessesids();
-                        getNextProcess(nextNewProcessesids,afterScheduleList,afterScheduleIdList,needUnLockList);
+                        getNextProcess(nextNewProcessesids, needScheduleList, needScheduleIdList, allProcessEquList, allProcessEquIdList, needUnLockList);
                     }
                 }
             }

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

@@ -423,4 +423,42 @@
           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'
+        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
+        WHERE
+            apo.DELETED = 0
+          AND apo.PROCESS IN ( '成退', '中退', '小卷成退' )
+          AND apope.PLANSTARTDATE >= #{needScheduleDate}
+          and apope.WORKSTATUS = '待开工'
+          AND apope.TENANTID = #{tenantId}
+    </select>
+    <select id="selectNeedRescheduleEqu3"
+            resultType="com.rongwei.bsentity.domain.ApsProcessOperationProcessEquDo">
+        SELECT apope.*
+        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'
+        WHERE
+        apope.deleted = '0' AND apo.DELETED = '0'
+        and apope.TENANTID = #{tenantId}
+        and apo.PROCESS not in ('铸轧','中退','成退','小卷成退')
+        and apope.WORKSTATUS = '待开工'
+        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>
 </mapper>