Merge branch 'mode-min-unit' into mode-min-unit-换线可选设备

cx-aps/cx-aps-common/src/main/java/com/rongwei/bscommon/sys/fegin/RwApsServer.java

@@ -16,4 +16,7 @@ public interface RwApsServer {
     @PostMapping("/apsSchedule/productionThSchedule")
     ProductionScheduleRetVo productionThSchedule(@RequestBody ProductionScheduleVo productionScheduleVo);
 
+    @PostMapping("/apsSchedule/productionLzDdSchedule")
+    ProductionScheduleRetVo productionLzDdSchedule(@RequestBody ProductionScheduleVo productionScheduleVo);
+
 }

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

@@ -4346,6 +4346,9 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             List<ApsProcessOperationDo> unLockingProcessList = apsProcessOperationService.list(new LambdaQueryWrapper<ApsProcessOperationDo>()
                     .eq(ApsProcessOperationDo::getLockmark, "n"));
             List<String> unLockingProcessIdList = unLockingProcessList.stream().map(ApsProcessOperationDo::getId).collect(Collectors.toList());
+            List<ApsProcessOperationProcessEquDo> unLockingEquList2 = apsProcessOperationProcessEquService.list(new LambdaQueryWrapper<ApsProcessOperationProcessEquDo>()
+                    .eq(ApsProcessOperationProcessEquDo::getLockmark, "n"));
+            List<String> unLockingEquIdList2 = unLockingEquList2.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
 
             //将实际完工时间大于明天的作业挪到实际完工时间
             this.baseMapper.updateFinishDateAboutProcessEqu(needScheduleDate, tenantId, chongpaiStartDate, chongpaiEndDate);
@@ -4387,6 +4390,20 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             } catch (Exception e) {
                 log.error("冷轧重排失败");
                 log.error(e);
+            } finally {
+                //锁定所有 未锁定的 作业和作业明细
+                apsProcessOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
+                        .set(ApsProcessOperationProcessEquDo::getLockmarkdetail, "y")
+                        .eq(ApsProcessOperationProcessEquDo::getLockmarkdetail, "n")
+                        .eq(ApsProcessOperationProcessEquDo::getTenantid, tenantId));
+                apsProcessOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
+                        .set(ApsProcessOperationProcessEquDo::getLockmark, "y")
+                        .eq(ApsProcessOperationProcessEquDo::getLockmark, "n")
+                        .eq(ApsProcessOperationProcessEquDo::getTenantid, tenantId));
+                apsProcessOperationService.update(new LambdaUpdateWrapper<ApsProcessOperationDo>()
+                        .set(ApsProcessOperationDo::getLockmark, "y")
+                        .eq(ApsProcessOperationDo::getLockmark, "n")
+                        .eq(ApsProcessOperationDo::getTenantid, tenantId));
             }
             try {
                 log.info("开始退火重排");
@@ -4396,21 +4413,21 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             } catch (Exception e) {
                 log.error("退火重排失败");
                 log.error(e);
+            } finally {
+                //锁定所有 未锁定的 作业和作业明细
+                apsProcessOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
+                        .set(ApsProcessOperationProcessEquDo::getLockmarkdetail, "y")
+                        .eq(ApsProcessOperationProcessEquDo::getLockmarkdetail, "n")
+                        .eq(ApsProcessOperationProcessEquDo::getTenantid, tenantId));
+                apsProcessOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
+                        .set(ApsProcessOperationProcessEquDo::getLockmark, "y")
+                        .eq(ApsProcessOperationProcessEquDo::getLockmark, "n")
+                        .eq(ApsProcessOperationProcessEquDo::getTenantid, tenantId));
+                apsProcessOperationService.update(new LambdaUpdateWrapper<ApsProcessOperationDo>()
+                        .set(ApsProcessOperationDo::getLockmark, "y")
+                        .eq(ApsProcessOperationDo::getLockmark, "n")
+                        .eq(ApsProcessOperationDo::getTenantid, tenantId));
             }
-            //锁定所有 未锁定的 作业和作业明细
-            apsProcessOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
-                    .set(ApsProcessOperationProcessEquDo::getLockmarkdetail, "y")
-                    .eq(ApsProcessOperationProcessEquDo::getLockmarkdetail, "n")
-                    .eq(ApsProcessOperationProcessEquDo::getTenantid, tenantId));
-            apsProcessOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
-                    .set(ApsProcessOperationProcessEquDo::getLockmark, "y")
-                    .eq(ApsProcessOperationProcessEquDo::getLockmark, "n")
-                    .eq(ApsProcessOperationProcessEquDo::getTenantid, tenantId));
-            apsProcessOperationService.update(new LambdaUpdateWrapper<ApsProcessOperationDo>()
-                    .set(ApsProcessOperationDo::getLockmark, "y")
-                    .eq(ApsProcessOperationDo::getLockmark, "n")
-                    .eq(ApsProcessOperationDo::getTenantid, tenantId));
-
             //调度排程结束
             //将之前锁定的作业和明细重新解锁
             if (!unLockingEquIdList.isEmpty()) {
@@ -4418,6 +4435,11 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                         .set(ApsProcessOperationProcessEquDo::getLockmarkdetail, "n")
                         .in(ApsProcessOperationProcessEquDo::getId, unLockingEquIdList));
             }
