Merge remote-tracking branch 'origin/master'

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

@@ -23,6 +23,8 @@ public interface ApsProcessOperationService extends IService<ApsProcessOperation
      */
     R resetCraftRoute(Map<String, Object> params);
 
+    R chooseHistoryRoute(Map<String, Object> params);
+
     /*
     清除工艺路线
      */

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

@@ -230,7 +230,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         // 更新工序作业的状态
         apsProcessOperationDao.publish(collect);
         // 更新订单表的生产状态
-        blankIds.forEach(blankId->{
+        blankIds.forEach(blankId -> {
             processOperationProcessEquService.updateOrder(blankId);
         });
         // 根据坯料ID 删除 备份数据
@@ -287,7 +287,7 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
         apsProcessOperationDao.publishCancel(collect);
         // 根据坯料ID 删除 备份数据
         // 更新订单表的生产状态
-        blankIds.forEach(blankId->{
+        blankIds.forEach(blankId -> {
             processOperationProcessEquService.updateOrder(blankId);
         });
         ApsUtils.clearBackup(null);
@@ -1518,6 +1518,18 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
                 return R.error("输出成品：" + apsProcessOutputProductDo.getProductname() + " 已修改或已删除，并已开工，计划输出订单重量 不能大于 0");
             }
         }
+
+        /**
+         * 如果所选产品明细对应技术要求的坯料类型，或者坯料产品类型与当前坯料需求的不同，
+         * 错误提示：所选产品的坯料类型，或者坯料产品类型与当前坯料需求的技术要求不同，不可作为该坯料的输出成品
+         */
+        for (ApsProcessOutputProductDo apsProcessOutputProductDo : apsProcessOutputProductDoList) {
+            if (!apsProcessOutputProductDo.getBlanktype().equals(apsBlankOrderDo.getBlanktype()) || !apsProcessOutputProductDo.getBlankproducttype().equals(apsBlankOrderDo.getProducttype())) {
+                return R.error("输出成品：" + apsProcessOutputProductDo.getProductname() + " 所选产品的坯料类型，或者坯料产品类型与当前坯料需求的技术要求不同，不可作为该坯料的输出成品");
+            }
+        }
+
+
         //如果存在订单产品和输出单卷重都相同坯料输出成品，错误提示：以下坯料输出成品重复：{订单产品1}{输出单卷重}{数量单位}，{订单产品2}{输出单卷重}{数量单位}
         //组装一下list
         List<String> processOutputDesList = apsProcessOutputProductDoList.stream().map(item -> {
@@ -1770,6 +1782,16 @@ public class ApsBlankOrderServiceImpl extends ServiceImpl<ApsBlankOrderDao, ApsB
             }
         }
 
+        /**
+         * 如果所选产品明细对应技术要求的坯料类型，或者坯料产品类型与当前坯料需求的不同，
+         * 错误提示：所选产品的坯料类型，或者坯料产品类型与当前坯料需求的技术要求不同，不可作为该坯料的输出成品
+         */
+        for (ApsProcessOutputProductDo apsProcessOutputProductDo : apsProcessOutputProductDoList) {
+            if (!apsProcessOutputProductDo.getBlanktype().equals(apsBlankOrderDo.getBlanktype()) || !apsProcessOutputProductDo.getBlankproducttype().equals(apsBlankOrderDo.getProducttype())) {
+                return R.error("第" + j + "个坯料计划 输出成品：" + apsProcessOutputProductDo.getProductname() + " 所选产品的坯料类型，或者坯料产品类型与当前坯料需求的技术要求不同，不可作为该坯料的输出成品");
+            }
+        }
+
 
         //============校验工艺路线=============
         //如果坯料需求的坯料输出成品字段值不等于坯料需求的工艺输出成品字段值，错误提示：工艺路线输出成品与坯料输出成品不一致

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

@@ -579,6 +579,194 @@ public class ApsProcessOperationServiceImpl extends ServiceImpl<ApsProcessOperat
         }
     }
 
