feature 增加常量

bs-common/src/main/java/com/rongwei/safecommon/utils/SaveConstans.java

@@ -862,9 +862,15 @@ public class SaveConstans {
     /**
      * 在制品类型
      */
-    public static class  WorkInProgressType{
-        public static final String PASS="合格在制品";
-        public static final String REJECTS="不良在制品";
+    public static class WorkInProgressType {
+        /**
+         * 合格在制品
+         */
+        public static final String PASS = "合格在制品";
+        /**
+         * 不良在制品
+         */
+        public static final String REJECTS = "不良在制品";
 
     }
 

cx-aps/cx-aps-common/pom.xml

@@ -55,6 +55,11 @@
             <version>1.0-SNAPSHOT</version>
             <scope>compile</scope>
         </dependency>
+        <dependency>
+            <groupId>com.rongwei</groupId>
+            <artifactId>wf-common</artifactId>
+            <version>1.1-SNAPSHOT</version>
+        </dependency>
 
         <dependency>
             <groupId>com.google.zxing</groupId>

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

@@ -2,28 +2,37 @@ package com.rongwei.bscommon.sys.service.impl;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
-import com.baomidou.mybatisplus.core.toolkit.Wrappers;
-import com.rongwei.bscommon.sys.dao.ApsBlankOrderDao;
-import com.rongwei.bscommon.sys.dao.ApsProcessOperationOutMaterDao;
+import com.rongwei.bscommon.sys.service.ApsBlankOrderService;
 import com.rongwei.bscommon.sys.service.ApsReportRecordsService;
 import com.rongwei.bscommon.sys.service.ReportCheckService;
 import com.rongwei.bsentity.domain.*;
+import com.rongwei.bsentity.vo.CancelProcessOperationVo;
 import com.rongwei.bsentity.vo.CommonUpdateProductionStatusReq;
-import com.rongwei.bsentity.vo.ProcessIdRelationVo;
 import com.rongwei.rwcommon.base.BaseDo;
 import com.rongwei.rwcommon.base.R;
+import com.rongwei.rwcommon.base.exception.CustomException;
+import com.rongwei.wfentity.sys.RunTaskDo;
+import com.rongwei.wfentity.sys.vo.RunTaskVo;
+import com.rongwei.wfserver.wfcommon.core.service.WorkFlowService;
+import com.rongwei.wfserver.wfcommon.sys.service.RunTaskService;
 import jodd.util.StringUtil;
 import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.*;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import static com.rongwei.safecommon.utils.SaveConstans.JobStatus.JOBSTATUS_TO_BE_END;
 import static com.rongwei.safecommon.utils.SaveConstans.WorkInProgressStatus.*;
+import static com.rongwei.safecommon.utils.SaveConstans.WorkInProgressType.PASS;
+import static com.rongwei.safecommon.utils.SaveConstans.WorkInProgressType.REJECTS;
 
 /**
  * ReportCheckServiceImpl class
@@ -40,7 +49,6 @@ public class ReportCheckServiceImpl implements ReportCheckService {
     public static final String PENDING_PLAN_REVIEW = "待计划评审";
     public static final String VERIFIED = "已检验";
     public static final String COMPLETED = "已完工";
-    public static final String REJECTS = "不良在制品";
     public static final String SEMIFINISHED_PRODUCTS = "半成品备料";
     public static final String WORK_IN_PROCESS = "在制品";
     private final Logger log = LoggerFactory.getLogger(this.getClass().getName());
@@ -51,8 +59,6 @@ public class ReportCheckServiceImpl implements ReportCheckService {
     @Autowired
     private ApsProcessOperationServiceImpl apsProcessOperationService;
     @Autowired
-    private ApsBlankOrderDao apsBlankOrderDao;
-    @Autowired
     private ApsProductionOrderServiceImpl apsProductionOrderService;
     @Autowired
     private ApsWorkInProgressInventoryServiceImpl apsWorkInProgressInventoryService;
@@ -61,7 +67,11 @@ public class ReportCheckServiceImpl implements ReportCheckService {
     @Autowired
     private ApsProcessOperationProcessEquServiceImpl apsProcessOperationProcessEquService;
     @Autowired
-    private ApsProcessOperationOutMaterDao apsProcessOperationOutMaterDao;
+    private ApsBlankOrderService apsBlankOrderService;
+    @Autowired
+    private WorkFlowService workFlowService;
+    @Autowired
+    private RunTaskService runTaskService;
 
     /**
      * 保存检验结果后更新相关信息
@@ -83,205 +93,497 @@ public class ReportCheckServiceImpl implements ReportCheckService {
             log.error("无法根据ID：{}获取到报工记录", id);
             return R.error("无法获取到报工记录");
         }
-//        if (VERIFIED.equals(reportRecordsDo.getCheckstatus())) {
-//            log.error("当前报工记录已检验无法再次检验");
-//            return R.error("当前报工记录已检验无法再次检验");
-//        }
-        // 获取当前报工记录对应的工序作业记录
-        ApsProcessOperationProcessEquDo currentProcessOperationEqu = apsProcessOperationProcessEquService.getById(reportRecordsDo.getProcessequid());
-        if (currentProcessOperationEqu == null) {
-            log.error("无法找到当前报工记录对应的工序作业信息");
-            return R.error("无法找到当前报工记录对应的工序作业信息");
+        // 获取该工序生成的物料输出信息
+        List<ApsReportOutputDo> reportOutputDos = apsReportOutputService.list(new LambdaQueryWrapper<ApsReportOutputDo>()
+                .eq(ApsReportOutputDo::getMainid, id)
+                .eq(BaseDo::getDeleted, NO_DELETED));
+        if (reportOutputDos.isEmpty()) {
+            log.error("无法根据ID：{}获取到输出物料信息", id);
+            return R.error("无法获取到输出物料信息");
+        }
+        // 获取工序作业信息
+        String currentProcessOperationId = reportRecordsDo.getProcessoperationid();
+        if (StringUtils.isBlank(currentProcessOperationId)) {
+            log.error("当前报工记录:{}无法获取到对应的工序作业信息!", id);
+            return R.error("无法获取到工序作业信息,请联系系统管理员!");
         }
-        String processOperationEquId = currentProcessOperationEqu.getId();
         // 获取工序作业主表信息
         ApsProcessOperationDo currentProcessOperationMainDo = apsProcessOperationService.getOne(new LambdaQueryWrapper<ApsProcessOperationDo>()
-                .eq(ApsProcessOperationDo::getId, reportRecordsDo.getProcessoperationid()).eq(BaseDo::getDeleted, NO_DELETED));
+                .eq(ApsProcessOperationDo::getId, currentProcessOperationId)
+                .eq(BaseDo::getDeleted, NO_DELETED));
         if (currentProcessOperationMainDo == null) {
             log.error("无法根据ID：{}获取到工序作业信息", id);
-            return R.error("无法获取到工序作业信息");
+            return R.error("无法获取到工序作业信息,请联系系统管理员!");
         }
-        if (StringUtils.isBlank(currentProcessOperationMainDo.getBlankid())) {
-            log.error("无法根据工序获取到生产订单信息");
-            return R.error("无法获取到生产订单信息");
+        // 获取工序作业明细信息
+        ApsProcessOperationProcessEquDo currentProcessOperationEqu = apsProcessOperationProcessEquService.getById(reportRecordsDo.getProcessequid());
+        if (currentProcessOperationEqu == null) {
+            log.error("无法找到当前报工记录对应的工序作业信息");
+            return R.error("无法找到当前报工记录对应的工序作业信息");
         }
-        // 前道工序作业ID
-        String previousprocessid = currentProcessOperationMainDo.getPreviousprocessid();
         // 获取工序作业对应的输出物料信息
-        ApsProcessOperationOutMaterDo operationOutMaterDoList = apsProcessOperationOutMaterService.getOne(new LambdaQueryWrapper<ApsProcessOperationOutMaterDo>()
-                .eq(ApsProcessOperationOutMaterDo::getMainid, currentProcessOperationMainDo.getId())
-                .eq(BaseDo::getDeleted, NO_DELETED), false);
-        if (operationOutMaterDoList == null) {
-            log.error("无法根据工序作业ID:{}获取对应的输出物料信息", currentProcessOperationMainDo.getId());
+        List<ApsProcessOperationOutMaterDo> operationOutMaterDoList = apsProcessOperationOutMaterService.list(new LambdaQueryWrapper<ApsProcessOperationOutMaterDo>()
+                .eq(ApsProcessOperationOutMaterDo::getMainid, currentProcessOperationId)
+                .eq(BaseDo::getDeleted, NO_DELETED));
+        if (operationOutMaterDoList.isEmpty()) {
+            log.error("无法根据工序作业ID:{}获取对应的输出物料信息", currentProcessOperationId);
             return R.error("无法获取到对应的输出物料信息");
         }
-        // 获取该工序生成的物料输出信息
-        List<ApsReportOutputDo> reportOutputDos = apsReportOutputService.list(new LambdaQueryWrapper<ApsReportOutputDo>()
-//                .eq(ApsReportOutputDo::getCheckstatus,"待检验")
-                .eq(ApsReportOutputDo::getMainid, id)
-                .eq(BaseDo::getDeleted, NO_DELETED));
-        if (reportOutputDos.isEmpty()) {
-            log.error("无法根据ID：{}获取到输出物料信息", id);
-            return R.error("无法获取到输出物料信息");
+        // 工序作业明细ID
+        String processOperationEquId = currentProcessOperationEqu.getId();
+        // 前道工序作业ID
+        String previousprocessid = currentProcessOperationMainDo.getPreviousprocessid();
+        // 坯料计划ID
+        String blankId = currentProcessOperationMainDo.getBlankid();
+        if (StringUtils.isBlank(blankId)) {
+            log.error("无法根据工序获取到生产订单信息");
+            return R.error("无法获取到生产订单信息");
         }
-        //获取批量计划
-        ApsBlankOrderDo blankOrderDo = apsBlankOrderDao.selectById(currentProcessOperationMainDo.getBlankid());
+        // 获取坯料计划
+        ApsBlankOrderDo blankOrderDo = apsBlankOrderService.getBaseMapper().selectById(blankId);
         if (blankOrderDo == null) {
-            log.error("无法根据ID：{}找到对应的订单信息", currentProcessOperationMainDo.getBlankid());
-            return R.error("无法获取订单信息");
+            log.error("无法根据ID：{}找到对应的坯料计划信息", blankId);
+            return R.error("无法获取到坯料计划信息");
         }
-        if (StringUtils.isBlank(blankOrderDo.getProductionorderid())) {
+        // 获取订单记录
+        String productionOrderId = blankOrderDo.getProductionorderid();
+        if (StringUtils.isBlank(productionOrderId)) {
             log.error("坯料计划对应的订单ID为空");
             return R.error("无法通过坯料计划找到订单信息");
         }
         // 获取订单信息
-        ApsProductionOrderDo productionOrderDo = apsProductionOrderService.getById(blankOrderDo.getProductionorderid());
+        ApsProductionOrderDo productionOrderDo = apsProductionOrderService.getById(productionOrderId);
         if (productionOrderDo == null) {
-            log.error("无法根据ID:{},获取到订单信息", blankOrderDo.getProductionorderid());
+            log.error("无法根据ID:{},获取到订单信息", productionOrderId);
             return R.error("无法找到订单信息");
         }
-
-        // 获取检验不合格批次的数量
-        List<ApsReportOutputDo> unqualificationOutPutList = reportOutputDos.stream()
-                .filter(info -> NO.equals(info.getQualified()))
-                .collect(Collectors.toList());
-        // 检验合格的数量信息
-        List<ApsReportOutputDo> qualifiedOutPutList = reportOutputDos.stream()
-                .filter(info -> YES.equals(info.getQualified()))
-                .collect(Collectors.toList());
-        if (unqualificationOutPutList.isEmpty() && qualifiedOutPutList.isEmpty()) {
-            log.debug("暂无检验的数据");
-            return R.ok("暂无需要检验的数据");
-        }
-        // modify at [ 2024-06-28 11:44:04 ] by xh: 修改获取下一个工序作业的逻辑
-        /**
-         * 当前报工记录的输出物料ID和下一个工序作业的输入物料匹配 找到需要更新待加工料卷批次号的工序作业明细信息
-         */
-        String nextProcessId = currentProcessOperationMainDo.getNextprocessid();
-        // 输出物料ID
-        List<String> outputMaterialId = reportOutputDos.stream().map(ApsReportOutputDo::getOutputid).distinct().collect(Collectors.toList());
-        // 获取当前工序对应的后道工序信息
-        List<ApsProcessOperationDo> nextProcessOperationDos = new ArrayList<>();
-        // 当前工序作业的下一个工序作业ID
-        List<String> nextProcessIds = new ArrayList<>();
-        if (StringUtils.isNotBlank(nextProcessId)) {
-            // 找到可以更新待加工料卷批次号的工序作业信息
-            nextProcessOperationDos = apsProcessOperationService.list(new LambdaQueryWrapper<ApsProcessOperationDo>()
-                    .in(ApsProcessOperationDo::getId, Arrays.asList(nextProcessId.split(",")))
-                    .in(ApsProcessOperationDo::getPlaninputid, outputMaterialId)
-                    .eq(BaseDo::getDeleted, NO_DELETED));
-            nextProcessIds.addAll(nextProcessOperationDos.stream().map(ApsProcessOperationDo::getId).collect(Collectors.toList()));
-        }
-
         // 获取当前报工作业对应的在制品信息
         List<ApsWorkInProgressInventoryDo> apsWorkInProgressInventoryDos = apsWorkInProgressInventoryService.list(new LambdaQueryWrapper<ApsWorkInProgressInventoryDo>()
                 .eq(ApsWorkInProgressInventoryDo::getWorkreportrecordid, id).eq(BaseDo::getDeleted, NO_DELETED));
+        if (apsWorkInProgressInventoryDos.isEmpty()) {
+            log.error("无法获取到当前工序对应的在制品信息");
+            return R.error("无法获取在制品信息");
+        }
+        // 更新当前工序作业和作业明细的已检验卷数
+        currentProcessOperationMainDo.setCheckoutroll(currentProcessOperationMainDo.getCheckoutroll() + reportOutputDos.size());
+        apsProcessOperationService.save(currentProcessOperationMainDo);
+        currentProcessOperationEqu.setCheckoutroll(currentProcessOperationEqu.getCheckoutroll() + reportOutputDos.size());
+        currentProcessOperationEqu.setWorkstatus(JOBSTATUS_TO_BE_END);
+        currentProcessOperationEqu.setBachmaterialprocess("");
+        apsProcessOperationProcessEquService.save(currentProcessOperationEqu);
+        // 更新 更新该报工检验记录所有输出物料 以及待加工料卷批次号
+        updateProcessOutputMater(apsWorkInProgressInventoryDos, reportOutputDos, operationOutMaterDoList, currentProcessOperationMainDo);
+        // 更新报工输出物料 检验状态
+        apsReportOutputService.update(new LambdaUpdateWrapper<ApsReportOutputDo>()
+                .in(ApsReportOutputDo::getId, reportOutputDos.stream().map(ApsReportOutputDo::getId).collect(Collectors.toList()))
+                .set(ApsReportOutputDo::getCheckstatus, VERIFIED));
+        if (reportOutputDos.stream().anyMatch(info -> NO.equals(info.getQualified()))) {
+
+            // 更新坯料计划的作业状态
+            CommonUpdateProductionStatusReq req = new CommonUpdateProductionStatusReq();
+            req.setProcessOperationEquId(processOperationEquId);
+            req.setProcessOperationId(currentProcessOperationMainDo.getId());
+            req.setOrderId(productionOrderDo.getId());
+            req.setBlankId(blankId);
+            // 更新
+            apsProcessOperationProcessEquService.updateProductionStatus(req);
+            // 备份
+            apsProductionOrderService.saveHistoryInfo(productionOrderDo.getId());
+            // 坯料计划撤回发布
+            apsBlankOrderService.publishCancel(Arrays.asList(blankId));
+            productionOrderDo.setAuditstatus("待排程");
+            productionOrderDo.setChangedate(new Date());
+            productionOrderDo.setIsback("是");
+            productionOrderDo.setChangecomment("");
+            apsProductionOrderService.update(new LambdaUpdateWrapper<ApsProductionOrderDo>()
+                    .eq(ApsProductionOrderDo::getId, productionOrderDo.getId())
+                    .set(ApsProductionOrderDo::getChangedate, new Date())
+                    .set(ApsProductionOrderDo::getIsback, "是")
+                    .set(ApsProductionOrderDo::getChangecomment, null));
+
+            String processinstid = productionOrderDo.getProcessinstid();
+            RunTaskDo runTaskDo = runTaskService.getOne(new LambdaQueryWrapper<RunTaskDo>().eq(BaseDo::getDeleted, "0")
+                    .eq(RunTaskDo::getProcessinstid, processinstid)
+                    .in(RunTaskDo::getTaskstatus, "10", "20")
+                    .orderByDesc(BaseDo::getCreatedate), false);
+            RunTaskVo runTaskVo = new RunTaskVo();
+            BeanUtils.copyProperties(runTaskDo, runTaskVo);
+            runTaskVo.setProcessInstId(processinstid);
+            runTaskVo.setBusinesstableid(productionOrderDo.getId());
+            runTaskVo.setProcesstitle("订单评审");
+            runTaskVo.setProcessdefid("order_review");
+            runTaskVo.setAuditoperation("10");
+            runTaskVo.setTaskstatusname("待处理");
+            try {
+                workFlowService.runTask(runTaskVo, true);
+            } catch (Exception e) {
+                log.error("流程更新失败");
+                throw new RuntimeException(e);
+            }
+
+        }
+        ;
+        return R.ok();
+        /*******************************************以下为旧逻辑*****************************************/
+        // 获取检验不合格批次的数量
+//        List<ApsReportOutputDo> unqualificationOutPutList = reportOutputDos.stream()
+//                .filter(info -> NO.equals(info.getQualified()))
+//                .collect(Collectors.toList());
+//        // 检验合格的数量信息
+//        List<ApsReportOutputDo> qualifiedOutPutList = reportOutputDos.stream()
+//                .filter(info -> YES.equals(info.getQualified()))
+//                .collect(Collectors.toList());
+//        if (unqualificationOutPutList.isEmpty() && qualifiedOutPutList.isEmpty()) {
+//            log.debug("暂无检验的数据");
+//            return R.ok("暂无需要检验的数据");
+//        }
+//        // modify at [ 2024-06-28 11:44:04 ] by xh: 修改获取下一个工序作业的逻辑
+//        /**
+//         * 当前报工记录的输出物料ID和下一个工序作业的输入物料匹配 找到需要更新待加工料卷批次号的工序作业明细信息
+//         */
+//        String nextProcessId = currentProcessOperationMainDo.getNextprocessid();
+//        // 输出物料ID
+//        List<String> outputMaterialId = reportOutputDos.stream().map(ApsReportOutputDo::getOutputid).distinct().collect(Collectors.toList());
+//        // 获取当前工序对应的后道工序信息
+//        List<ApsProcessOperationDo> nextProcessOperationDos = new ArrayList<>();
+//        // 当前工序作业的下一个工序作业ID
+//        List<String> nextProcessIds = new ArrayList<>();
+//        if (StringUtils.isNotBlank(nextProcessId)) {
+//            // 找到可以更新待加工料卷批次号的工序作业信息
+//            nextProcessOperationDos = apsProcessOperationService.list(new LambdaQueryWrapper<ApsProcessOperationDo>()
+//                    .in(ApsProcessOperationDo::getId, Arrays.asList(nextProcessId.split(",")))
+//                    .in(ApsProcessOperationDo::getPlaninputid, outputMaterialId)
+//                    .eq(BaseDo::getDeleted, NO_DELETED));
+//            nextProcessIds.addAll(nextProcessOperationDos.stream().map(ApsProcessOperationDo::getId).collect(Collectors.toList()));
+//        }
+
 
         /******************************开始数据处理逻辑***************************************/
         // 更新合格不合格数量
-        int unqualifiedQuantity = unqualificationOutPutList.size();
+//        int unqualifiedQuantity = unqualificationOutPutList.size();
         // 更新合格数量
-        int qualifiedQuantity = qualifiedOutPutList.size();
+//        int qualifiedQuantity = qualifiedOutPutList.size();
         // 更新已检验卷数
-        int inspectQuantity = reportOutputDos.size();
+//        int inspectQuantity = reportOutputDos.size();
         /***********************更新 工序作业输出物料的  输出已检验卷数 输出不合格卷数 输出合格卷数****************************************/
-        Map<String, List<ApsReportOutputDo>> collect = reportOutputDos.stream().collect(Collectors.groupingBy(ApsReportOutputDo::getOutputid));
-        collect.forEach((k, v) -> {
-            // 不合格卷数
-            long unqualifiedQty = v.stream().filter(info -> NO.equals(info.getQualified())).count();
-            // 合格卷数
-            long passingQty = v.stream().filter(info -> YES.equals(info.getQualified())).count();
-            log.debug("更新输出物料ID:{},不合格卷数:{},合格卷数:{},已检验卷数:{}", k, unqualifiedQty, passingQty, v.size());
-            apsProcessOperationOutMaterDao.reportCheckUpdateAboutVolumesNum(k, unqualifiedQty, passingQty, v.size());
-        });
+//        Map<String, List<ApsReportOutputDo>> collect = reportOutputDos.stream().collect(Collectors.groupingBy(ApsReportOutputDo::getOutputid));
+//        collect.forEach((k, v) -> {
+//            // 不合格卷数
+//            long unqualifiedQty = v.stream().filter(info -> NO.equals(info.getQualified())).count();
+//            // 合格卷数
+//            long passingQty = v.stream().filter(info -> YES.equals(info.getQualified())).count();
+//            log.debug("更新输出物料ID:{},不合格卷数:{},合格卷数:{},已检验卷数:{}", k, unqualifiedQty, passingQty, v.size());
+//            apsProcessOperationOutMaterDao.reportCheckUpdateAboutVolumesNum(k, unqualifiedQty, passingQty, v.size());
+//        });
         /*********************** 工序作业输出物料 更新结束****************************************/
         // 订单信息
         //currentProductionOrderDoDispose(productionOrderDo, unqualificationOutPutList);
-        log.debug("开始更新在制品库存信息");
+//        log.debug("开始更新在制品库存信息");
         // 在制品
-        updateArticlesProcessData(unqualificationOutPutList, qualifiedOutPutList, reportRecordsDo,
-                apsWorkInProgressInventoryDos, nextProcessOperationDos, currentProcessOperationMainDo,
-                operationOutMaterDoList);
+//        updateArticlesProcessData(unqualificationOutPutList, qualifiedOutPutList, reportRecordsDo,
+//                apsWorkInProgressInventoryDos, nextProcessOperationDos, currentProcessOperationMainDo,
+//                operationOutMaterDoList);
         // 获取所有待加工的批次号信息
-        String toBeProcessedBatchNum = apsWorkInProgressInventoryDos.stream().filter(info -> WAIT_WORK.equals(info.getWorkinprocessstatus()))
-                .map(ApsWorkInProgressInventoryDo::getBatchnumber).collect(Collectors.joining(","));
+//        String toBeProcessedBatchNum = apsWorkInProgressInventoryDos.stream().filter(info -> WAIT_WORK.equals(info.getWorkinprocessstatus()))
+//                .map(ApsWorkInProgressInventoryDo::getBatchnumber).collect(Collectors.joining(","));
 //        if (!qualifiedOutPutList.isEmpty()) {
 //            // 获取后道工序的数据
 //            nextProcessDispose(nextProcessOperationDo, qualifiedOutPutList);
 //        }
 
         /**********************执行数据更新操作*************************/
-        if (!nextProcessIds.isEmpty() && StringUtils.isNotBlank(toBeProcessedBatchNum)) {
-            log.debug("开始增加后道工序作业:{}的待加工批次号：{}", nextProcessIds, toBeProcessedBatchNum);
-            //更新后续工序的待加工批次号信息
-            apsProcessOperationService.updateBachmaterialprocessByIds(nextProcessIds, toBeProcessedBatchNum,
-                    unqualifiedQuantity);
-            apsProcessOperationProcessEquService.updateBachmaterialprocessByIds(nextProcessIds, toBeProcessedBatchNum,
-                    currentProcessOperationEqu.getNextprocessesids());
-        }
+//        if (!nextProcessIds.isEmpty() && StringUtils.isNotBlank(toBeProcessedBatchNum)) {
+//            log.debug("开始增加后道工序作业:{}的待加工批次号：{}", nextProcessIds, toBeProcessedBatchNum);
+//            //更新后续工序的待加工批次号信息
+//            apsProcessOperationService.updateBachmaterialprocessByIds(nextProcessIds, toBeProcessedBatchNum,
+//                    unqualifiedQuantity);
+//            apsProcessOperationProcessEquService.updateBachmaterialprocessByIds(nextProcessIds, toBeProcessedBatchNum,
+//                    currentProcessOperationEqu.getNextprocessesids());
+//        }
         /***************************存在不合格批次信息时 更新更新报工记录对应订单的订单评审状态=待计划评审， 订单调整日期=今天*************************************/
-        if (unqualifiedQuantity > 0) {
-            LambdaUpdateWrapper<ApsProductionOrderDo> lambdaUpdateWrapper = Wrappers.lambdaUpdate();
-            lambdaUpdateWrapper.eq(ApsProductionOrderDo::getId,productionOrderDo.getId());
-            lambdaUpdateWrapper.set(ApsProductionOrderDo::getAuditstatus,"待提交");
-            lambdaUpdateWrapper.set(ApsProductionOrderDo::getChangedate,new Date());
-            apsProductionOrderService.update(lambdaUpdateWrapper);
-        }
+//        if (unqualifiedQuantity > 0) {
+//            LambdaUpdateWrapper<ApsProductionOrderDo> lambdaUpdateWrapper = Wrappers.lambdaUpdate();
+//            lambdaUpdateWrapper.eq(ApsProductionOrderDo::getId, productionOrderDo.getId());
+//            lambdaUpdateWrapper.set(ApsProductionOrderDo::getAuditstatus, "待提交");
+//            lambdaUpdateWrapper.set(ApsProductionOrderDo::getChangedate, new Date());
+//            apsProductionOrderService.update(lambdaUpdateWrapper);
+//        }
         /************************更新工序*******************************/
         // 更新工序主表的 已检验卷数，不合格卷数，合格卷数 , 完工状态,作业状态,生产状态
-        log.debug("开始更新工序作业");
-        apsProcessOperationService.updateAboutCheckBatchNum(currentProcessOperationMainDo.getId(), inspectQuantity,
-                qualifiedQuantity, unqualifiedQuantity);
-
-        log.debug("开始更新工序作业明细");
-        // 更新工序作业明细表的输出已检验卷数，不合格卷数，合格卷数完工状态,作业状态,生产状态
-        apsProcessOperationProcessEquService.updateAboutCheckBatchNum(processOperationEquId, inspectQuantity,
-                qualifiedQuantity, unqualifiedQuantity, previousprocessid, currentProcessOperationMainDo.getId());
+//        log.debug("开始更新工序作业");
+//        apsProcessOperationService.updateAboutCheckBatchNum(currentProcessOperationMainDo.getId(), inspectQuantity,
+//                qualifiedQuantity, unqualifiedQuantity);
+//
+//        log.debug("开始更新工序作业明细");
+//        // 更新工序作业明细表的输出已检验卷数，不合格卷数，合格卷数完工状态,作业状态,生产状态
+//        apsProcessOperationProcessEquService.updateAboutCheckBatchNum(processOperationEquId, inspectQuantity,
+//                qualifiedQuantity, unqualifiedQuantity, previousprocessid, currentProcessOperationMainDo.getId());
 
         /***************更新在制品信息****************************/
-        List<ApsWorkInProgressInventoryDo> updateList = apsWorkInProgressInventoryDos.stream()
-                .filter(info -> NO_DELETED.equals(info.getDeleted())).collect(Collectors.toList());
-        if (!updateList.isEmpty()) {
-            log.debug("更新在制品信息");
-            apsWorkInProgressInventoryService.updateWorkinprocessstatus(apsWorkInProgressInventoryDos);
-        }
+//        List<ApsWorkInProgressInventoryDo> updateList = apsWorkInProgressInventoryDos.stream()
+//                .filter(info -> NO_DELETED.equals(info.getDeleted())).collect(Collectors.toList());
+//        if (!updateList.isEmpty()) {
+//            log.debug("更新在制品信息");
+//            apsWorkInProgressInventoryService.updateWorkinprocessstatus(apsWorkInProgressInventoryDos);
+//        }
         /********************************更新当前报工记录的待检验批次号*************************************/
 //        apsReportRecordsService.update(new LambdaUpdateWrapper<ApsReportRecordsDo>().eq(ApsReportRecordsDo::getId, id)
 //                .set(ApsReportRecordsDo::getCheckstatus, VERIFIED)
 //                .set(ApsReportRecordsDo::getNeedcheckbatchnumber, ""));
         /******************************如果本次检验中存在不合格的批次 则更新后续所有工序作业的状态***************************/
-        if (unqualifiedQuantity != 0 && !nextProcessIds.isEmpty()) {
-            ApsProcessOperationDo apsProcessOperationDo = apsProcessOperationService.getById(currentProcessOperationMainDo.getId());
-            /**
-             *且当前工序作业已完成 则更新后续所有
-             *工序作业明细和工序作业的 相关信息
-             *(工序作业明细) 完工状态 实际完工时间
-             *(工序作业) 完工状态 作业状态 生产状态 实际完工时间
-             */
-            if (COMPLETED.equals(apsProcessOperationDo.getClosestatus())) {
-                // 获取当前工序
-                List<ProcessIdRelationVo> allNextProcessOperationById = apsProcessOperationService.getAllNextProcessOperationById(nextProcessIds);
-                apsProcessOperationProcessEquService.updateAboutStateByProcessId(allNextProcessOperationById);
+//        if (unqualifiedQuantity != 0 && !nextProcessIds.isEmpty()) {
+//            ApsProcessOperationDo apsProcessOperationDo = apsProcessOperationService.getById(currentProcessOperationMainDo.getId());
+//            /**
+//             *且当前工序作业已完成 则更新后续所有
+//             *工序作业明细和工序作业的 相关信息
+//             *(工序作业明细) 完工状态 实际完工时间
+//             *(工序作业) 完工状态 作业状态 生产状态 实际完工时间
+//             */
+//            if (COMPLETED.equals(apsProcessOperationDo.getClosestatus())) {
+//                // 获取当前工序
+//                List<ProcessIdRelationVo> allNextProcessOperationById = apsProcessOperationService.getAllNextProcessOperationById(nextProcessIds);
+//                apsProcessOperationProcessEquService.updateAboutStateByProcessId(allNextProcessOperationById);
+//            }
+//        }
+//        return R.ok();
+    }
+
+    /**
+     * 更新工序作业对应的输出物料信息
+     *
+     * @param apsWorkInProgressInventoryDos 在制品信息
+     * @param reportOutputDos               报工输出物料信息
+     * @param operationOutMaterDoList
+     */
+    public void updateProcessOutputMater(List<ApsWorkInProgressInventoryDo> apsWorkInProgressInventoryDos,
+                                         List<ApsReportOutputDo> reportOutputDos,
+                                         List<ApsProcessOperationOutMaterDo> operationOutMaterDoList,
+                                         ApsProcessOperationDo currentProcessOperationMainDo) {
+        // 需要作为待加工料卷批次号的批次号
+        Map<String, List<String>> toBeProcessedDataMap = new HashMap<>();
+
+        // 循环报工输出物料信息
+        reportOutputDos.forEach(reportOutputDo -> {
+            String outputid = reportOutputDo.getOutputid();
+            // 获取报工记录对应的输出物料
+            ApsProcessOperationOutMaterDo apsProcessOperationOutMaterDo = operationOutMaterDoList.stream()
+                    .filter(materDo -> materDo.getId().equals(outputid)).findFirst().orElse(null);
+            // 报工记录对应的
+            ApsWorkInProgressInventoryDo apsWorkInProgressInventoryDo = apsWorkInProgressInventoryDos.stream()
+                    .filter(inventory -> reportOutputDo.getOutputnumber().equals(inventory.getBatchnumber()))
+                    .findFirst().orElse(null);
+            if (apsProcessOperationOutMaterDo == null) {
+                log.error("报工记录:{}无法找到对应的输出物料信息", reportOutputDo.getId());
+                throw new CustomException("无法找到对应的输出物料信息");
+            }
+            if (apsWorkInProgressInventoryDo == null) {
+                log.error("报工记录:{}无法找到对应的在制品信息", reportOutputDo.getId());
+                throw new CustomException("无法找到对应的在制品信息");
+            }
+            // 已检验卷数加+1
+            apsProcessOperationOutMaterDo.setInspectrollnum(apsProcessOperationOutMaterDo.getInspectrollnum() + 1);
+            // 不合格
+            if (NO.equals(reportOutputDo.getQualified())) {
+                currentProcessOperationMainDo.setOutputunqualifiednum(currentProcessOperationMainDo.getOutputunqualifiednum() + 1);
+                apsProcessOperationOutMaterDo.setFailrollnum(apsProcessOperationOutMaterDo.getFailrollnum() + 1);
+                apsWorkInProgressInventoryDo.setWorkinprocessstatus(WAITING);
+                apsWorkInProgressInventoryDo.setWorkinprocesstype(REJECTS);
+            } else {
+                currentProcessOperationMainDo.setOutputqualifiednum(currentProcessOperationMainDo.getOutputqualifiednum() + 1);
+                apsProcessOperationOutMaterDo.setGoodrollnum(apsProcessOperationOutMaterDo.getGoodrollnum() + 1);
+                apsWorkInProgressInventoryDo.setWorkinprocesstype(PASS);
+                if (apsProcessOperationOutMaterDo.getProdleaveoutroll() > 0) {
+                    /**
+                     * 输出物料批次号对应在制品的在制品状态=待入库，
+                     * 成品输出卷数加1
+                     * 成品剩余需输出卷数减1
+                     */
+                    apsWorkInProgressInventoryDo.setWorkinprocessstatus(TO_BE_PUT_INTO_STORAGE);
+                    apsProcessOperationOutMaterDo.setProdoutroll(apsProcessOperationOutMaterDo.getProdoutroll() + 1);
+                    apsProcessOperationOutMaterDo.setProdleaveoutroll(apsProcessOperationOutMaterDo.getProdleaveoutroll() - 1);
+                } else if (apsProcessOperationOutMaterDo.getProdleaveoutroll() == 0 && apsProcessOperationOutMaterDo.getMoveleaveoutroll() > 0) {
+                    /**
+                     * 输出物料批次号对应在制品的在制品状态=待加工
+                     * 流转输出卷数加1
+                     * 流转剩余需输出卷数减1
+                     */
+                    apsWorkInProgressInventoryDo.setWorkinprocessstatus(WAIT_WORK);
+                    toBeProcessedDataMap.computeIfAbsent(outputid, k -> new ArrayList<>()).add(reportOutputDo.getOutputnumber());
+                    apsProcessOperationOutMaterDo.setMoveoutroll(apsProcessOperationOutMaterDo.getMoveoutroll() + 1);
+                    apsProcessOperationOutMaterDo.setMoveleaveoutroll(apsProcessOperationOutMaterDo.getMoveleaveoutroll() - 1);
+                } else {
+                    /**
+                     * 输出物料批次号对应在制品的在制品状态=备料工
+                     * 备料输出卷数加1
+                     * 备料剩余需输出卷数减1
+                     */
+                    apsWorkInProgressInventoryDo.setWorkinprocessstatus(WAITING);
+                    apsProcessOperationOutMaterDo.setStockoutroll(apsProcessOperationOutMaterDo.getStockoutroll() + 1);
+                    apsProcessOperationOutMaterDo.setStockleaveoutroll(apsProcessOperationOutMaterDo.getStockleaveoutroll() - 1);
+                }
             }
+        });
+
+        // 当前工序的下一个工序作业信息
+        String nextprocessid = currentProcessOperationMainDo.getNextprocessid();
+        // 当前工序存在下一个工序且 存在代加工的在制品信息时
+        if (!toBeProcessedDataMap.isEmpty() && StringUtils.isNotBlank(nextprocessid)) {
+            List<ApsProcessOperationDo> nextProcessOperations = apsProcessOperationService.list(new LambdaQueryWrapper<ApsProcessOperationDo>()
+                    .in(ApsProcessOperationDo::getId, Arrays.asList(nextprocessid.split(",")))
+                    .in(ApsProcessOperationDo::getPlaninputid, toBeProcessedDataMap.values())
+                    .eq(BaseDo::getDeleted, NO_DELETED));
+            List<ApsProcessOperationProcessEquDo> nextProcessOperationProcessEquDos = apsProcessOperationProcessEquService.list(new LambdaQueryWrapper<ApsProcessOperationProcessEquDo>()
+                    .in(ApsProcessOperationProcessEquDo::getProcessid, nextProcessOperations.stream().map(ApsProcessOperationDo::getId).collect(Collectors.toList()))
+                    .eq(BaseDo::getDeleted, NO_DELETED));
+
+            nextProcessOperations.forEach(data -> {
+                if (toBeProcessedDataMap.containsKey(data.getPlaninputid())) {
+                    String oldNums = data.getBachmaterialprocess();
+                    List<String> strings = toBeProcessedDataMap.get(data.getPlaninputid());
+                    data.setBachmaterialprocess(strAppendListConvertStr(oldNums, strings));
+                    // 更新剩余待报工卷数
+                    data.setLeavewaitjobroll(data.getLeavewaitjobroll() + strings.size());
+                    // 更新剩余待开工卷数
+                    data.setLeavewaitworkroll(data.getLeavewaitworkroll() + strings.size());
+                    nextProcessOperationProcessEquDos.forEach(equ -> {
+                        if (data.getId().equals(equ.getProcessid())) {
+                            data.setBachmaterialprocess(strAppendListConvertStr(data.getBachmaterialprocess(), strings));
+                        }
+                    });
+                }
+            });
+            // 保存工序作业明细信息
+            apsProcessOperationService.saveOrUpdateBatch(nextProcessOperations);
+            apsProcessOperationProcessEquService.saveOrUpdateBatch(nextProcessOperationProcessEquDos);
         }
-        // 更新坯料计划的作业状态
 
-        CommonUpdateProductionStatusReq req = new CommonUpdateProductionStatusReq();
-        req.setProcessOperationEquId(processOperationEquId);
-        req.setProcessOperationId(currentProcessOperationMainDo.getId());
-        req.setOrderId(productionOrderDo.getId());
-        req.setBlankId(blankOrderDo.getId());
-        // 更新
-        apsProcessOperationProcessEquService.updateProductionStatus(req);
-        apsReportOutputService.update(new LambdaUpdateWrapper<ApsReportOutputDo>()
-                .in(ApsReportOutputDo::getId, reportOutputDos.stream().map(ApsReportOutputDo::getId).collect(Collectors.toList()))
-                .set(ApsReportOutputDo::getCheckstatus, VERIFIED));
-        reportRecordsDo.setCheckstatus(VERIFIED);
-        apsReportRecordsService.update(new LambdaUpdateWrapper<ApsReportRecordsDo>()
-                .set(ApsReportRecordsDo::getCheckstatus, VERIFIED)
-                .set(ApsReportRecordsDo::getNeedcheckbatchnumber, null)
-                .eq(ApsReportRecordsDo::getId, id));
-        return R.ok();
+        // 保存在制品
+        apsWorkInProgressInventoryService.saveOrUpdateBatch(apsWorkInProgressInventoryDos);
+        // 保存工序作业输出物料
+        apsProcessOperationOutMaterService.saveOrUpdateBatch(operationOutMaterDoList);
+        int unqualifiedCount = (int) reportOutputDos.stream().filter(info -> NO.equals(info.getQualified())).count();
+        if (unqualifiedCount > 0) {
+            CancelProcessOperationVo cancelProcessOperationVo = new CancelProcessOperationVo();
+            cancelProcessOperationVo.setCraftrouteid(null);
+            cancelProcessOperationVo.setCurcancelroll(unqualifiedCount);
+            cancelProcessOperationVo.setApsprocessoperationdo(currentProcessOperationMainDo);
+            apsProcessOperationService.cancelProcessOperation(cancelProcessOperationVo);
+        }
+        return;
+//        // 对不合格的报工输出物料信息安装数据分组
+//        Map<String, List<ApsReportOutputDo>> unqualifiedMap = reportOutputDos.stream()
+//                .filter(info -> NO.equals(info.getQualified()))
+//                .collect(Collectors.groupingBy(ApsReportOutputDo::getOutputid));
+//        unqualifiedMap.forEach((k, v) -> {
+//            // 获取报工记录对应的输出物料
+//            ApsProcessOperationOutMaterDo apsProcessOperationOutMaterDo = operationOutMaterDoList.stream()
+//                    .filter(materDo -> materDo.getId().equals(k)).findFirst().get();
+//            // 待分配取消卷数
+//            int toBeAllocatedCancelRollNum = v.size();
+//            // 本次成品取消卷数
+//            int finishProductCancelRollNum = 0;
+//            // 本次流转取消卷数
+//            int circulationCancelRollNum = 0;
+//            // 备料取消卷数
+//            int materialPreparationCancelRollNum = 0;
+//            // 更新备料已取消卷数
+//            materialPreparationCancelRollNum = checkAndSet(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getStockleaveoutroll,
+//                    toBeAllocatedCancelRollNum);
+//            // 待分配取消卷数 = 待分配取消卷数- 备料已取消卷数
+//            toBeAllocatedCancelRollNum = toBeAllocatedCancelRollNum - apsProcessOperationOutMaterDo.getStockcancelroll();
+//
+//            if (toBeAllocatedCancelRollNum > 0) {
+//                // 更新备料流转剩余需输出卷数
+//                circulationCancelRollNum = checkAndSet(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getMoveleaveoutroll,
+//                        toBeAllocatedCancelRollNum);
+//                // 待分配取消卷数 = 待分配取消卷数- 备料已取消卷数
+//                toBeAllocatedCancelRollNum = toBeAllocatedCancelRollNum - apsProcessOperationOutMaterDo.getStockcancelroll();
+//            }
+//            if (toBeAllocatedCancelRollNum > 0) {
+//                // 成品已取消卷数
+//                finishProductCancelRollNum = checkAndSet(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getProdleaveoutroll,
+//                        toBeAllocatedCancelRollNum);
+//            }
+//            /**
+//             * •成品已取消卷数=成品已取消卷数+本次成品取消卷数
+//             * •成品剩余需输出卷数=成品剩余需输出卷数-本次成品取消卷数；
+//             *
+//             * •备料已取消卷数=备料已取消卷数+本次备料取消卷数
+//             * •备料剩余需输出卷数=备料剩余需输出卷数-本次备料取消卷数；
+//             *
+//             * •流转已取消卷数=流转已取消卷数+本次流转取消卷数
+//             * •流转剩余需输出卷数=流转剩余需输出卷数-本次流转取消卷数；
+//             */
+//            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getProdcancelroll,
+//                    ApsProcessOperationOutMaterDo::setProdcancelroll, finishProductCancelRollNum);
+//            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getProdleaveoutroll,
+//                    ApsProcessOperationOutMaterDo::setProdleaveoutroll, -finishProductCancelRollNum);
+//
+//            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getStockcancelroll,
+//                    ApsProcessOperationOutMaterDo::setStockcancelroll, materialPreparationCancelRollNum);
+//            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getStockleaveoutroll,
+//                    ApsProcessOperationOutMaterDo::setStockleaveoutroll, -materialPreparationCancelRollNum);
+//
+//            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getMovecancelroll,
+//                    ApsProcessOperationOutMaterDo::setMovecancelroll, circulationCancelRollNum);
+//            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getMoveleaveoutroll,
+//                    ApsProcessOperationOutMaterDo::setMoveleaveoutroll, -circulationCancelRollNum);
+//            if(circulationCancelRollNum>0){
+//
+//            }
+//        });
+
+    }
+
+    /**
+     * 设置值
+     *
+     * @param materDo
+     * @param getPojoData
+     * @param toBeAllocatedCancelRollNum
+     * @return
+     */
+    public int checkAndSet(ApsProcessOperationOutMaterDo materDo,
+                           Function<ApsProcessOperationOutMaterDo, Integer> getPojoData,
+                           int toBeAllocatedCancelRollNum) {
+        Integer compareA = getPojoData.apply(materDo);
+        if (compareA >= toBeAllocatedCancelRollNum) {
+            return toBeAllocatedCancelRollNum;
+        } else {
+            return compareA;
+        }
+    }
+
+    /**
+     * 计算相关卷数
+     *
+     * @param materDo
+     * @param getPojoData
+     * @param setPojoData
+     * @param changeRollNum
+     * @return
+     */
+    public void calculateAboutRollNum(ApsProcessOperationOutMaterDo materDo,
+                                      Function<ApsProcessOperationOutMaterDo, Integer> getPojoData,
+                                      BiConsumer<ApsProcessOperationOutMaterDo, Integer> setPojoData,
+                                      int changeRollNum) {
+        setPojoData.accept(materDo, getPojoData.apply(materDo) + changeRollNum);
+    }
+
+    /**
+     * str 拼接List 转str
+     *
+     * @param oldValue
+     * @param newValues
+     * @return
+     */
+    public String strAppendListConvertStr(String oldValue, List<String> newValues) {
+        if (StringUtils.isBlank(oldValue) && (newValues == null || newValues.isEmpty())) {
+            return "";
+        }
+        List<String> oldValues = new ArrayList<>(Arrays.asList(oldValue.split(",")));
+        oldValues.addAll(newValues);
+        return oldValues.stream().distinct().filter(StringUtils::isNotBlank).collect(Collectors.joining(","));
     }
 
     /**