aps-调度重排

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

@@ -160,5 +160,5 @@ public interface ApsBlankOrderDao extends BaseMapper<ApsBlankOrderDo> {
 
     void removeLockNextTwoDayProcessEqu(@Param("needScheduleDate") String needScheduleDate);
 
-    List<ApsProcessOperationProcessEquDo> selectNeedRescheduleEqu(@Param("needScheduleDate") String needScheduleDate);
+    List<ApsProcessOperationProcessEquChongpaiVo> selectNeedRescheduleEqu(@Param("needScheduleDate") String needScheduleDate,@Param("tenantId") String tenantId);
 }

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

@@ -3986,37 +3986,127 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         }
 
         if (ObjectUtil.isNotEmpty(needScheduleDate)) {
+            //计算重排开始时间和结束时间
+            DateTime chongpaiStartDate = DateUtil.parseDate(needScheduleDate);
+            DateTime chongpaiEndDate = DateUtil.endOfDay(chongpaiStartDate);
+
             //将实际完工时间大于明天的作业挪到实际完工时间
             this.baseMapper.updateFinishDateAboutProcessEqu(needScheduleDate);
             //查询在重排时间前一天之后的所有作业明细信息,不包括：铸轧、成退、中退、小卷成退
-            List<ApsProcessOperationProcessEquDo> list = this.baseMapper.selectNeedRescheduleEqu(needScheduleDate);
-            //查询重排时间之后的所有作业明细
-            String finalNeedScheduleDate = needScheduleDate;
-            List<ApsProcessOperationProcessEquDo> needScheduleList = list.stream().filter(item ->
-                    item.getPlanstartdate().compareTo(DateUtil.parseDate(finalNeedScheduleDate)) >= 0
-                    && item.getPlanstartdate().compareTo(DateUtil.offsetDay(DateUtil.parseDate(finalNeedScheduleDate),1)) <= 0
+            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<ApsProcessOperationProcessEquDo> beforeScheduleList = list.stream().filter(item -> item.getPlanstartdate().compareTo(DateUtil.parseDate(finalNeedScheduleDate)) < 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());
-            for (ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo : needScheduleList) {
-                //前道作业明细ID不为空
-                if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getPreviousprocessesids())){
-                    //如果存在
-                    if (afterScheduleIdList.contains(apsProcessOperationProcessEquDo.getPreviousprocessesids())){
 
+            //排程设置
+            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<ApsProcessOperationProcessEquChongpaiVo> needUnLockList = new LinkedList<>(needScheduleList);
 
-            //解锁明天有开工作业明细的坯料计划的所有作业明细
-            this.baseMapper.removeLockNextDayProcessEqu(needScheduleDate);
-            //解锁后天开工的所有作业明细
-            this.baseMapper.removeLockNextTwoDayProcessEqu(needScheduleDate);
-            //获取排程类型
-            ApsScheduleConfigDo apsScheduleConfigDo = apsScheduleConfigService.getById("1");
+            for (ApsProcessOperationProcessEquChongpaiVo apsProcessOperationProcessEquDo : needScheduleList) {
+                //前道作业明细ID不为空
+                if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getPreviousprocessesids())) {
+                    //如果存在
+                    if (beforeScheduleIdList.contains(apsProcessOperationProcessEquDo.getPreviousprocessesids())) {
+                        String previousprocessesid = apsProcessOperationProcessEquDo.getPreviousprocessesids();
+                        //循环寻找前道明细
+                        while (true) {
+                            if (StringUtils.isBlank(previousprocessesid)) {
+                                break;
+                            }
+                            //上一个明细
+                            String finalPreviousprocessesid = previousprocessesid;
+                            ApsProcessOperationProcessEquChongpaiVo previousEqu = beforeScheduleList.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();
+                                } else {
+                                    break;
+                                }
+                            } else {
+                                break;
+                            }
+                        }
+                    }
+                }
+                //后道明细不为空
+                if (ObjectUtil.isNotEmpty(apsProcessOperationProcessEquDo.getNextprocessesids())) {
+                    getNextProcess(apsProcessOperationProcessEquDo.getNextprocessesids(),afterScheduleList,afterScheduleIdList,needUnLockList);
+                }
+            }
+            //需要解锁的明细ID
+            List<String> needUnLockProcessEquIdList = needUnLockList.stream().map(ApsProcessOperationProcessEquChongpaiVo::getId).distinct().collect(Collectors.toList());
+            //需要解锁的作业ID
+            List<String> needUnLockProcessIdList = needUnLockList.stream().map(ApsProcessOperationProcessEquChongpaiVo::getProcessid).distinct().collect(Collectors.toList());
+            //解锁
+            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)
+            );
+
+//            //解锁明天有开工作业明细的坯料计划的所有作业明细
+//            this.baseMapper.removeLockNextDayProcessEqu(needScheduleDate);
+//            //解锁后天开工的所有作业明细
+//            this.baseMapper.removeLockNextTwoDayProcessEqu(needScheduleDate);
             String scheduletype = apsScheduleConfigDo.getScheduletype();
             ApsTypeVo apsTypeVo = BeanUtil.toBean(scheduletype, ApsTypeVo.class);
             apsTypeVo.setMixIf("mix");
