aps-拆分

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

@@ -18,7 +18,7 @@ public interface ApsProcessOperationProcessEquService extends IService<ApsProces
 
     String updateProcessByProcessEquId(String processOperationEquId);
 
-    R changingWires(List<ChangingWiresVo> changingWiresVos);
+    List<String> changingWires(List<ChangingWiresVo> changingWiresVos);
 
     R getOptionalEquipment(List<String> operationJobDetailsId);
 

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

@@ -296,11 +296,11 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
      */
     @Override
 //    @Transactional(rollbackFor = Exception.class)
-    public R changingWires(List<ChangingWiresVo> changingWiresVos) {
+    public List<String> changingWires(List<ChangingWiresVo> changingWiresVos) {
 //        ApsUtils.checkScheduling(null);
         if (changingWiresVos.isEmpty()) {
             log.error("换线作业的工序作业不为空");
-            return R.error("工序作业不能为空");
+            throw new CustomException("工序作业不能为空");
         }
         // 工序作业明细ID
         List<String> detailIds = changingWiresVos.stream().map(ChangingWiresVo::getId).collect(Collectors.toList());
@@ -308,7 +308,7 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
         for (String equId : detailIds) {
             if (changeWiresLock.containsKey(equId)) {
                 log.error("该作业明细已被：{}其他操作员换线", changeWiresLock.get(equId));
-                return R.error("该作业明细已被其他操作员换线");
+                throw new CustomException("该作业明细已被其他操作员换线");
             }
         }
         for (String equId : detailIds) {
@@ -320,7 +320,7 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
             List<String> returnAboutIds = changingWiresVos.stream().map(ChangingWiresVo::getReturnAboutIds).flatMap(Collection::stream).collect(Collectors.toList());
             if (detailIds.isEmpty()) {
                 log.error("需要换线的工序作业id为空");
-                return R.error("需要换线的工序作业id为空");
+                throw new CustomException("需要换线的工序作业id为空");
             }
             // 换线作业受影响的工序作业ID
             List<String> affectedIdList = new ArrayList<>(detailIds);
@@ -330,18 +330,18 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
             List<ApsProcessOperationProcessEquDo> apsProcessOperationProcessEquDos = this.baseMapper.selectBatchIds(detailIds);
             if (apsProcessOperationProcessEquDos.isEmpty()) {
                 log.error("无法获取到工序作业明细");
-                return R.error("无法获取到工序作业明细");
+                throw new CustomException("无法获取到工序作业明细");
             }
             if (apsProcessOperationProcessEquDos.size() != changingWiresVos.size()) {
                 log.error("本次换线操作存在无法获取作业明细的数据");
-                return R.error("本次换线操作存在无法获取作业明细的数据!请联系系统管理员");
+                throw new CustomException("本次换线操作存在无法获取作业明细的数据!请联系系统管理员");
             }
             // 校验是否存在已完工的工序作业
             boolean hasCompletedWork = apsProcessOperationProcessEquDos.stream()
                     .anyMatch(info -> JOBSTATUS_TO_BE_END.equals(info.getWorkstatus()));
             if (hasCompletedWork) {
                 log.error("存在已完工的工序作业无法换线");
-                return R.error("存在已完工的工序作业无法换线");
+                throw new CustomException("存在已完工的工序作业无法换线");
             }
             //对于换线作业的数据进行排序
             Optional<Date> minDate = apsProcessOperationProcessEquDos.stream()
@@ -569,8 +569,7 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
                 changeWiresLock.remove(equId);
             }
         }
-        // 重新获取甘特图数据并返回前段
-        return R.ok(ganttService.getListById(aboutIds));
+        return aboutIds;
     }
 
     public void splitProcessEqu(ApsProcessOperationProcessEquDo processEqus,
@@ -1455,178 +1454,245 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
                     newDo.setProcessworkshop(currentProcessEquDo.getProcessworkshop());
                 }
                 // 数量和待加工数量相同直接修改原数据
