feature 增加按照卷数拆分的接口

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

@@ -2,10 +2,7 @@ package com.rongwei.bscommon.sys.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.rongwei.bsentity.domain.ApsProcessOperationProcessEquDo;
-import com.rongwei.bsentity.vo.ChangeStartTimeVo;
-import com.rongwei.bsentity.vo.ChangingWiresVo;
-import com.rongwei.bsentity.vo.CommonUpdateProductionStatusReq;
-import com.rongwei.bsentity.vo.JobDetailsVo;
+import com.rongwei.bsentity.vo.*;
 import com.rongwei.rwcommon.base.R;
 
 import java.util.List;
@@ -27,4 +24,6 @@ public interface ApsProcessOperationProcessEquService extends IService<ApsProces
 
     R updateDetails(JobDetailsVo jobDetailsVo);
 
+    R splitDetails(List<ProcessOperationDetailSplitVo> processOperationDetailSplitVos);
+
 }

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

@@ -34,6 +34,7 @@ import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 
 import static com.rongwei.bscommon.sys.utils.ApsUtils.addNewConflictsDesc;
+import static com.rongwei.safecommon.utils.SaveConstans.CloseStatus.UNFINISHED;
 import static com.rongwei.safecommon.utils.SaveConstans.ForcedConflictsDescription.EQUIPMENT_RUN_TIME;
 import static com.rongwei.safecommon.utils.SaveConstans.ForcedConflictsDescription.EQ_TIME_CROSS;
 import static com.rongwei.safecommon.utils.SaveConstans.JobStatus.*;
@@ -109,7 +110,6 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
 
     }
 