@@ -4026,4 +4116,28 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             apsService.apsSchedule(new ArrayList<>(), apsTypeVo, null);
         }
     }
+
+    //迭代处理寻找下道明细
+    private void getNextProcess(String nextprocessesids,
+                                List<ApsProcessOperationProcessEquChongpaiVo> afterScheduleList,
+                                List<String> afterScheduleIdList,
+                                List<ApsProcessOperationProcessEquChongpaiVo> needUnLockList) {
+        if (ObjectUtil.isEmpty(nextprocessesids)) {
+            return;
+        }
+        for (String nextProcessEquId : nextprocessesids.split(",")) {
+            //如果存在
+            if (afterScheduleIdList.contains(nextProcessEquId)) {
+                //下一个明细
+                ApsProcessOperationProcessEquChongpaiVo nextEqu = afterScheduleList.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);
+                    }
+                }
+            }
+        }
+    }
 }

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

@@ -407,16 +407,20 @@
           AND apo.ID = #{productionorderid}
     </select>
     <select id="selectNeedRescheduleEqu"
-            resultType="com.rongwei.bsentity.domain.ApsProcessOperationProcessEquDo">
+            resultType="com.rongwei.bsentity.vo.ApsProcessOperationProcessEquChongpaiVo">
         SELECT
-            apope.*
+            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 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 NOT IN ( '铸轧', '成退', '中退', '小卷成退' )
-          AND apope.PLANSTARTDATE >= DATE_SUB(#{needScheduleDate}, INTERVAL 1 DAY)
+          AND apope.PLANSTARTDATE >= DATE_SUB('2025-02-12', INTERVAL 1 DAY)
+          and apope.WORKSTATUS = '待开工'
+          AND apope.TENANTID = #{tenantId}
     </select>
 </mapper>

cx-aps/cx-aps-entity/src/main/java/com/rongwei/bsentity/vo/ApsProcessOperationProcessEquChongpaiVo.java

@@ -0,0 +1,23 @@
+package com.rongwei.bsentity.vo;
+
+import com.rongwei.bsentity.domain.ApsProcessOperationProcessEquDo;
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+ * @author ：sc
+ * @since ：2025/2/11
+ */
+@Data
+public class ApsProcessOperationProcessEquChongpaiVo extends ApsProcessOperationProcessEquDo {
+    /**
+     * 最小流转等待时间
+     */
+    private BigDecimal minflowwaitmin;
+
+    /**
+     * 设备所属工厂ID
+     */
+    private String deviceFactory;
+}