+                //如果拆分卷数=计划加工卷数,则相当于换线
                 if (splitQty == unFinishRoll) {
-                    newDo.setId(currentProcessEquDo.getId());
-                    if (data.getPlanStartTime() != null) {
-                        newDo.setPlanstartdate(data.getPlanStartTime());
-                        // 自动计算计划完工时间=原完工时间+新计划开工时间-原计划开工时间
-                        newDo.setPlanenddate(new Date(newDo.getPlanenddate().getTime() +
-                                data.getPlanStartTime().getTime() - currentProcessEquDo.getPlanstartdate().getTime()));
-                    }
-                    newDo.setCreatedate(new Date());
-                    newDo.setModifydate(DateUtil.date());
-                    newDo.setModifyuserid(nowWorkUser.getId());
-                    newDo.setModifyusername(nowWorkUser.getName());
-                    newDataList.add(newDo);
-                    this.updateById(newDo);
-                    affectedIdList.add(newDo.getId());
-                    // 增加受影响的工序作业信息
-                    affectedIdList.addAll(checkProcessingTimeConflict(newDo, currentProcessEquDo.getPlanstartdate(),
-                            currentProcessEquDo.getPlanenddate(), currentProcessEquDo.getProcessdeviceid(),
-                            currentProcessOperationDo.getProcessway(), new ArrayList<>()));
+//                    newDo.setId(currentProcessEquDo.getId());
+//                    if (data.getPlanStartTime() != null) {
+//                        newDo.setPlanstartdate(data.getPlanStartTime());
+//                        // 自动计算计划完工时间=原完工时间+新计划开工时间-原计划开工时间
+//                        newDo.setPlanenddate(new Date(newDo.getPlanenddate().getTime() +
+//                                data.getPlanStartTime().getTime() - currentProcessEquDo.getPlanstartdate().getTime()));
+//                    }
+//                    newDo.setCreatedate(new Date());
+//                    newDo.setModifydate(DateUtil.date());
+//                    newDo.setModifyuserid(nowWorkUser.getId());
+//                    newDo.setModifyusername(nowWorkUser.getName());
+//                    newDataList.add(newDo);
+//                    this.updateById(newDo);
+//                    affectedIdList.add(newDo.getId());
+//                    // 增加受影响的工序作业信息
+//                    affectedIdList.addAll(checkProcessingTimeConflict(newDo, currentProcessEquDo.getPlanstartdate(),
+//                            currentProcessEquDo.getPlanenddate(), currentProcessEquDo.getProcessdeviceid(),
+//                            currentProcessOperationDo.getProcessway(), new ArrayList<>()));
+                    ChangingWiresVo req = new ChangingWiresVo();
+                    req.setId(currentProcessEquDo.getId());
+                    req.setEquId(data.getEquId());
+                    req.setEquName(data.getEquName());
+                    req.setWorkshopId(data.getWorkshopId());
+                    req.setWorkshopName(data.getWorkshopName());
+                    req.setProcessingTime(data.getPlanStartTime());
+                    req.setRollerId(currentProcessEquDo.getRollerid());
+                    List<ChangingWiresVo> list = new ArrayList<>();
+                    list.add(req);
+                    affectedIdList.addAll(this.changingWires(list));
                 } else {
-                    /**************************原数据逻辑处理***********************************/
-                    ApsProcessOperationProcessEquDo oldDo = new ApsProcessOperationProcessEquDo();
-                    oldDo.setId(currentProcessEquDo.getId());
-                    oldDo.setPlanprocessrall(currentProcessEquDo.getPlanprocessrall() - splitQty);
-                    if (data.getPlanStartTime() != null) {
-                        oldDo.setPlanstartdate(data.getPlanStartTime());
-                    } else {
-                        oldDo.setPlanstartdate(currentProcessEquDo.getPlanstartdate());
-                    }
-                    if (PROCESS_WAY_MERGE.equals(currentProcessOperationDo.getProcessway())) {
-                        // 如果工序作业的加工方式是合并加工，则计划完工时间=计划开工时间+工序作业单卷作业时长
-                        oldDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() +
-                                TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue())));
-                    } else {
-                        // 如果工序作业的加工方式不是合并加工，计划开工时间+工序作业单卷作业时长*（计划加工卷数-已取消卷数）
-                        oldDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() +
-                                TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue() * oldDo.getPlanprocessrall())));
+                    //待更新作业明细集合
+                    List<ApsProcessOperationProcessEquDo> waitUpdateEquList = new LinkedList<>();
+                    //待新增作业明细集合
+                    List<ApsProcessOperationProcessEquDo> waitInsertEquList = new LinkedList<>();
+                    List<ApsProcessOperationProcessEquDo> needUpdateOldList = new LinkedList<>();
+                    List<ApsProcessOperationProcessEquDo> needInsertNewList = new LinkedList<>();
+                    apsProcessOperationProcessEquService.splitProcessEqu(currentProcessEquDo,
+                            splitQty,
+                            currentProcessOperationDo,
+                            needUpdateOldList,
+                            needInsertNewList,
+                            waitUpdateEquList,
+                            waitInsertEquList);
+                    Set<String> needUpdateProcessIdList = new HashSet<>();
+
+                    //拆分完执行sql更新数据
+                    if (!needInsertNewList.isEmpty()) {
+                        apsProcessOperationProcessEquService.saveBatch(needInsertNewList);
+                        needUpdateProcessIdList.addAll(needInsertNewList.stream().map(ApsProcessOperationProcessEquDo::getProcessid).collect(Collectors.toList()));
                     }