+    /*
+    选择历史工艺路线后续操作
+     */
+    @Override
+    @Transactional
+    public R chooseHistoryRoute(Map<String, Object> params) {
+        String oldblankid = params.get("OLDBLANKID").toString();
+        String newblankid = params.get("NEWBLANKID").toString();
+        String craftrouteid = params.get("CRAFTROUTEID").toString();
+
+        //先清空之前的相关数据
+        Map<String, Object> blanckMap = new HashMap<>();
+        blanckMap.put("BLANKID", oldblankid);
+        clearCraftRoute(blanckMap);
+
+        //选择新的坯料计划的工序作业、可选设备、输出、思维导图
+        Map<String, Object> map = new HashMap<>();
+        map.put("BLANKID", newblankid);
+        List<ApsProcessOperationDo> apsProcessOperationDos = apsProcessOperationService.listByMap(map).stream().collect(Collectors.toList());
+        Collections.sort(apsProcessOperationDos, Comparator.comparingInt(ApsProcessOperationDo::getLevel));
+        Collections.sort(apsProcessOperationDos, Comparator.comparing(ApsProcessOperationDo::getCreatedate));
+        List<ApsProcessOperationOutMaterDo> apsProcessOperationOutMaterDos = apsProcessOperationOutMaterService.listByMap(map).stream().collect(Collectors.toList());
+        List<ApsProcessOperationEquDo> apsProcessOperationEquDos = apsProcessOperationEquService.listByMap(map).stream().collect(Collectors.toList());
+
+        //要新建的实体集合
+        List<String> overProcessIds = new ArrayList<>();
+        List<PreviousProcessVo> newProcessIds = new ArrayList<>();//前道工序信息
+        List<ApsProcessOperationDo> apsProcessOperationDoList = new ArrayList<>();
+        List<ApsProcessOperationOutMaterDo> apsProcessOperationOutMaterDoList = new ArrayList<>();
+        List<ApsProcessOperationEquDo> apsProcessOperationEquDoList = new ArrayList<>();
+        List<SysMindMappingDo> sysMindMappingDoList = new ArrayList<>();
+
+        Map<String, Object> mindMap = new HashMap<>();
+        mindMap.put("BSID", newblankid);
+        List<SysMindMappingDo> sysMindMappingDos = sysMindMappingService.listByMap(mindMap).stream().collect(Collectors.toList());
+        Collections.sort(sysMindMappingDos, Comparator.comparing(SysMindMappingDo::getTreecode, Comparator.nullsFirst(Comparator.naturalOrder())));
+        if (sysMindMappingDos.size() == 0) {
+            return R.error("工艺路线思维导图不存在");
+        }
+        SysMindMappingDo sysMindMappingDo = BeanUtil.toBean(sysMindMappingDos.get(0), SysMindMappingDo.class);
+        String mindStrId = SecurityUtil.getUUID();
+        sysMindMappingDo.setId(mindStrId);
+        sysMindMappingDo.setBsid(oldblankid);
+        sysMindMappingDo.setBstable("aps_process_operation");
+        sysMindMappingDoList.add(sysMindMappingDo);
+
+        for (ApsProcessOperationDo apsProcessOperationDo : apsProcessOperationDos) {
+            if (overProcessIds.contains(apsProcessOperationDo.getId())) {
+                continue;
+            } else {
+                String processId;
+                ApsProcessOperationDo processOperationDo;
+                PreviousProcessVo previousProcessVo;
+                if (StringUtils.isNotBlank(apsProcessOperationDo.getPreviousprocessid())) {
+                    //后面工序
+                    List<ApsProcessOperationDo> apsProcessOperationDos1 = apsProcessOperationDos.stream().filter(acrs -> apsProcessOperationDo.getPreviousprocessid().equals(acrs.getPreviousprocessid())).collect(Collectors.toList());
+                    Collections.sort(apsProcessOperationDos1, Comparator.comparing(ApsProcessOperationDo::getCreatedate));
+                    for (ApsProcessOperationDo apsProcessOperationDo1 : apsProcessOperationDos1) {
+                        previousProcessVo = new PreviousProcessVo();
+                        processId = SecurityUtil.getUUID();
+                        processOperationDo = BeanUtil.toBean(apsProcessOperationDo1, ApsProcessOperationDo.class);
+                        processOperationDo.setId(processId);
+                        processOperationDo.setBlankid(oldblankid);
+                        processOperationDo.setNextprocessid(null);
+
+                        //前道工序输出
+                        List<PreviousProcessVo> processVo = newProcessIds.stream().filter(pro -> pro.getPreviousstepid().equals(apsProcessOperationDo1.getPreviousprocessid())).collect(Collectors.toList());
+                        processOperationDo.setPreviousprocessid(processVo.get(0).getProcessId());
+
+                        //更新前道工序的后道工序
+                        ApsProcessOperationDo aDo = apsProcessOperationDoList.stream().filter(qtr -> processVo.get(0).getProcessId().equals(qtr.getId())).findAny().orElse(null);
+                        if (StringUtils.isBlank(aDo.getNextprocessid())) {
+                            aDo.setNextprocessid(processId);
+                        } else {
+                            aDo.setNextprocessid(aDo.getNextprocessid() + "," + processId);
+                        }
+
+                        //本道工序信息
+                        previousProcessVo.setProcessId(processId);
+                        previousProcessVo.setPreviousstepid(apsProcessOperationDo1.getId());
+
+                        //本道工序的输出
+                        List<ApsProcessOperationOutMaterDo> apsProcessOperationOutMaterDos1 = apsProcessOperationOutMaterDos.stream().filter(omd -> apsProcessOperationDo1.getId().equals(omd.getMainid())).collect(Collectors.toList());
+                        if (apsProcessOperationOutMaterDos1.size() == 0) {
+                            return R.error("工艺步骤" + apsProcessOperationDo1.getProcessname() + "没输出");
+                        }
+                        for (ApsProcessOperationOutMaterDo apsProcessOperationOutMaterDo : apsProcessOperationOutMaterDos1) {
+                            ApsProcessOperationOutMaterDo processOperationOutMaterDo = BeanUtil.toBean(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo.class);
+                            processOperationOutMaterDo.setId(SecurityUtil.getUUID());
+                            processOperationOutMaterDo.setMainid(processId);
+                            processOperationOutMaterDo.setBlankid(oldblankid);
+                            apsProcessOperationOutMaterDoList.add(processOperationOutMaterDo);
+                        }
+
+                        //本道工序的可选设备
+                        List<ApsProcessOperationEquDo> apsProcessOperationEquDos1 = apsProcessOperationEquDos.stream().filter(crse -> apsProcessOperationDo1.getId().equals(crse.getMainid())).collect(Collectors.toList());
+                        for (ApsProcessOperationEquDo apsProcessOperationEquDo : apsProcessOperationEquDos1) {
+                            ApsProcessOperationEquDo processOperationEquDo = BeanUtil.toBean(apsProcessOperationEquDo, ApsProcessOperationEquDo.class);
+                            processOperationEquDo.setId(SecurityUtil.getUUID());
+                            processOperationEquDo.setMainid(processId);
+                            processOperationEquDo.setBlankid(oldblankid);
+                            apsProcessOperationEquDoList.add(processOperationEquDo);
+                        }
+
+                        //本道工序思维导图
+                        List<SysMindMappingDo> sysMindMappingDos1 = sysMindMappingDos.stream().filter(mind -> mind.getId().equals(apsProcessOperationDo1.getId())).collect(Collectors.toList());
+                        SysMindMappingDo sysMindMappingDo1 = sysMindMappingDos1.get(0);
+                        sysMindMappingDo1.setId(processId);
+                        sysMindMappingDo1.setParentid(processVo.get(0).getProcessId());
+                        sysMindMappingDo1.setBsid(oldblankid);
+                        sysMindMappingDo1.setBstable("aps_process_operation");
+                        JSONObject jsonObject = new JSONObject();
+                        jsonObject.putOpt("craftStepId", apsProcessOperationDo1.getId());
+                        sysMindMappingDo1.setRoption(jsonObject.toString());//存工艺路线的工艺步骤ID
+                        sysMindMappingDoList.add(sysMindMappingDo1);
+
+                        newProcessIds.add(previousProcessVo);
+                        apsProcessOperationDoList.add(processOperationDo);
+
+                        overProcessIds.add(apsProcessOperationDo1.getId());
+                    }
+                } else {
+                    previousProcessVo = new PreviousProcessVo();
+                    //首道工序
+                    processId = SecurityUtil.getUUID();
+                    processOperationDo = BeanUtil.toBean(apsProcessOperationDo, ApsProcessOperationDo.class);
+                    processOperationDo.setId(processId);
+                    processOperationDo.setBlankid(oldblankid);
+                    processOperationDo.setNextprocessid(null);
+
+                    //本道工序信息
+                    previousProcessVo.setProcessId(processId);
+                    previousProcessVo.setPreviousstepid(apsProcessOperationDo.getId());
+
+                    //本道工序的输出
+                    List<ApsProcessOperationOutMaterDo> apsProcessOperationOutMaterDos1 = apsProcessOperationOutMaterDos.stream().filter(omd -> apsProcessOperationDo.getId().equals(omd.getMainid())).collect(Collectors.toList());
+                    if (apsProcessOperationOutMaterDos1.size() == 0) {
+                        return R.error("工艺步骤" + apsProcessOperationDo.getProcessname() + "没输出");
+                    }
+                    for (ApsProcessOperationOutMaterDo apsProcessOperationOutMaterDo : apsProcessOperationOutMaterDos1) {
+                        ApsProcessOperationOutMaterDo processOperationOutMaterDo = BeanUtil.toBean(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo.class);
+                        processOperationOutMaterDo.setId(SecurityUtil.getUUID());
+                        processOperationOutMaterDo.setMainid(processId);
+                        processOperationOutMaterDo.setBlankid(oldblankid);
+                        apsProcessOperationOutMaterDoList.add(processOperationOutMaterDo);
+                    }
+
+                    //本道工序的可选设备
+                    List<ApsProcessOperationEquDo> apsProcessOperationEquDos1 = apsProcessOperationEquDos.stream().filter(omd -> apsProcessOperationDo.getId().equals(omd.getMainid())).collect(Collectors.toList());
+                    for (ApsProcessOperationEquDo apsProcessOperationEquDo : apsProcessOperationEquDos1) {
+                        ApsProcessOperationEquDo processOperationEquDo = BeanUtil.toBean(apsProcessOperationEquDo, ApsProcessOperationEquDo.class);
+                        processOperationEquDo.setId(SecurityUtil.getUUID());
+                        processOperationEquDo.setMainid(processId);
+                        processOperationEquDo.setBlankid(oldblankid);
+                        apsProcessOperationEquDoList.add(processOperationEquDo);
+                    }
+
+                    //本道工序思维导图
+                    List<SysMindMappingDo> sysMindMappingDos1 = sysMindMappingDos.stream().filter(mind -> mind.getId().equals(apsProcessOperationDo.getId())).collect(Collectors.toList());
+                    SysMindMappingDo sysMindMappingDo1 = sysMindMappingDos1.get(0);
+                    sysMindMappingDo1.setId(processId);
+                    sysMindMappingDo1.setParentid(mindStrId);
+                    sysMindMappingDo1.setBsid(oldblankid);
+                    sysMindMappingDo1.setBstable("aps_process_operation");
+                    JSONObject jsonObject = new JSONObject();
+                    jsonObject.putOpt("craftStepId", apsProcessOperationDo.getId());
+                    sysMindMappingDo1.setRoption(jsonObject.toString());//存工艺路线的工艺步骤ID
+                    sysMindMappingDoList.add(sysMindMappingDo1);
+
+                    newProcessIds.add(previousProcessVo);
+                    apsProcessOperationDoList.add(processOperationDo);
+                }
+            }
+        }
+
+        boolean bool1 = apsProcessOperationService.saveOrUpdateBatch(apsProcessOperationDoList);
+        boolean bool2 = apsProcessOperationOutMaterService.saveOrUpdateBatch(apsProcessOperationOutMaterDoList);
+        boolean bool3 = apsProcessOperationEquService.saveOrUpdateBatch(apsProcessOperationEquDoList);
+        boolean bool4 = sysMindMappingService.saveOrUpdateBatch(sysMindMappingDoList);
+        if (bool1 && bool2 && bool3 && bool4) {
+            //更新坯料计划的所选工艺路线
+            apsBlankOrderDao.upCraftrouteId(oldblankid, craftrouteid);
+            return R.ok();
+        } else {
+            return R.error();
+        }
+    }
+
     /*
     清除工艺路线
      */

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