+            if (!unLockingEquIdList2.isEmpty()) {
+                apsProcessOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
+                        .set(ApsProcessOperationProcessEquDo::getLockmark, "n")
+                        .in(ApsProcessOperationProcessEquDo::getId, unLockingEquIdList2));
+            }
             if (!unLockingProcessIdList.isEmpty()) {
                 apsProcessOperationService.update(new LambdaUpdateWrapper<ApsProcessOperationDo>()
                         .set(ApsProcessOperationDo::getLockmark, "n")

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

@@ -1,5 +1,6 @@
 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;
@@ -723,7 +724,7 @@ public class ApsServiceImpl implements ApsService {
                 productionScheduleVo.setEquipmentList(equipmentList1);
                 apsProductionSchedules.add(productionScheduleVo);
             } catch (Exception e) {
-                logger.info("坯料计划：+bo.getBlanknumber() + ;排程数据初始化异常", e);
+                logger.info("坯料计划："+bo.getBlanknumber() + ";排程数据初始化异常", e);
                 String msg = "坯料计划：" + bo.getBlanknumber() + ";排程数据初始化异常";
                 throw new CustomException(msg + " " + DateUtil.formatDateTime(new Date()));
             }
@@ -784,125 +785,183 @@ public class ApsServiceImpl implements ApsService {
             System.out.println("排程数据：" + JSONUtil.toJsonStr(apsProductionSchedule, jsonConfig));
             logger.info("排程数据：" + JSONUtil.toJsonStr(apsProductionSchedule, jsonConfig));
             // APS平台排程接口调用
-            ProductionScheduleRetVo productionScheduleRetVo = rwApsServer.productionSchedule(apsProductionSchedule);
-            logger.info("排程结果：" + JSONUtil.toJsonStr(productionScheduleRetVo, jsonConfig));
-            //排程结束时间
-            DateTime endTime = DateUtil.date();
-            //日志写入文件
-            logWriter(JSONUtil.toJsonStr(apsProductionSchedule, jsonConfig), JSONUtil.toJsonStr(productionScheduleRetVo, jsonConfig), apsType.getScheduleType());
-            //排程日志存入数据库
-            logSave(currentUser, startTime, endTime, apsType, apsPlanStartDate, apsPlanEndDate, productionScheduleRetVo);
-            if (!"200".equals(productionScheduleRetVo.getCode())) {
-                logger.info("排程异常，坯料计划ID：" + blankOrderIds);
-                // 排程异常后恢复历史排程结果为锁定状态
-                processOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>().set(ApsProcessOperationProcessEquDo::getLockmark, "y")
-                        .in(ApsProcessOperationProcessEquDo::getBlankid, blankOrderIds));
-                // 没有可排程工序的订单跳过
-                if ("没有可排程的工序".equals(productionScheduleRetVo.getMsg())) {
-                    logger.info("排程异常：没有可排程的工序，坯料计划编号：" + blankOrderIds);
-                } else {
-                    throw new CustomException(productionScheduleRetVo.getMsg() + " " + DateUtil.formatDateTime(new Date()));
-                }
+            ProductionScheduleRetVo productionScheduleRetVo;
+            if (apsType.getConstraintMode() != null && apsType.getConstraintMode().equals("lz")) {
+                productionScheduleRetVo = rwApsServer.productionLzDdSchedule(apsProductionSchedule);
             } else {
-                // 获取坯料计划
+                productionScheduleRetVo = rwApsServer.productionSchedule(apsProductionSchedule);
+            }
+            saveRes(productionScheduleRetVo,
+                    jsonConfig,
+                    apsProductionSchedule,
+                    apsType,
+                    apsPlanStartDate,
+                    apsPlanEndDate,
+                    blankOrderIds,
+                    apsBlankOrders,
+                    currentUser,
+                    startTime);
+        }
+    }
+
+    private void saveRes(ProductionScheduleRetVo productionScheduleRetVo,
+                         JSONConfig jsonConfig,
+                         ProductionScheduleVo apsProductionSchedule,
+                         ApsTypeVo apsType,
+                         Date apsPlanStartDate,
+                         Date apsPlanEndDate,
+                         List<String> blankOrderIds,
+                         List<ApsBlankOrderVo> apsBlankOrders,
+                         SysUserVo currentUser,
+                         DateTime startTime) {
+
+        logger.info("排程结果：" + JSONUtil.toJsonStr(productionScheduleRetVo, jsonConfig));
+        //排程结束时间
+        DateTime endTime = DateUtil.date();
+        //日志写入文件
+        logWriter(JSONUtil.toJsonStr(apsProductionSchedule, jsonConfig), JSONUtil.toJsonStr(productionScheduleRetVo, jsonConfig), apsType.getScheduleType());
+        //排程日志存入数据库
+        logSave(currentUser, startTime, endTime, apsType, apsPlanStartDate, apsPlanEndDate, productionScheduleRetVo);
+        if (!"200".equals(productionScheduleRetVo.getCode())) {
+            logger.info("排程异常，坯料计划ID：" + blankOrderIds);
+            // 排程异常后恢复历史排程结果为锁定状态
+            processOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>().set(ApsProcessOperationProcessEquDo::getLockmark, "y")
+                    .in(ApsProcessOperationProcessEquDo::getBlankid, blankOrderIds));
+            // 没有可排程工序的订单跳过
+            if ("没有可排程的工序".equals(productionScheduleRetVo.getMsg())) {
+                logger.info("排程异常：没有可排程的工序，坯料计划编号：" + blankOrderIds);
+            } else {
+                throw new CustomException(productionScheduleRetVo.getMsg() + " " + DateUtil.formatDateTime(new Date()));
+            }
+        } else {
+            // 获取坯料计划
                 /*List<ApsBlankOrderVo> apsBlankOrderss = new ArrayList<>();
                 apsBlankOrderss.add(bo);*/
-                //排程结束后，查询修改时间在排程开始-？的明细，不更新修改信息，并最后重新判断其冲突
-                List<ApsProcessOperationProcessEquCheckVo> list = apsProcessOperationProcessEquDao.getNeedCheckEquList(startTime, CXCommonUtils.getCurrentUserFactoryId(currentUser));
-
-                if ("dd".equals(apsType.getScheduleType())) {
-                    if (!list.isEmpty()) {
-                        List<String> updateIdList = list.stream().map(ApsProcessOperationProcessEquCheckVo::getId).distinct().collect(Collectors.toList());
-                        List<ProductionProcesses> productionProcesses = productionScheduleRetVo.getProcesses().stream().filter(item -> !updateIdList.contains(item.getId())).collect(Collectors.toList());
-                        productionScheduleRetVo.setProcesses(productionProcesses);
+            //排程结束后，查询修改时间在排程开始-？的明细，不更新修改信息，并最后重新判断其冲突
+            List<ApsProcessOperationProcessEquCheckVo> list = apsProcessOperationProcessEquDao.getNeedCheckEquList(startTime, CXCommonUtils.getCurrentUserFactoryId(currentUser));
+
+            if ("dd".equals(apsType.getScheduleType())) {
+                if (!list.isEmpty()) {
+                    List<String> updateIdList = list.stream().map(ApsProcessOperationProcessEquCheckVo::getId).distinct().collect(Collectors.toList());
+                    List<ProductionProcesses> productionProcesses = productionScheduleRetVo.getProcesses().stream().filter(item -> !updateIdList.contains(item.getId())).collect(Collectors.toList());
+                    productionScheduleRetVo.setProcesses(productionProcesses);
+                }
+                //循环5次，如果执行成功，继续向下执行，如果出现sql超时，等待2分钟后重试，重试5次
+                boolean isSuccess = false;
+                for (int i = 0; i < 5; i++) {
+                    if (isSuccess) {
+                        break;
                     }
-                    //循环5次，如果执行成功，继续向下执行，如果出现sql超时，等待2分钟后重试，重试5次
-                    boolean isSuccess = false;
-                    for (int i = 0; i < 5; i++) {
-                        if (isSuccess) {
-                            break;
-                        }
+                    try {
+                        apsBlankOrderService.ddApsAfter(productionScheduleRetVo, apsBlankOrders, currentUser, apsType);
+                        isSuccess = true;
+                    } catch (SQLNonTransientConnectionException | CJCommunicationsException |
+                             SocketTimeoutException | CommunicationsException e) {
                         try {
-                            apsBlankOrderService.ddApsAfter(productionScheduleRetVo, apsBlankOrders, currentUser, apsType);
-                            isSuccess = true;
-                        } catch (SQLNonTransientConnectionException | CJCommunicationsException |
-                                 SocketTimeoutException | CommunicationsException | MySQLTransactionRollbackException e) {
-                            try {
-                                Thread.sleep(120000);
-                                logger.info("排程结束写入数据异常，重试");
-                            } catch (InterruptedException ignored) {
-                            }
-                        } catch (Exception e) {
-                            throw new CustomException(e.getMessage());
+                            Thread.sleep(120000);
+                        } catch (InterruptedException ignored) {
                         }
+                    } catch (Exception e) {
+                        throw new CustomException(e.getMessage());
                     }
+                }
 
-                } else {
-                    //循环5次，如果执行成功，继续向下执行，如果出现sql超时，等待2分钟后重试，重试5次
-                    boolean isSuccess = false;
-                    for (int i = 0; i < 5; i++) {
-                        if (isSuccess) {
-                            break;
-                        }
+            } else {
+                //循环5次，如果执行成功，继续向下执行，如果出现sql超时，等待2分钟后重试，重试5次
+                boolean isSuccess = false;
+                for (int i = 0; i < 5; i++) {
+                    if (isSuccess) {
+                        break;
+                    }
+                    try {
+                        apsBlankOrderService.apsAfter(productionScheduleRetVo, apsBlankOrders, currentUser, apsType);
+                        isSuccess = true;
+                    } catch (SQLNonTransientConnectionException | CJCommunicationsException |
+                             SocketTimeoutException | CommunicationsException e) {
                         try {
-                            apsBlankOrderService.apsAfter(productionScheduleRetVo, apsBlankOrders, currentUser, apsType);
-                            isSuccess = true;
-                        } catch (SQLNonTransientConnectionException | CJCommunicationsException |
-                                 SocketTimeoutException | CommunicationsException | MySQLTransactionRollbackException e) {
-                            try {
-                                Thread.sleep(120000);
-                                logger.info("排程结束写入数据异常，重试");
-                            } catch (InterruptedException ignored) {
-                            }
-                        } catch (Exception e) {
-                            throw new CustomException(e.getMessage());
+                            Thread.sleep(120000);
+                        } catch (InterruptedException ignored) {
                         }
+                    } catch (Exception e) {
+                        throw new CustomException(e.getMessage());
                     }
                 }
-                //还原排程过程中，开工/报工的作业的计划时间
-                apsProcessOperationProcessEquDao.repairePlanStartDate();
-                apsProcessOperationProcessEquDao.repairePlanStartDate2();
-
-                if (StrUtil.isNotBlank(productionScheduleRetVo.getMsg())) {
-                    // 排程异常后恢复历史排程结果为锁定状态
-                    List<String> blankids = CollUtil.distinct(productionScheduleRetVo.getProcesses().stream().map(v -> v.getProduceOrder().get(0).getId()).collect(Collectors.toList()));
-                    List<String> allblankids = apsBlankOrders.stream().map(v -> v.getId()).collect(Collectors.toList());
-                    List<String> exblankids = null;
-                    if (blankids != null && blankids.size() > 0) {
-                        exblankids = allblankids.stream().filter(v -> !blankids.contains(v)).collect(Collectors.toList());
-                    } else {
-                        exblankids = allblankids;
-                    }
-                    if (exblankids != null && exblankids.size() > 0) {
-                        processOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>().set(ApsProcessOperationProcessEquDo::getLockmark, "y")
-                                .in(ApsProcessOperationProcessEquDo::getBlankid, exblankids));
-                    }
+            }
+            //还原排程过程中，开工/报工的作业的计划时间
+            apsProcessOperationProcessEquDao.repairePlanStartDate();
+            apsProcessOperationProcessEquDao.repairePlanStartDate2();
 
-                    throw new CustomException(productionScheduleRetVo.getMsg() + " " + DateUtil.formatDateTime(new Date()));
+            if (StrUtil.isNotBlank(productionScheduleRetVo.getMsg())) {
+                // 排程异常后恢复历史排程结果为锁定状态
+                List<String> blankids = CollUtil.distinct(productionScheduleRetVo.getProcesses().stream().map(v -> v.getProduceOrder().get(0).getId()).collect(Collectors.toList()));
+                List<String> allblankids = apsBlankOrders.stream().map(v -> v.getId()).collect(Collectors.toList());
+                List<String> exblankids = null;
+                if (blankids != null && blankids.size() > 0) {
+                    exblankids = allblankids.stream().filter(v -> !blankids.contains(v)).collect(Collectors.toList());
+                } else {
+                    exblankids = allblankids;
                 }
-                if (!list.isEmpty()) {
-                    List<ApsProcessOperationProcessEquCheckVo> waitStartList = list.stream().filter(item -> item.getWorkstatus().equals("待开工")).collect(Collectors.toList());
-                    for (ApsProcessOperationProcessEquCheckVo equDo : waitStartList) {
-                        try {
-                            apsProcessOperationProcessEquService.checkProcessingTimeConflict(equDo,
-                                    null, null, null, equDo.getProcessWay(), new LinkedList<>());
-                            ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo = apsProcessOperationProcessEquService.getById(equDo.getId());
-                            // 判断是否存在设备不可用
-                            apsProcessOperationProcessEquService.inspectionEquipmentIsAvailable(apsProcessOperationProcessEquDo,
-                                    apsProcessOperationProcessEquDo.getProcessdeviceid(),
-                                    apsProcessOperationProcessEquDo.getPlanstartdate(),
-                                    apsProcessOperationProcessEquDo.getPlanenddate(),
-                                    new LinkedList<>());
-                        } catch (Exception e) {
-                            logger.error("判断冲突失败：" + equDo.getId(), e);
-                        }
+                if (exblankids != null && exblankids.size() > 0) {
+                    processOperationProcessEquService.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>().set(ApsProcessOperationProcessEquDo::getLockmark, "y")
+                            .in(ApsProcessOperationProcessEquDo::getBlankid, exblankids));
+                }
+
+                throw new CustomException(productionScheduleRetVo.getMsg() + " " + DateUtil.formatDateTime(new Date()));
+            }
+            if (!list.isEmpty()) {
+                List<ApsProcessOperationProcessEquCheckVo> waitStartList = list.stream().filter(item -> item.getWorkstatus().equals("待开工")).collect(Collectors.toList());
+                for (ApsProcessOperationProcessEquCheckVo equDo : waitStartList) {
+                    try {
+                        apsProcessOperationProcessEquService.checkProcessingTimeConflict(equDo,
+                                null, null, null, equDo.getProcessWay(), new LinkedList<>());
+                        ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo = apsProcessOperationProcessEquService.getById(equDo.getId());
+                        // 判断是否存在设备不可用
+                        apsProcessOperationProcessEquService.inspectionEquipmentIsAvailable(apsProcessOperationProcessEquDo,
+                                apsProcessOperationProcessEquDo.getProcessdeviceid(),
+                                apsProcessOperationProcessEquDo.getPlanstartdate(),
+                                apsProcessOperationProcessEquDo.getPlanenddate(),
+                                new LinkedList<>());
+                    } catch (Exception e) {
+                        logger.error("判断冲突失败：" + equDo.getId(), e);
                     }
                 }
             }
-
         }
     }
 
+//    private List<ProductionScheduleVo> xmxSplit(ProductionScheduleVo apsProductionSchedule) {
+//        List<ProductionScheduleVo> res = new LinkedList<>();
+//        List<ProductionProcesses> processes = apsProductionSchedule.getProcesses();
+//        List<String> blankIdList = processes.stream().map(item -> item.getProduceOrder().get(0).getId()).distinct().collect(Collectors.toList());
+//        //查询涉及到的所有明细
+//        List<ApsProcessOperationProcessEquDo> allProcessEquList = apsProcessOperationProcessEquService.list(new LambdaQueryWrapper<ApsProcessOperationProcessEquDo>().in(ApsProcessOperationProcessEquDo::getBlankid, blankIdList));
+//        for (String blankId : blankIdList) {
+//            List<ProductionProcesses> productionProcesses = new LinkedList<>(processes);
+//            for (ProductionProcesses productionProcess : productionProcesses) {
+//                //不是此坯料计划的明细,并且解锁的，锁定，并且填入加工设备、计划开工时间
+//                if (!productionProcess.getProduceOrder().get(0).getId().equals(blankId)
+//                        && !productionProcess.isIfLock()) {
+//                    ApsProcessOperationProcessEquDo equDo = allProcessEquList.stream().filter(item -> item.getId().equals(productionProcess.getId())).findFirst().orElse(null);
+//                    if (equDo != null) {
+//                        LocalDateTime planstartdate = DateUtil.parseLocalDateTime((CharSequence) equDo.getPlanstartdate());
+//                        LocalDateTime planenddate = DateUtil.parseLocalDateTime((CharSequence) equDo.getPlanenddate());
+//                        String processdeviceid = equDo.getProcessdeviceid();
+//                        Equipment equipment = new Equipment();
+//                        equipment.setId(processdeviceid);
+//                        productionProcess.setStartTime(planstartdate);
+//                        productionProcess.setEndTime(planenddate);
+//                        productionProcess.setEquipment(equipment);
+//                    }
+//                }
+//            }
+//            ProductionScheduleVo newProductionSchedule = BeanUtil.toBean(apsProductionSchedule, ProductionScheduleVo.class);
+//            newProductionSchedule.setProcesses(productionProcesses);
+//            res.add(newProductionSchedule);
+//        }
+//
+//        return res;
+//    }
+
     private void logSave(SysUserVo currentUser, DateTime startTime, DateTime endTime, ApsTypeVo apsType, Date apsPlanStartDate, Date apsPlanEndDate, ProductionScheduleRetVo productionScheduleRetVo) {
         try {
             ApsScheduleLogDo apsScheduleLogDo = new ApsScheduleLogDo();

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

@@ -1286,6 +1286,8 @@
                 PROCESSWORKSHOPID,
                 max(PROCESSWORKSHOP) PROCESSWORKSHOP,
                 DATE(PROCESSDAY) PROCESSDAY,
+                count(if(YEARWEEK(heat.PROCESSDAY,1)=YEARWEEK(CURRENT_DATE,1), -- 本周
+                         1,null)) AS haveDay, -- 本周实际出炉天数
                 count(if(YEARWEEK(heat.PROCESSDAY,1)=YEARWEEK(CURRENT_DATE,1), -- 本周
                          HEATNUMBER,null)) PLANPRODUCEVOLUME, -- 本周计划加工量=炉次的数量
                 count(if(DATE(heat.PROCESSDAY) = DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY), -- 昨日
@@ -1312,7 +1314,8 @@
                      HAVING (YEARWEEK(PROCESSDAY,1)=YEARWEEK(CURRENT_DATE,1) -- 本周
                          or DATE(PROCESSDAY) = DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY)) -- 昨日
                  ) heat
-            group by PROCESSWORKSHOPID,DATE(PROCESSDAY)
+            group by PROCESSWORKSHOPID
+
         ),
              actual as (
                  -- 按照车间分组统计本周退火工序类别实际加工量
@@ -1320,6 +1323,8 @@
                      PROCESSWORKSHOPID,
                      max(PROCESSWORKSHOP) PROCESSWORKSHOP,
                      DATE(PROCESSDAY) PROCESSDAY,
+                     count(if(YEARWEEK(heat.PROCESSDAY,1)=YEARWEEK(CURRENT_DATE,1), -- 本周
+                              1,null)) AS haveDay, -- 本周实际出炉天数
                      count(if(YEARWEEK(heat.PROCESSDAY,1)=YEARWEEK(CURRENT_DATE,1), -- 本周
                               HEATNUMBER,null)) ACTUALPRODUCEVOLUME, -- 本周实际已加工（炉次）
                      count(if(DATE(heat.PROCESSDAY) = DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY), -- 昨日
@@ -1341,35 +1346,35 @@
                            and arr.REPORTWORKSTATUS='已报工'
                            and apo.TENANTID=#{tenantId}
                          group by
-                             apope.PROCESSDEVICEID,concat(apope.PROCESSDEVICEID,arr.STARTWORKTIME,arr.HEATNUMBER)
+                             concat(apope.PROCESSDEVICEID,arr.STARTWORKTIME,arr.HEATNUMBER)
                          HAVING (YEARWEEK(PROCESSDAY,1)=YEARWEEK(CURRENT_DATE,1) -- 本周
                              or DATE(PROCESSDAY) = DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY)) -- 昨日
                      ) heat
-                 group by PROCESSWORKSHOPID,DATE(PROCESSDAY)
+                 group by PROCESSWORKSHOPID
              )
         select
             plan.PROCESSWORKSHOPID
              ,plan.PROCESSWORKSHOP
-             ,IFNULL(ROUND(sum(if(YEARWEEK(plan.PROCESSDAY,1)=YEARWEEK(CURRENT_DATE,1),plan.PLANPRODUCEVOLUME,null)),2),0) AS 'WEEKPLANPRODUCEVOLUME' -- 本周计划加工（吨）
-             ,IFNULL(ROUND(sum(if(DATE(plan.PROCESSDAY) = DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY),plan.YPLANPRODUCEVOLUME,null)),2),0) AS 'YPLANPRODUCEVOLUME' -- 昨日计划加工（吨）
-             ,IFNULL(ROUND(sum(if(YEARWEEK(actual.PROCESSDAY,1)=YEARWEEK(CURRENT_DATE,1),actual.ACTUALPRODUCEVOLUME,null)),2),0) AS 'WEEKACTUALPRODUCEVOLUME' -- 本周实际已加工（吨）
-             ,IFNULL(ROUND(sum(if(DATE(actual.PROCESSDAY) = DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY),actual.YACTUALPRODUCEVOLUME,null)),2),0) AS 'YACTUALPRODUCEVOLUME' -- 昨日实际已加工（吨）
+             ,IFNULL(ROUND(plan.PLANPRODUCEVOLUME,2),0) AS 'WEEKPLANPRODUCEVOLUME' -- 本周计划加工（吨）
+             ,IFNULL(ROUND(plan.YPLANPRODUCEVOLUME,2),0) AS 'YPLANPRODUCEVOLUME' -- 昨日计划加工（吨）
+             ,IFNULL(ROUND(actual.ACTUALPRODUCEVOLUME,2),0) AS 'WEEKACTUALPRODUCEVOLUME' -- 本周实际已加工（吨）
+             ,IFNULL(ROUND(actual.YACTUALPRODUCEVOLUME,2),0) AS 'YACTUALPRODUCEVOLUME' -- 昨日实际已加工（吨）
              --              ,ROUND(if(plan.PLANPRODUCEVOLUME is null or plan.PLANPRODUCEVOLUME = 0,
 --                  1, actual.ACTUALPRODUCEVOLUME/plan.PLANPRODUCEVOLUME),2) COMPLETIONRATIO -- 本周实际已完成比例
-             ,IFNULL(ROUND(AVG(actual.ACTUALPRODUCEVOLUME),2),0) COMPLETIONRATIO -- 本周日平均
+             ,IFNULL(ROUND(actual.ACTUALPRODUCEVOLUME/actual.haveDay,2),0) COMPLETIONRATIO -- 本周日平均
         from
             plan left join actual on plan.PROCESSWORKSHOPID=actual.PROCESSWORKSHOPID group by plan.PROCESSWORKSHOPID
         union -- mysql 该版本不支持full join，通过left join 和right join配合
         select
             actual.PROCESSWORKSHOPID
              ,actual.PROCESSWORKSHOP
-             ,IFNULL(ROUND(sum(if(YEARWEEK(plan.PROCESSDAY,1)=YEARWEEK(CURRENT_DATE,1),plan.PLANPRODUCEVOLUME,null)),2),0) AS 'WEEKPLANPRODUCEVOLUME' -- 本周计划加工（吨）
-             ,IFNULL(ROUND(sum(if(DATE(plan.PROCESSDAY) = DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY),plan.YPLANPRODUCEVOLUME,null)),2),0) AS 'YPLANPRODUCEVOLUME' -- 昨日计划加工（吨）
-             ,IFNULL(ROUND(sum(if(YEARWEEK(actual.PROCESSDAY,1)=YEARWEEK(CURRENT_DATE,1),actual.ACTUALPRODUCEVOLUME,null)),2),0) AS 'WEEKACTUALPRODUCEVOLUME' -- 本周实际已加工（吨）
-             ,IFNULL(ROUND(sum(if(DATE(actual.PROCESSDAY) = DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY),actual.YACTUALPRODUCEVOLUME,null)),2),0) AS 'YACTUALPRODUCEVOLUME' -- 昨日实际已加工（吨）
+             ,IFNULL(ROUND(plan.PLANPRODUCEVOLUME,2),0) AS 'WEEKPLANPRODUCEVOLUME' -- 本周计划加工（吨）
+             ,IFNULL(ROUND(plan.YPLANPRODUCEVOLUME,2),0) AS 'YPLANPRODUCEVOLUME' -- 昨日计划加工（吨）
+             ,IFNULL(ROUND(actual.ACTUALPRODUCEVOLUME,2),0) AS 'WEEKACTUALPRODUCEVOLUME' -- 本周实际已加工（吨）
+             ,IFNULL(ROUND(actual.YACTUALPRODUCEVOLUME,2),0) AS 'YACTUALPRODUCEVOLUME' -- 昨日实际已加工（吨）
              --              ,ROUND(if(plan.PLANPRODUCEVOLUME is null or plan.PLANPRODUCEVOLUME = 0,
 --                  1, actual.ACTUALPRODUCEVOLUME/plan.PLANPRODUCEVOLUME),2) COMPLETIONRATIO -- 本周实际已完成比例