-
     @Override
     @Transactional
     public R updateProductionStatus(CommonUpdateProductionStatusReq request) {
@@ -395,7 +395,7 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
 
                     newProcessEqu.setUnfinishroll(newProcessEqu.getPlanprocessrall());
                     newProcessEqu.setWorkstatus(JOBSTATUS_TO_BE_START);
-                    newProcessEqu.setClosestatus(SaveConstans.CloseStatus.UNFINISHED);
+                    newProcessEqu.setClosestatus(UNFINISHED);
                     affectedIdList.add(newProcessEqu.getId());
                     updateConflictVo.setApsProcessOperationProcessEquDo(newProcessEqu);
                     checkConflictVos.add(new CheckConflictVo(processEqus.getId(), newProcessEqu.getProcessdeviceid(),
@@ -404,10 +404,10 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
                     updateConflictVoList.add(updateConflictVo);
                     // 获取上一个工序作业明细ID
                     String previousprocessesids = newProcessEqu.getPreviousprocessesids();
-                    if(StringUtils.isNotBlank(previousprocessesids)){
+                    if (StringUtils.isNotBlank(previousprocessesids)) {
                         ApsProcessOperationProcessEquDo previousProcessEqu = this.getById(previousprocessesids);
                         this.update(new LambdaUpdateWrapper<ApsProcessOperationProcessEquDo>()
-                                .eq(ApsProcessOperationProcessEquDo::getId,previousprocessesids)
+                                .eq(ApsProcessOperationProcessEquDo::getId, previousprocessesids)
                                 .set(ApsProcessOperationProcessEquDo::getNextprocessesids,
                                         strAppendListConvertStr(previousProcessEqu.getNextprocessesids(), Arrays.asList(previousprocessesids))));
                     }
@@ -591,7 +591,6 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
         return R.ok(this.ganttService.getListById(affectedIdList.stream().distinct().collect(Collectors.toList())));
     }
 
-
     /**
      * 更新工序作业明细
      *
@@ -668,6 +667,229 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
         return R.ok(this.ganttService.getListById(affectedIdList));
     }
 
+    /**
+     * 工序作业明细拆分
+     *
+     * @param processOperationDetailSplitVos
+     * @return
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public R splitDetails(List<ProcessOperationDetailSplitVo> processOperationDetailSplitVos) {
+        log.debug("开始执行工序作业明细指定卷数拆分逻辑");
+//        ApsUtils.checkScheduling(null);
+        boolean qtyError = processOperationDetailSplitVos.stream().anyMatch(data -> data.getSplitQty() == 0);
+        if (qtyError) {
+            log.error("存在拆分数量为0的工序作业明细数据");
+            throw new CustomException("存在拆分数量为0的数据");
+        }
+        List<String> ids = processOperationDetailSplitVos.stream().map(ProcessOperationDetailSplitVo::getId).filter(StringUtils::isNotBlank).collect(Collectors.toList());
+        if (ids.isEmpty()) {
+            log.error("无法找到对应工序作业明细");
+            throw new CustomException("参数异常,工序作业明细ID为空");
+        }
+        // 所有的工序作业明细
+        List<ApsProcessOperationProcessEquDo> apsProcessOperationProcessEquDos = (List<ApsProcessOperationProcessEquDo>) this.listByIds(ids);
+        // 前一个工序作业明细Id
+        List<String> previousIds = apsProcessOperationProcessEquDos.stream()
+                .map(ApsProcessOperationProcessEquDo::getPreviousprocessesids)
+                .distinct()
+                .filter(StringUtils::isNotBlank)
+                .collect(Collectors.toList());
+        if(previousIds.isEmpty()){
+            log.error("无法找到当前工序作业明细的上一个工序作业明细信息");
+            throw new CustomException("无法找到前道工序作业明细信息");
+        }
+        List<ApsProcessOperationProcessEquDo> previousApsProcessOperationProcessEquDos = this.getBaseMapper().selectBatchIds(previousIds) ;
+        // 获取工序作业信息
+        List<String> processId = apsProcessOperationProcessEquDos.stream()
+                .map(ApsProcessOperationProcessEquDo::getProcessid)
+                .distinct()
+                .filter(StringUtils::isNotBlank)
+                .collect(Collectors.toList());
+        if (processId.isEmpty()) {
+            log.error("无法根据工序作业明细获取工序作业信息");
+            throw new CustomException("无法获取到工序作业信息");
+        }
+        List<ApsProcessOperationDo> apsProcessOperationDos = (List<ApsProcessOperationDo>) apsProcessOperationService.listByIds(processId);
+        // 合并加工
+        boolean mergeProcessing = apsProcessOperationDos.stream().anyMatch(data -> !PROCESS_WAY_MERGE.equals(data.getProcessway()));
+        if (mergeProcessing) {
+            log.error("存在非合并加工的工序作业无法拆分");
+            throw new CustomException("存在非合并加工的工序作业无法拆分");
+        }
+        List<String> affectedIdList = new ArrayList<>();
+        List<ApsProcessOperationProcessEquDo> newDataList = new ArrayList<>();
+        processOperationDetailSplitVos.forEach(data -> {
+            affectedIdList.addAll(data.getReturnAboutIds());
+            int splitQty = data.getSplitQty();
+            ApsProcessOperationProcessEquDo currentProcessEquDo = apsProcessOperationProcessEquDos.stream()
+                    .filter(equs -> equs.getId().equals(data.getId()))
+                    .findFirst()
+                    .orElse(null);
+            if (currentProcessEquDo == null) {
+                log.error("无法根据id:{}获取到工序作业明细", data.getId());
+                throw new CustomException("无法获取到工序作业明细！请联系系统管理员");
+            }
+            // 当前的工序作业信息
+            ApsProcessOperationDo currentProcessOperationDo = apsProcessOperationDos.stream()
+                    .filter(process -> process.getId().equals(currentProcessEquDo.getProcessid()))
+                    .findFirst()
+                    .orElse(null);
+            if (currentProcessOperationDo == null) {
+                log.error("无法获取工序作业明细:{}所对应的工序作业信息", currentProcessOperationDo.getId());
+                throw new CustomException("找不到对应工序作业信息！请联系系统管理员");
+            }
+            // 剩余待加工卷数
+            int unFinishRoll = currentProcessEquDo.getPlanprocessrall() - currentProcessEquDo.getStartingroll() - currentProcessEquDo.getCancelroll();
+            if (unFinishRoll <= 0) {
+                log.error("当前暂无可拆分的卷数信息");
+                throw new RuntimeException("该作业已全部开工，不能拆分");
+            }
+            if (splitQty > unFinishRoll) {
+                log.error("拆分数量:{}大于待加工卷数:{}", splitQty, unFinishRoll);
+                throw new RuntimeException("拆分数量大于待加工卷数，不能拆分");
+            }
+            ApsProcessOperationProcessEquDo newDo = new ApsProcessOperationProcessEquDo();
+            BeanUtils.copyProperties(currentProcessEquDo, newDo);
+            if (StringUtils.isNotBlank(data.getEquName())) {
+                newDo.setProcessdevice(currentProcessEquDo.getProcessdeviceid());
+            } else {
+                newDo.setProcessdevice(data.getEquName());
+            }
+
+            if (StringUtils.isNotBlank(data.getEquId())) {
+                newDo.setProcessdeviceid(data.getEquId());
+            } else {
+                newDo.setProcessdeviceid(currentProcessEquDo.getProcessdeviceid());
+            }
+
+            if (StringUtils.isNotBlank(data.getWorkshopName())) {
+                newDo.setProcessworkshop(data.getWorkshopName());
+            } else {
+                newDo.setProcessworkshop(currentProcessEquDo.getProcessworkshop());
+            }
+
+            if (StringUtils.isNotBlank(data.getWorkshopId())) {
+                newDo.setProcessworkshopid(data.getWorkshopId());
+            } else {
+                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(new Date());
+                newDataList.add(newDo);
+                this.updateById(newDo);
+                // 增加受影响的工序作业信息
+                affectedIdList.addAll(checkProcessingTimeConflict(newDo, currentProcessEquDo.getPlanstartdate(),
+                        currentProcessEquDo.getPlanenddate(), currentProcessEquDo.getProcessdeviceid(),
+                        currentProcessOperationDo.getProcessway()));
+            } else {
+                /**************************拆分逻辑处理***********************************/
+                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);
+                newDo.setWorkstatus(JOBSTATUS_TO_BE_START);
+                newDo.setClosestatus(UNFINISHED);
+                newDo.setActualstartdate(null);
+                newDo.setWaitreportid(null);
+                newDo.setBachmaterialprocess(null);
+                newDo.setCreatedate(new Date());
+                newDo.setModifydate(new Date());
+                // 增加受影响的工序作业信息
+                affectedIdList.addAll(checkProcessingTimeConflict(newDo, newDo.getPlanstartdate(),
+                        newDo.getPlanenddate(), newDo.getProcessdeviceid(),
+                        currentProcessOperationDo.getProcessway()));
+                this.save(newDo);
+                newDataList.add(newDo);
+                /**************************原数据逻辑处理***********************************/
+                ApsProcessOperationProcessEquDo oldDo = new ApsProcessOperationProcessEquDo();
+                oldDo.setId(currentProcessEquDo.getId());
+                oldDo.setPlanprocessrall(unFinishRoll - 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);
+                }
+                oldDo.setModifydate(new Date());
+                this.updateById(oldDo);
+                // 增加受影响的工序作业信息
+                affectedIdList.addAll(checkProcessingTimeConflict(oldDo,
+                        currentProcessEquDo.getPlanstartdate(), currentProcessEquDo.getPlanenddate(),
+                        oldDo.getProcessdeviceid(), currentProcessOperationDo.getProcessway()));
+            }
+        });
+        this.saveOrUpdateBatch(newDataList);
+        newDataList.forEach(newDo -> {
+            // 判断是否存在设备不可用
+            inspectionEquipmentIsAvailable(newDo, newDo.getProcessdeviceid()
+                    , newDo.getPlanstartdate(), newDo.getPlanenddate());
+        });
+        apsProcessOperationDos.forEach(data -> {
+            // 更新坯料交货期
+            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)));
+        });
+        return R.ok(this.ganttService.getListById(affectedIdList));
+    }
+
     public void updateBlank(String processOperationId) {
         //查询此工序的所属订单ID
         String orderId = this.baseMapper.selectOrderIdByProcessOperationId(processOperationId);
@@ -847,16 +1069,16 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
 //                        StringUtils.isBlank(info.getSoftconflictdes()) ?
 //                        LOCKMARK_N : LOCKMARK_Y);
 //            }
-            if(PROCESS_WAY_MERGE.equals(processway)){
+            if (PROCESS_WAY_MERGE.equals(processway)) {
                 if (info.getPlanstartdate().equals(newPlanStartDate)) {
                     info.setConflictdes(removeConflictsDesc(info.getConflictdes(), removeConflictsDesc));
                     info.setHasconflict(StringUtils.isBlank(info.getConflictdes()) &&
                             StringUtils.isBlank(info.getSoftconflictdes()) ?
                             LOCKMARK_N : LOCKMARK_Y);
                 }
-            }else{
-                if(newPlanStartDate.compareTo(info.getPlanenddate())>0 ||
-                        newOldEndDate.compareTo(info.getPlanstartdate())<0 ){
+            } else {
+                if (newPlanStartDate.compareTo(info.getPlanenddate()) > 0 ||
+                        newOldEndDate.compareTo(info.getPlanstartdate()) < 0) {
                     info.setConflictdes(removeConflictsDesc(info.getConflictdes(), removeConflictsDesc));
                     info.setHasconflict(StringUtils.isBlank(info.getConflictdes()) &&
                             StringUtils.isBlank(info.getSoftconflictdes()) ?
@@ -916,7 +1138,8 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
      * @param startDate
      * @param endDate
      */
-    public void inspectionEquipmentIsAvailable(ApsProcessOperationProcessEquDo processEquDo, String equId, Date startDate, Date endDate) {
+    public void inspectionEquipmentIsAvailable(ApsProcessOperationProcessEquDo processEquDo,
+                                               String equId, Date startDate, Date endDate) {
         // 查询当前设备当前时间段是否存在不可用设备
         List<ApsEquipmentCalendarDo> list = apsEquipmentCalendarService.list(new LambdaQueryWrapper<ApsEquipmentCalendarDo>()
                 .eq(ApsEquipmentCalendarDo::getProcessdeviceid, equId)
@@ -948,8 +1171,8 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
      * @return
      */
     public List<String> checkProcessingTimeConflict(ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo,
-                                                    Date oldPlanstartdate, Date oldPlanenddate, String oldEquId,
-                                                    String currentProcessWay) {
+                                                    Date oldPlanstartdate, Date oldPlanenddate,
+                                                    String oldEquId, String currentProcessWay) {
         // 受影响的工序作业Id
         List<String> affectedIdList = new ArrayList<>();
 
@@ -996,6 +1219,7 @@ public class ApsProcessOperationProcessEquServiceImpl extends ServiceImpl<ApsPro
         }
         return affectedIdList;
     }
+
     public String strAppendListConvertStr(String oldValue, List<String> newValues) {
         if (org.apache.commons.lang.StringUtils.isBlank(oldValue) && (newValues == null || newValues.isEmpty())) {
             return "";

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

@@ -0,0 +1,52 @@
+package com.rongwei.bsentity.vo;
+
+import lombok.Data;
+
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * ProcessOperationDetailsVo class
+ *
+ * @author XH
+ * @date 2024/09/11
+ */
+@Data
+public class ProcessOperationDetailSplitVo {
+    /**
+     * 工序作业明细ID
+     */
+    @NotBlank(message = "工序作业必填")
+    private String id;
+    /**
+     * 设备ID
+     */
+    private String equId;
+    /**
+     * 设备名称
+     */
+    private String equName;
+    /**
+     * 车间ID
+     */
+    private String workshopId;
+    /**
+     * 车间名称
+     */
+    private String workshopName;
+    /**
+     * 拆分出的数量
+     */
+    private int splitQty = 0;
+    /**
+     * 计划开工时间
+     */
+    private Date planStartTime;
+    /**
+     * 需要返回的相关IDs
+     */
+    private List<String> returnAboutIds = new ArrayList<>();
+}

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

@@ -2,10 +2,7 @@ package com.rongwei.bsserver.controller;
 
 
 import com.rongwei.bscommon.sys.service.ApsProcessOperationProcessEquService;
-import com.rongwei.bsentity.vo.ChangeStartTimeVo;
-import com.rongwei.bsentity.vo.ChangingWiresVo;
-import com.rongwei.bsentity.vo.CommonUpdateProductionStatusReq;
-import com.rongwei.bsentity.vo.JobDetailsVo;
+import com.rongwei.bsentity.vo.*;
 import com.rongwei.rwcommon.base.R;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -50,13 +47,14 @@ public class ApsProcessOperationProcessEquController {
 
     /**
      * 换线作业
+     *
      * @param changingWiresVos
      * @return
      */
     @PostMapping("/changing-wires")
-    public R changingWires(@RequestBody @Validated List<ChangingWiresVo> changingWiresVos){
+    public R changingWires(@RequestBody @Validated List<ChangingWiresVo> changingWiresVos) {
         log.info("开始进行换线作业");
-        return  apsProcessOperationProcessEquService.changingWires(changingWiresVos);
+        return apsProcessOperationProcessEquService.changingWires(changingWiresVos);
     }
 
     /**
@@ -65,30 +63,43 @@ public class ApsProcessOperationProcessEquController {
      * @return
      */
     @PostMapping("/optional/equipment")
-    public R getOptionalEquipment(@RequestBody List<String> operationJobDetailsId){
+    public R getOptionalEquipment(@RequestBody List<String> operationJobDetailsId) {
         log.info("换线获取可选设备");
-        return  apsProcessOperationProcessEquService.getOptionalEquipment(operationJobDetailsId);
+        return apsProcessOperationProcessEquService.getOptionalEquipment(operationJobDetailsId);
     }
 
     /**
      * 工序作业修改开始时间
+     *
      * @param changeStartTimeVo
      * @return
      */
     @PostMapping("/change/start-time")
     public R changeStartTime(@RequestBody @Validated List<ChangeStartTimeVo> changeStartTimeVo) {
         log.info("开修改工序作业开工时间");
-        return  apsProcessOperationProcessEquService.changeStartTime(changeStartTimeVo);
+        return apsProcessOperationProcessEquService.changeStartTime(changeStartTimeVo);
     }
 
     /**
      * 修改作业详情
+     *
      * @return
      */
     @PostMapping("/update")
-    public  R updateDetails(@RequestBody JobDetailsVo jobDetailsVo ){
+    public R updateDetails(@RequestBody JobDetailsVo jobDetailsVo) {
         log.info("开修改作业详情");
-        return  apsProcessOperationProcessEquService.updateDetails(jobDetailsVo);
+        return apsProcessOperationProcessEquService.updateDetails(jobDetailsVo);
+    }
+
+    /**
+     * 拆分工序作业明细
+     *
+     * @return
+     */
+    @PostMapping("/split")
+    public R splitDetails(@RequestBody List<ProcessOperationDetailSplitVo> processOperationDetailSplitVos) {
+        log.info("开修改作业详情");
+        return apsProcessOperationProcessEquService.splitDetails(processOperationDetailSplitVos);
     }
 }