@@ -287,11 +287,10 @@ public class ApsProductionOrderServiceImpl extends ServiceImpl<ApsProductionOrde
 
         if (req.getIsNeedPublish()) {
             //=============发布排程================
-            List<String> productOrderIdList = new LinkedList<>();
-            productOrderIdList.add(apsProductionOrderDo.getId());
-            R publish = this.publish(productOrderIdList);
+            List<String> blankIds = apsBlankOrderDoList.stream().map(ApsBlankOrderDo::getId).collect(Collectors.toList());
+            R publish = apsBlankOrderService.publish(blankIds);
             if (!publish.getCode().equals("200")) {
-                return R.error(publish.getMsg());
+                throw new RuntimeException(publish.getMsg());
             }
         }
 

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

@@ -390,6 +390,7 @@ public class ApsReportRecordsServiceImpl extends ServiceImpl<ApsReportRecordsDao
             for (ApsReportBlankCompentDo apsReportBlankCompentDo : apsReportBlankCompentDoList) {
                 ApsReportBlankCompentDo needAdd = new ApsReportBlankCompentDo();
                 needAdd.setId(SecurityUtil.getUUID());
+                needAdd.setTenantid(tenantId);
                 needAdd.setMainid(apsReportRecordsDo.getId());
                 needAdd.setCompent(apsReportBlankCompentDo.getCompent());
                 needAdd.setStartproportion(apsReportBlankCompentDo.getStartproportion());

cx-aps/cx-aps-entity/src/main/java/com/rongwei/bsentity/domain/ApsProductionOrderDo.java

@@ -607,6 +607,16 @@ public class ApsProductionOrderDo extends BaseDo implements Serializable {
      */
     private String deputygeneralmanagername;
 
+    /**
+     * 变更说明
+     */
+    private String changefile;
+
+    /**
+     * 流程状态
+     */
+    private String processstatustext;
+
     @TableField(exist = false)
     private static final long serialVersionUID = 1L;
 }

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

@@ -46,6 +46,22 @@ public class ApsProcessOperationController {
         }
     }
 
+    /*
+    选择历史工艺路线自动生成工序作业
+     */
+    @PostMapping("/chooseHistoryRoute")
+    public R chooseHistoryRoute(@RequestBody Map<String, Object> params) {
+        try {
+            log.info("选择历史工艺路线;参数为：{}", params);
+            R resData = apsProcessOperationService.chooseHistoryRoute(params);
+            return resData;
+        } catch (Exception e) {
+            e.printStackTrace();
+            log.info("选择历史工艺路线异常:" + e.getMessage());
+            return R.error("选择历史工艺路线异常:" + e.getMessage());
+        }
+    }
+
     /*
     清除工艺路线
      */

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

@@ -68,7 +68,7 @@ public class ApsProductionOrderController {
     }
 
     /**
-     * 调整订单时打开编辑页之前的操作
+     * 调整订单时打开编辑页之前的操作（废弃）
      */
     @PostMapping("/changeOrder")
     public R changeOrder(@RequestBody ApsProductionOrderDo req){