-             ,IFNULL(ROUND(AVG(actual.ACTUALPRODUCEVOLUME),2),0) COMPLETIONRATIO -- 本周日平均
+             ,IFNULL(ROUND(actual.ACTUALPRODUCEVOLUME/actual.haveDay,2),0) COMPLETIONRATIO -- 本周日平均
         from
             plan right join actual on plan.PROCESSWORKSHOPID=actual.PROCESSWORKSHOPID group by actual.PROCESSWORKSHOPID
     </select>
@@ -1389,7 +1394,7 @@
                           -- 按照车间分组统计本月退火工序类别计划加工量
                           select
                               concat(apope.PROCESSDEVICEID,apope.PLANSTARTDATE) HEATNUMBER, -- 炉次(设备ID+计划开工时间)
-                              max(apope.PLANSTARTDATE) PROCESSDAY
+                              max(apope.PLANENDDATE) PROCESSDAY
                           from
                               aps_process_operation_process_equ apope
                                   join aps_process_operation apo on apo.ID = apope.PROCESSID
@@ -1399,8 +1404,6 @@
                             and app.PROCESSCATEGORY='30' -- 退火
                             and apo.PROCESSSTATUS in ('30','40','50') -- 已发布
                             and (apope.PLANPROCESSRALL-apope.CANCELROLL)>0 -- 计划加工卷数- 已取消卷数合计