-                    oldDo.setUnfinishroll(oldDo.getPlanprocessrall() - currentProcessEquDo.getReportroll());
-                    // 完工状态更新
-                    if (oldDo.getPlanprocessrall() - currentProcessEquDo.getReportroll() - currentProcessEquDo.getCancelroll() > 0) {
-                        oldDo.setClosestatus(UNFINISHED);
-                    } else {
-                        oldDo.setClosestatus(SaveConstans.CloseStatus.COMPLETED);
+                    if (!needUpdateOldList.isEmpty()) {
+                        apsProcessOperationProcessEquService.updateBatchById(needUpdateOldList);
+                        needUpdateProcessIdList.addAll(needUpdateOldList.stream().map(ApsProcessOperationProcessEquDo::getProcessid).collect(Collectors.toList()));
                     }
-                    if (SaveConstans.CloseStatus.COMPLETED.equals(oldDo.getClosestatus())) {
-                        // 作业状态更新
-                        oldDo.setWorkstatus(JOBSTATUS_TO_BE_END);
-                    } else {
-                        oldDo.setWorkstatus(currentProcessEquDo.getReportroll() == 0 ? JOBSTATUS_TO_BE_START : JOBSTATUS_TO_BE_STARTING);
+                    if (!needUpdateProcessIdList.isEmpty()) {
+                        //更新对应工序作业的 计划完工时间和计划开工时间
+                        apsProcessOperationProcessEquDao.updateProcessPlanTimeByProcessIds(needUpdateProcessIdList);
                     }
-                    /**
-                     * 新增需求：计算剩余待开工/报工卷数
-                     * 剩余待开工卷数=计划加工卷数-已开工卷数-已取消卷数合计
-                     * 剩余待报工卷数=计划加工卷数-已报工卷数-已取消卷数合计
-                     * 如果剩余待报工卷数=0，则完工状态=已完工
-                     * 如果剩余待报工卷数>0，则完工状态=未完工
-                     * 临时计算待加工料卷批次号数量
-                     * 如果剩余待开工卷数<待加工料卷批次号数量，则表示有多余的批次号，去掉待加工料卷批次号最后多余的{待加工料卷批次号数量-剩余待开工卷数}个批次号，给拆分的新的作业明细
-                     */
-                    Integer leaveWaitWorkRoll = oldDo.getPlanprocessrall() - currentProcessEquDo.getStartingroll() - currentProcessEquDo.getCancelroll();
-                    Integer leaveWaitJobRoll = oldDo.getPlanprocessrall() - currentProcessEquDo.getReportroll() - currentProcessEquDo.getCancelroll();
-                    oldDo.setLeavewaitworkroll(leaveWaitWorkRoll);
-                    oldDo.setLeavewaitjobroll(leaveWaitJobRoll);
-                    if (leaveWaitJobRoll > 0) {
-                        oldDo.setClosestatus("未完工");
-                    } else {
-                        if (leaveWaitJobRoll == 0) {
-                            oldDo.setClosestatus("已完工");
-                        }
+                    //判断新拆分的作业的冲突
+                    for (ApsProcessOperationProcessEquDo equDo : needInsertNewList) {
+                        ApsProcessOperationProcessEquDo processEqu = apsProcessOperationProcessEquService.getById(equDo.getId());
+                        ApsProcessOperationDo process = apsProcessOperationService.getById(processEqu.getProcessid());
+                        affectedIdList.addAll(apsProcessOperationProcessEquService.checkProcessingTimeConflict(processEqu,
+                                null, null, null, process.getProcessway(), new LinkedList<>()));
+                        processEqu = apsProcessOperationProcessEquService.getById(processEqu.getId());
+                        apsProcessOperationProcessEquService.inspectionEquipmentIsAvailable(processEqu,
+                                processEqu.getProcessdeviceid(),
+                                processEqu.getPlanstartdate(),
+                                processEqu.getPlanenddate(),
+                                affectedIdList);
                     }
-                    List<String> newBachMaterProcess = new ArrayList<>();
-                    if (ObjectUtil.isNotEmpty(currentProcessEquDo.getBachmaterialprocess())) {
-                        String[] bachMaterialProcessArr = currentProcessEquDo.getBachmaterialprocess().split(",");
-                        if (leaveWaitWorkRoll < bachMaterialProcessArr.length) {
-                            List<String> newBach = new ArrayList<>();
-                            List<String> oldBach = new ArrayList<>();
-                            for (String mater : bachMaterialProcessArr) {
-                                if (oldBach.size() < leaveWaitWorkRoll) {
-                                    oldBach.add(mater);
-                                } else {
-                                    newBach.add(mater);
-                                }
-                            }
-                            newBachMaterProcess = newBach;
-                            oldDo.setBachmaterialprocess(String.join(",", oldBach));
-                        }
+                    for (ApsProcessOperationProcessEquDo equDo : needUpdateOldList) {
+                        ApsProcessOperationProcessEquDo processEqu = apsProcessOperationProcessEquService.getById(equDo.getId());
+                        ApsProcessOperationDo process = apsProcessOperationService.getById(processEqu.getProcessid());
+                        affectedIdList.addAll(apsProcessOperationProcessEquService.checkProcessingTimeConflict(processEqu,
+                                null, null, null, process.getProcessway(), new LinkedList<>()));
+                        processEqu = apsProcessOperationProcessEquService.getById(processEqu.getId());
+                        apsProcessOperationProcessEquService.inspectionEquipmentIsAvailable(processEqu,
+                                processEqu.getProcessdeviceid(),
+                                processEqu.getPlanstartdate(),
+                                processEqu.getPlanenddate(),
+                                affectedIdList);
                     }
-                    affectedIdList.add(oldDo.getId());
-                    oldDo.setModifydate(DateUtil.date());
-                    oldDo.setModifyuserid(nowWorkUser.getId());
-                    oldDo.setModifyusername(nowWorkUser.getName());
-                    this.updateById(oldDo);
+
+
+//                    /**************************原数据逻辑处理***********************************/
+//                    ApsProcessOperationProcessEquDo oldDo = new ApsProcessOperationProcessEquDo();
+//                    oldDo.setId(currentProcessEquDo.getId());
+//                    oldDo.setPlanprocessrall(currentProcessEquDo.getPlanprocessrall() - splitQty);
+//                    if (data.getPlanStartTime() != null) {
+//                        oldDo.setPlanstartdate(data.getPlanStartTime());
+//                    } else {
+//                        oldDo.setPlanstartdate(currentProcessEquDo.getPlanstartdate());
+//                    }
+//                    if (PROCESS_WAY_MERGE.equals(currentProcessOperationDo.getProcessway())) {
+//                        // 如果工序作业的加工方式是合并加工，则计划完工时间=计划开工时间+工序作业单卷作业时长
+//                        oldDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() +
+//                                TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue())));
+//                    } else {
+//                        // 如果工序作业的加工方式不是合并加工，计划开工时间+工序作业单卷作业时长*（计划加工卷数-已取消卷数）
+//                        oldDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() +
+//                                TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue() * oldDo.getPlanprocessrall())));
+//                    }
+//                    oldDo.setUnfinishroll(oldDo.getPlanprocessrall() - currentProcessEquDo.getReportroll());
+//                    // 完工状态更新
+//                    if (oldDo.getPlanprocessrall() - currentProcessEquDo.getReportroll() - currentProcessEquDo.getCancelroll() > 0) {
+//                        oldDo.setClosestatus(UNFINISHED);
+//                    } else {
+//                        oldDo.setClosestatus(SaveConstans.CloseStatus.COMPLETED);
+//                    }
+//                    if (SaveConstans.CloseStatus.COMPLETED.equals(oldDo.getClosestatus())) {
+//                        // 作业状态更新
+//                        oldDo.setWorkstatus(JOBSTATUS_TO_BE_END);
+//                    } else {
+//                        oldDo.setWorkstatus(currentProcessEquDo.getReportroll() == 0 ? JOBSTATUS_TO_BE_START : JOBSTATUS_TO_BE_STARTING);
+//                    }
+//                    /**
+//                     * 新增需求：计算剩余待开工/报工卷数
+//                     * 剩余待开工卷数=计划加工卷数-已开工卷数-已取消卷数合计
+//                     * 剩余待报工卷数=计划加工卷数-已报工卷数-已取消卷数合计
+//                     * 如果剩余待报工卷数=0，则完工状态=已完工
+//                     * 如果剩余待报工卷数>0，则完工状态=未完工
+//                     * 临时计算待加工料卷批次号数量
+//                     * 如果剩余待开工卷数<待加工料卷批次号数量，则表示有多余的批次号，去掉待加工料卷批次号最后多余的{待加工料卷批次号数量-剩余待开工卷数}个批次号，给拆分的新的作业明细
+//                     */
+//                    Integer leaveWaitWorkRoll = oldDo.getPlanprocessrall() - currentProcessEquDo.getStartingroll() - currentProcessEquDo.getCancelroll();
+//                    Integer leaveWaitJobRoll = oldDo.getPlanprocessrall() - currentProcessEquDo.getReportroll() - currentProcessEquDo.getCancelroll();
+//                    oldDo.setLeavewaitworkroll(leaveWaitWorkRoll);
+//                    oldDo.setLeavewaitjobroll(leaveWaitJobRoll);
+//                    if (leaveWaitJobRoll > 0) {
+//                        oldDo.setClosestatus("未完工");
+//                    } else {
+//                        if (leaveWaitJobRoll == 0) {
+//                            oldDo.setClosestatus("已完工");
+//                        }
+//                    }
+//                    List<String> newBachMaterProcess = new ArrayList<>();
+//                    if (ObjectUtil.isNotEmpty(currentProcessEquDo.getBachmaterialprocess())) {
+//                        String[] bachMaterialProcessArr = currentProcessEquDo.getBachmaterialprocess().split(",");
+//                        if (leaveWaitWorkRoll < bachMaterialProcessArr.length) {
+//                            List<String> newBach = new ArrayList<>();
+//                            List<String> oldBach = new ArrayList<>();
+//                            for (String mater : bachMaterialProcessArr) {
+//                                if (oldBach.size() < leaveWaitWorkRoll) {
+//                                    oldBach.add(mater);
+//                                } else {
+//                                    newBach.add(mater);
+//                                }
+//                            }
+//                            newBachMaterProcess = newBach;
+//                            oldDo.setBachmaterialprocess(String.join(",", oldBach));
+//                        }
+//                    }
+//                    affectedIdList.add(oldDo.getId());
+//                    oldDo.setModifydate(DateUtil.date());
+//                    oldDo.setModifyuserid(nowWorkUser.getId());
+//                    oldDo.setModifyusername(nowWorkUser.getName());
+//                    this.updateById(oldDo);
+////                    // 增加受影响的工序作业信息
+////                    affectedIdList.addAll(checkProcessingTimeConflict(oldDo,
+////                            currentProcessEquDo.getPlanstartdate(), currentProcessEquDo.getPlanenddate(),
+////                            oldDo.getProcessdeviceid(), currentProcessOperationDo.getProcessway(),new ArrayList<>()));
+//                    /**************************拆分逻辑处理***********************************/
+//                    newDo.setId(SecurityUtil.getUUID());
+//                    newDo.setPlanprocessrall(splitQty);
+//                    newDo.setCancelroll(0);
+//                    if (data.getPlanStartTime() != null) {
+//                        newDo.setPlanstartdate(data.getPlanStartTime());
+//                    } else {
+//                        newDo.setPlanstartdate(currentProcessOperationDo.getPlanstartdate());
+//                    }
+//                    if (PROCESS_WAY_MERGE.equals(currentProcessOperationDo.getProcessway())) {
+//                        // 如果工序作业的加工方式是合并加工，则计划完工时间=计划开工时间+工序作业单卷作业时长
+//                        newDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue())));
+//                    } else {
+//                        // 如果工序作业的加工方式不是合并加工，则计划完工时间=计划开工时间+工序作业单卷作业时长*（计划加工卷数-已取消卷数）
+//                        newDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue() * splitQty)));
+//                    }
+//                    newDo.setStartingroll(0);
+//                    newDo.setReportroll(0);
+//                    newDo.setCheckoutroll(0);
+//                    newDo.setUnfinishroll(splitQty);
+//                    /**
+//                     * 新增需求：已借调卷数=0，已取消卷数=0，输入不合格卷数=0，输入已取消卷数=0，已取消卷数合计=0,剩余待开工卷数=计划加工卷数,剩余待报工卷数=计划加工卷数
+//                     * 如果原作业有多余的待加工料卷批次号，则待加工料卷批次号=原作业明细的多余的待加工料卷批次号
+//                     */
+//                    newDo.setSecondroll(0);
+//                    newDo.setCancelrollno(0);
+//                    newDo.setInputunqualifiednum(0);
+//                    newDo.setInputunqualifiedroll(0);
+//                    newDo.setCancelroll(0);
+//                    newDo.setLeavewaitworkroll(splitQty);
+//                    newDo.setLeavewaitjobroll(splitQty);
+//                    if (ObjectUtil.isNotEmpty(newBachMaterProcess)) {
+//                        newDo.setBachmaterialprocess(String.join(",", newBachMaterProcess));
+//                    }
+//                    newDo.setWorkstatus(JOBSTATUS_TO_BE_START);
+//                    newDo.setClosestatus(UNFINISHED);
+//                    newDo.setActualstartdate(null);
+//                    newDo.setWaitreportid(null);
+//                    newDo.setReportbatchnumber(null);
+//                    newDo.setCreatedate(new Date());
+//                    newDo.setModifydate(new Date());
+//                    affectedIdList.add(newDo.getId());
+//                    this.save(newDo);
 //                    // 增加受影响的工序作业信息
-//                    affectedIdList.addAll(checkProcessingTimeConflict(oldDo,
-//                            currentProcessEquDo.getPlanstartdate(), currentProcessEquDo.getPlanenddate(),
-//                            oldDo.getProcessdeviceid(), currentProcessOperationDo.getProcessway(),new ArrayList<>()));
-                    /**************************拆分逻辑处理***********************************/
-                    newDo.setId(SecurityUtil.getUUID());
-                    newDo.setPlanprocessrall(splitQty);
-                    newDo.setCancelroll(0);
-                    if (data.getPlanStartTime() != null) {
-                        newDo.setPlanstartdate(data.getPlanStartTime());
-                    } else {
-                        newDo.setPlanstartdate(currentProcessOperationDo.getPlanstartdate());
-                    }
-                    if (PROCESS_WAY_MERGE.equals(currentProcessOperationDo.getProcessway())) {
-                        // 如果工序作业的加工方式是合并加工，则计划完工时间=计划开工时间+工序作业单卷作业时长
-                        newDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue())));
-                    } else {
-                        // 如果工序作业的加工方式不是合并加工，则计划完工时间=计划开工时间+工序作业单卷作业时长*（计划加工卷数-已取消卷数）
-                        newDo.setPlanenddate(new Date(newDo.getPlanstartdate().getTime() + TimeUnit.MINUTES.toMillis(currentProcessOperationDo.getOnceprocessmin().longValue() * splitQty)));
-                    }
-                    newDo.setStartingroll(0);
-                    newDo.setReportroll(0);
-                    newDo.setCheckoutroll(0);
-                    newDo.setUnfinishroll(splitQty);
-                    /**
-                     * 新增需求：已借调卷数=0，已取消卷数=0，输入不合格卷数=0，输入已取消卷数=0，已取消卷数合计=0,剩余待开工卷数=计划加工卷数,剩余待报工卷数=计划加工卷数
-                     * 如果原作业有多余的待加工料卷批次号，则待加工料卷批次号=原作业明细的多余的待加工料卷批次号
-                     */
-                    newDo.setSecondroll(0);
-                    newDo.setCancelrollno(0);
-                    newDo.setInputunqualifiednum(0);
-                    newDo.setInputunqualifiedroll(0);
-                    newDo.setCancelroll(0);
-                    newDo.setLeavewaitworkroll(splitQty);
-                    newDo.setLeavewaitjobroll(splitQty);
-                    if (ObjectUtil.isNotEmpty(newBachMaterProcess)) {
-                        newDo.setBachmaterialprocess(String.join(",", newBachMaterProcess));
-                    }
-                    newDo.setWorkstatus(JOBSTATUS_TO_BE_START);
-                    newDo.setClosestatus(UNFINISHED);
-                    newDo.setActualstartdate(null);
-                    newDo.setWaitreportid(null);
-                    newDo.setReportbatchnumber(null);
-                    newDo.setCreatedate(new Date());
-                    newDo.setModifydate(new Date());
-                    affectedIdList.add(newDo.getId());
-                    this.save(newDo);
-                    // 增加受影响的工序作业信息
-                    affectedIdList.addAll(checkProcessingTimeConflict(newDo, newDo.getPlanstartdate(),
-                            newDo.getPlanenddate(), newDo.getProcessdeviceid(),
-                            currentProcessOperationDo.getProcessway(), new ArrayList<>()));
-                    newDo = this.getById(newDo.getId());
-                    newDataList.add(newDo);
+//                    affectedIdList.addAll(checkProcessingTimeConflict(newDo, newDo.getPlanstartdate(),
+//                            newDo.getPlanenddate(), newDo.getProcessdeviceid(),
+//                            currentProcessOperationDo.getProcessway(), new ArrayList<>()));
+//                    newDo = this.getById(newDo.getId());
+//                    newDataList.add(newDo);
                 }
             });
 //            this.saveOrUpdateBatch(newDataList);
-            newDataList.forEach(newDo -> {
-                // 判断是否存在设备不可用
-                inspectionEquipmentIsAvailable(newDo, newDo.getProcessdeviceid()
-                        , newDo.getPlanstartdate(), newDo.getPlanenddate(),
-                        affectedIdList);
-            });
+//            newDataList.forEach(newDo -> {
+//                // 判断是否存在设备不可用
+//                inspectionEquipmentIsAvailable(newDo, newDo.getProcessdeviceid()
+//                        , newDo.getPlanstartdate(), newDo.getPlanenddate(),
+//                        affectedIdList);
+//            });
             List<String> aboutIds = affectedIdList.stream().distinct().collect(Collectors.toList());
             apsProcessOperationDos.forEach(data -> {
                 // 更新坯料交货期
                 aboutIds.addAll(apsBlankOrderService.updateBlankDeliveryDate(null, data.getBlankid()));
             });
-            // 将工序作业明细ID 加入到上一个工序作业信息的中
-            Map<String, List<ApsProcessOperationProcessEquDo>> collect = newDataList.stream().collect(Collectors.groupingBy(ApsProcessOperationProcessEquDo::getPreviousprocessesids));
-            collect.forEach((k, v) -> {
-                List<String> collect1 = v.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
-                ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo = previousApsProcessOperationProcessEquDos.stream()
-                        .filter(info -> k.equals(info.getId()))
-                        .findFirst()
-                        .orElse(null);
-                this.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
-                        .eq(ApsProcessOperationProcessEquDo::getId, k)
-                        .set(ApsProcessOperationProcessEquDo::getNextprocessesids, strAppendListConvertStr(apsProcessOperationProcessEquDo.getNextprocessesids(), collect1)));
-            });
+//            // 将工序作业明细ID 加入到上一个工序作业信息的中
+//            Map<String, List<ApsProcessOperationProcessEquDo>> collect = newDataList.stream().collect(Collectors.groupingBy(ApsProcessOperationProcessEquDo::getPreviousprocessesids));
+//            collect.forEach((k, v) -> {
+//                List<String> collect1 = v.stream().map(ApsProcessOperationProcessEquDo::getId).collect(Collectors.toList());
+//                ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo = previousApsProcessOperationProcessEquDos.stream()
+//                        .filter(info -> k.equals(info.getId()))
+//                        .findFirst()
+//                        .orElse(null);
+//                this.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
+//                        .eq(ApsProcessOperationProcessEquDo::getId, k)
+//                        .set(ApsProcessOperationProcessEquDo::getNextprocessesids, strAppendListConvertStr(apsProcessOperationProcessEquDo.getNextprocessesids(), collect1)));
+//            });
             return R.ok(this.ganttService.getListById(aboutIds));
         } finally {
             for (String equId : ids) {

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

@@ -2,6 +2,7 @@ package com.rongwei.bsserver.controller;
 
 
 import com.rongwei.bscommon.sys.service.ApsProcessOperationProcessEquService;
+import com.rongwei.bscommon.sys.service.GanttService;
 import com.rongwei.bsentity.vo.*;
 import com.rongwei.rwcommon.base.R;
 import lombok.extern.slf4j.Slf4j;
@@ -28,6 +29,8 @@ import java.util.List;
 public class ApsProcessOperationProcessEquController {
     @Autowired
     private ApsProcessOperationProcessEquService apsProcessOperationProcessEquService;
+    @Autowired
+    private GanttService ganttService;
 
     /**
      * 通用更新订单、坯料计划、工序作业的 生产状态 方法（根据传入的指定项目的ID，传入多个ID，根据最小粒度的ID）
@@ -54,7 +57,7 @@ public class ApsProcessOperationProcessEquController {
     @PostMapping("/changing-wires")
     public R changingWires(@RequestBody @Validated List<ChangingWiresVo> changingWiresVos) {
         log.info("开始进行换线作业");
-        return apsProcessOperationProcessEquService.changingWires(changingWiresVos);
+        return R.ok(ganttService.getListById(apsProcessOperationProcessEquService.changingWires(changingWiresVos)));
     }
     /**
      * 换线作业2，区分甘特图和车间作业跟踪
@@ -65,7 +68,7 @@ public class ApsProcessOperationProcessEquController {
     @PostMapping("/changing-wires2")
     public R changingWires2(@RequestBody @Validated List<ChangingWiresVo> changingWiresVos) {
         log.info("开始进行换线作业2");
-        return apsProcessOperationProcessEquService.changingWires(changingWiresVos);
+        return R.ok(ganttService.getListById(apsProcessOperationProcessEquService.changingWires(changingWiresVos)));
     }
     /**
      * 排单