-                            and (YEAR(apope.PLANSTARTDATE) = YEAR(CURRENT_DATE) and MONTH(apope.PLANSTARTDATE) = MONTH(CURRENT_DATE) -- 本月
-                              or DATE(apope.PLANSTARTDATE) = DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY)) -- 昨日
                             and apo.TENANTID=#{tenantId}
                           group by
                               concat(apope.PROCESSDEVICEID,apope.PLANSTARTDATE) -- 计划炉次
@@ -1416,7 +1419,7 @@
                          -- 按照车间分组统计本月退火工序类别实际加工量
                          select
                              concat(apope.PROCESSDEVICEID,arr.STARTWORKTIME,arr.HEATNUMBER) HEATNUMBER, -- 炉次
-                             max(DATE(arr.STARTWORKTIME)) PROCESSDAY
+                             max(DATE(arr.REPORTWORKTIME)) PROCESSDAY
                          from
                              aps_report_records arr
                                  join aps_process_operation_process_equ apope  on apope.id=arr.PROCESSEQUID
@@ -1428,7 +1431,7 @@
                            and arr.REPORTWORKSTATUS='已报工'
                            and apo.TENANTID=#{tenantId}
                          group by
-                             apope.PROCESSDEVICEID,concat(apope.PROCESSDEVICEID,arr.STARTWORKTIME,arr.HEATNUMBER)
+                             concat(apope.PROCESSDEVICEID,arr.STARTWORKTIME,arr.HEATNUMBER)
                      ) heat
                  group by month_year
              )
@@ -1457,7 +1460,7 @@
                           -- 按照车间分组统计本月退火工序类别计划加工量
                           select
                               concat(apope.PROCESSDEVICEID,apope.PLANSTARTDATE) HEATNUMBER, -- 炉次(设备ID+计划开工时间)
-                              max(apope.PLANSTARTDATE) PROCESSDAY
+                              max(apope.PLANENDDATE) PROCESSDAY
                           from
                               aps_process_operation_process_equ apope
                                   join aps_process_operation apo on apo.ID = apope.PROCESSID
@@ -1467,8 +1470,6 @@
                             and app.PROCESSCATEGORY='30' -- 退火
                             and apo.PROCESSSTATUS in ('30','40','50') -- 已发布
                             and (apope.PLANPROCESSRALL-apope.CANCELROLL)>0 -- 计划加工卷数- 已取消卷数合计
-                            and (YEAR(apope.PLANSTARTDATE) = YEAR(CURRENT_DATE) and MONTH(apope.PLANSTARTDATE) = MONTH(CURRENT_DATE) -- 本月
-                              or DATE(apope.PLANSTARTDATE) = DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY)) -- 昨日
                             and apo.TENANTID=#{tenantId}
                           group by
                               concat(apope.PROCESSDEVICEID,apope.PLANSTARTDATE) -- 计划炉次
@@ -1484,7 +1485,7 @@
                          -- 按照车间分组统计本月退火工序类别实际加工量
                          select
                              concat(apope.PROCESSDEVICEID,arr.STARTWORKTIME,arr.HEATNUMBER) HEATNUMBER, -- 炉次
-                             max(DATE(arr.STARTWORKTIME)) PROCESSDAY
+                             max(DATE(arr.REPORTWORKTIME)) PROCESSDAY
                          from
                              aps_report_records arr
                                  join aps_process_operation_process_equ apope  on apope.id=arr.PROCESSEQUID
@@ -1496,7 +1497,7 @@
                            and arr.REPORTWORKSTATUS='已报工'
                            and apo.TENANTID=#{tenantId}
                          group by
-                             apope.PROCESSDEVICEID,concat(apope.PROCESSDEVICEID,arr.STARTWORKTIME,arr.HEATNUMBER)
+                             concat(apope.PROCESSDEVICEID,arr.STARTWORKTIME,arr.HEATNUMBER)
                      ) heat
                  group by month_year
              )