feature 报工检验逻辑优化

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

@@ -185,10 +185,15 @@ public class ReportCheckServiceImpl implements ReportCheckService {
         currentProcessOperationEqu.setWorkstatus(JOBSTATUS_TO_BE_END);
         currentProcessOperationEqu.setBachmaterialprocess("");
         // 更新 更新该报工检验记录所有输出物料 以及待加工料卷批次号
-        updateProcessOutputMater(apsWorkInProgressInventoryDos, reportOutputDos,
+        batchNumCirculation(apsWorkInProgressInventoryDos, reportOutputDos,
                 operationOutMaterDoList,
                 currentProcessOperationMainDo,
-                currentProcessOperationEqu);
+                currentProcessOperationEqu,
+                reportRecordsDo);
+//        updateProcessOutputMater(apsWorkInProgressInventoryDos, reportOutputDos,
+//                operationOutMaterDoList,
+//                currentProcessOperationMainDo,
+//                currentProcessOperationEqu);
         // 更新当前工序作业和作业明细的数据
         apsProcessOperationService.updateById(currentProcessOperationMainDo);
         apsProcessOperationProcessEquService.updateById(currentProcessOperationEqu);
@@ -202,129 +207,8 @@ public class ReportCheckServiceImpl implements ReportCheckService {
         apsReportRecordsService.update(new LambdaUpdateWrapper<ApsReportRecordsDo>().eq(ApsReportRecordsDo::getId, id)
                 .set(ApsReportRecordsDo::getCheckstatus, VERIFIED)
                 .set(ApsReportRecordsDo::getNeedcheckbatchnumber, ""));
-        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 qualifiedQuantity = qualifiedOutPutList.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());
-//        });
-        /*********************** 工序作业输出物料 更新结束****************************************/
-        // 订单信息
-        //currentProductionOrderDoDispose(productionOrderDo, unqualificationOutPutList);
-//        log.debug("开始更新在制品库存信息");
-        // 在制品
-//        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(","));
-//        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 (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());
-
-        /***************更新在制品信息****************************/
-//        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);
-//            }
-//        }
-//        return R.ok();
+        throw new CustomException("asdada");
+        //return R.ok();
     }
 
     /**
@@ -377,6 +261,379 @@ public class ReportCheckServiceImpl implements ReportCheckService {
         }
     }
 
+    /**
+     * 批次号流转相关逻辑
+     *
+     * @param apsWorkInProgressInventoryDos
+     * @param reportOutputDos
+     * @param operationOutMaterDoList
+     * @param currentProcessOperationDo
+     * @param currentProcessOperationEqu
+     */
+    public void batchNumCirculation(List<ApsWorkInProgressInventoryDo> apsWorkInProgressInventoryDos,
+                                    List<ApsReportOutputDo> reportOutputDos,
+                                    List<ApsProcessOperationOutMaterDo> operationOutMaterDoList,
+                                    ApsProcessOperationDo currentProcessOperationDo,
+                                    ApsProcessOperationProcessEquDo currentProcessOperationEqu,
+                                    ApsReportRecordsDo reportRecordsDo) {
+        // 获取当前工序作业对应的下一个工序作业 以及工序作业明细信息
+        String nextProcessesIds = currentProcessOperationEqu.getNextprocessesids();
+        log.debug("当前工序作业明细对应的下一个工序作业信息ID:{}", nextProcessesIds);
+        // 被流转的工序作业明细
+        List<ApsProcessOperationProcessEquDo> nextProcessOperationProcessEquDos = apsProcessOperationProcessEquService.list(new LambdaQueryWrapper<ApsProcessOperationProcessEquDo>()
+                .in(ApsProcessOperationProcessEquDo::getId, Arrays.asList(nextProcessesIds.split(",")))
+                .eq(BaseDo::getDeleted, NO_DELETED));
+        List<String> nextProcessIds = nextProcessOperationProcessEquDos.stream().map(ApsProcessOperationProcessEquDo::getProcessid).distinct().collect(Collectors.toList());
+        log.debug("当前工序作业明细对应的下一个工序作业ID:{}", nextProcessIds);
+        // 被流转的工序作业
+        List<ApsProcessOperationDo> nextProcessList = apsProcessOperationService.list(new LambdaQueryWrapper<ApsProcessOperationDo>()
+                .in(ApsProcessOperationDo::getId, nextProcessIds)
+                .eq(BaseDo::getDeleted, NO_DELETED));
+        //当前报工记录对应的输入物料数量
+        int inputNum = StringUtils.isBlank(reportRecordsDo.getNeedcheckbatchnumber()) ? 1 : reportRecordsDo.getNeedcheckbatchnumber().split(",").length;
+
+        // 当前报工检验卷数
+        int checkNum = reportOutputDos.size();
+        // 本次检验不合格卷数
+        int unqualifiedNum = (int) reportOutputDos.stream().filter(reportOutputDo -> NO.equals(reportOutputDo.getQualified())).count();
+        // 合格卷数
+        int qualifiedNum = (int) reportOutputDos.stream().filter(reportOutputDo -> YES.equals(reportOutputDo.getQualified())).count();
+        if (unqualifiedNum == 0 && qualifiedNum == 0) {
+            log.error("当前报工记录暂无合格和不合格卷数");
+            throw new CustomException("请检查报工记录信息");
+        }
+        log.debug("本次已检验卷数:{},合格:{}，不合格：{}", checkNum, qualifiedNum, unqualifiedNum);
+        // 对输出物料按照输出物料进行分组
+        Map<String, List<ApsReportOutputDo>> reportOutputMap = reportOutputDos.stream()
+                .collect(Collectors.groupingBy(ApsReportOutputDo::getOutputid,
+                        LinkedHashMap::new, Collectors.toList()));
+        currentProcessOperationDo.setOutputunqualifiednum(currentProcessOperationDo.getOutputunqualifiednum() + unqualifiedNum);
+        currentProcessOperationDo.setOutputqualifiednum(currentProcessOperationDo.getOutputqualifiednum() + qualifiedNum);
+        log.debug("增加当前工序作业的合格：{}和不合格：{}卷数", qualifiedNum, unqualifiedNum);
+        String outputId;
+        List<ApsReportOutputDo> currentReportOutputs;
+        // 需要流转的输出物料id和对应的批次号
+        Map<String, List<String>> toBeProcessedDataMap = new HashMap<>();
+        // 流转取消的卷数
+        Map<String, Integer> circulationCancellationMap = new HashMap<>();
+        for (Map.Entry<String, List<ApsReportOutputDo>> entry : reportOutputMap.entrySet()) {
+            outputId = entry.getKey();
+            currentReportOutputs = entry.getValue();
+            // 当前报工检验卷数
+            int currentOutputCheckNum = currentReportOutputs.size();
+            // 本次检验不合格卷数
+            int currentOutputUnqualifiedNum = (int) currentReportOutputs.stream().filter(reportOutputDo -> NO.equals(reportOutputDo.getQualified())).count();
+            // 合格卷数
+            int currentOutputQualifiedNum = (int) currentReportOutputs.stream().filter(reportOutputDo -> YES.equals(reportOutputDo.getQualified())).count();
+            // 获取工序作业对应的输出物料
+            ApsProcessOperationOutMaterDo apsProcessOperationOutMaterDo = operationOutMaterDoList.stream()
+                    .filter(materDo -> materDo.getId().equals(entry.getKey()))
+                    .findFirst()
+                    .orElse(null);
+            if (apsProcessOperationOutMaterDo == null) {
+                log.error("无法根据输出物料id：{}获取到报工记录对应的输出物料信息", outputId);
+                throw new CustomException("无法获取报工记录对应的输出物料信息");
+            }
+            apsProcessOperationOutMaterDo.setInspectrollnum(apsProcessOperationOutMaterDo.getInspectrollnum() + currentOutputCheckNum);
+            apsProcessOperationOutMaterDo.setFailrollnum(apsProcessOperationOutMaterDo.getFailrollnum() + currentOutputUnqualifiedNum);
+            apsProcessOperationOutMaterDo.setGoodrollnum(apsProcessOperationOutMaterDo.getGoodrollnum() + currentOutputQualifiedNum);
+            log.debug("增加工序作业输出物料的已检验卷数:{},合格卷数:{},不合格卷数:{}", currentOutputCheckNum, currentOutputQualifiedNum, currentOutputUnqualifiedNum);
+            // 临时计划备料卷数 =本次报工卷数*该作业的输出物料的计划备料卷数/该作业的计划加工卷数
+            int blPlanNum = inputNum * apsProcessOperationOutMaterDo.getPlanstockrollnum() / currentProcessOperationDo.getPlanprocessrall();
+            // 临时计划流转卷数 =本次报工卷数*该作业的输出物料的计划流转卷数/该作业的计划加工卷数
+            int lzPlanNum = inputNum * apsProcessOperationOutMaterDo.getPlanmoverollnum() / currentProcessOperationDo.getPlanprocessrall();
+            // 临时计划成品卷数 =本次报工卷数*该作业的输出物料的计划成品卷数/该作业的计划加工卷数
+            int cpPlanNum = inputNum * apsProcessOperationOutMaterDo.getPlanprodrollnum() / currentProcessOperationDo.getPlanprocessrall();
+            /**
+             * •临时本次备料取消卷数=0
+             * •临时本次流转取消卷数=0
+             * •临时本次成品取消卷数=0
+             */
+            int blQxNum = 0;
+            int lzQxNum = 0;
+            int cpQxNum = 0;
+            if (currentOutputUnqualifiedNum > 0) {
+                //  如果该作业明细输出物料的计划备料卷数≥待分配不合格卷数，
+                if (blPlanNum >= currentOutputUnqualifiedNum) {
+                    /**
+                     *
+                     * 临时计算本次备料取消卷数=待分配不合格卷数；
+                     * 临时计算待分配不合格卷数=0
+                     */
+                    blQxNum = currentOutputUnqualifiedNum;
+                    currentOutputUnqualifiedNum = 0;
+                } else {
+                    /**
+                     * 临时计算本次备料取消卷数=该作业明细输出物料的计划备料卷数；
+                     * 临时计算待分配不合格卷数= 待分配不合格卷数-该作业明细输出物料的计划备料卷数
+                     */
+                    blQxNum = blPlanNum;
+                    currentOutputUnqualifiedNum = currentOutputUnqualifiedNum - blPlanNum;
+                }
+            }
+
+            if (currentOutputUnqualifiedNum > 0) {
+                //如果该作业明细输出物料的计划流转卷数 ≥ 待分配不合格卷数
+                if (lzPlanNum >= currentOutputUnqualifiedNum) {
+                    /**
+                     * 临时计算本次流转取消卷数 =	待分配不合格卷数
+                     * 临时计算待分配不合格卷数 = 0
+                     */
+                    lzQxNum = currentOutputUnqualifiedNum;
+                    currentOutputUnqualifiedNum = 0;
+                } else {
+                    /**
+                     * 临时计算本次流转取消卷数=	该作业明细输出物料的计划流转卷数
+                     * 临时计算待分配不合格卷数=待分配不合格卷数-该作业明细输出物料的计划流转卷数
+                     */
+                    lzQxNum = lzPlanNum;
+                    currentOutputUnqualifiedNum = -currentOutputUnqualifiedNum - lzPlanNum;
+                }
+            }
+
+            if (currentOutputUnqualifiedNum > 0) {
+                /**
+                 * 临时计算本次成品已取消卷数=待分配不合格卷数；
+                 */
+                cpQxNum = currentOutputUnqualifiedNum;
+            }
+            // 流转取消卷数>0
+            if (lzQxNum > 0) {
+                // 首先获取当前值
+                Integer currentCount = circulationCancellationMap.get(outputId);
+                // 检查是否为 null
+                if (currentCount == null) {
+                    currentCount = 0;
+                }
+                // 更新值
+                circulationCancellationMap.put(outputId, currentCount + lzQxNum);
+            }
+
+            /**
+             * 临时本次备料输出卷数=该作业明细输出物料的计划备料卷数-本次备料取消卷数
+             * 临时本次流转输出卷数=该作业明细输出物料的计划流转卷数-本次流转取消卷数，
+             * 临时本次成品输出卷数=该作业明细输出物料的计划成品数-本次成品取消卷数
+             */
+            int blScNum = blPlanNum - blQxNum;
+            int lzScNum = lzPlanNum - lzQxNum;
+            int cpScNum = cpPlanNum - cpQxNum;
+            /**
+             * 备料已取消卷数=备料已取消卷数+本次备料取消卷数；
+             * 备料已输出卷数=备料已输出卷数+本次备料输出卷数
+             * 备料剩余需输出卷数=备料剩余需输出卷数-该作业明细输出物料的计划备料卷数
+             */
+            log.debug("更新输出物料：{}的 备料取消卷数+{},备料输出卷数+{},计划备料卷数-{}", apsProcessOperationOutMaterDo.getId(), blQxNum, blScNum, blPlanNum);
+            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getStockcancelroll,
+                    ApsProcessOperationOutMaterDo::setStockcancelroll, blQxNum, 1);
+            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getStockoutroll,
+                    ApsProcessOperationOutMaterDo::setStockoutroll, blScNum, 1);
+            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getStockleaveoutroll,
+                    ApsProcessOperationOutMaterDo::setStockleaveoutroll, blPlanNum, -1);
+            /**
+             * 流转已取消卷数=流转已取消卷数+本次流转取消卷数；
+             * 流转已输出卷数=流转已输出卷数+本次流转输出卷数
+             * 流转剩余需输出卷数=流转剩余需输出卷数-该作业明细输出物料的计划流转卷数
+             */
+            log.debug("更新输出物料：{}的 流转取消卷数+{},流转输出卷数+{},计划流转卷数-{}", apsProcessOperationOutMaterDo.getId(), lzQxNum, lzScNum, lzPlanNum);
+            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getMovecancelroll,
+                    ApsProcessOperationOutMaterDo::setMovecancelroll, lzQxNum, 1);
+            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getMoveoutroll,
+                    ApsProcessOperationOutMaterDo::setMoveoutroll, lzScNum, 1);
+            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getMoveleaveoutroll,
+                    ApsProcessOperationOutMaterDo::setMoveleaveoutroll, lzPlanNum, -1);
+            /**
+             * 成品已取消卷数=成品已取消卷数+本次成品取消卷数；
+             * 成品已输出卷数=成品已输出卷数+本次成品输出卷数
+             * 成品剩余需输出卷数=成品剩余需输出卷数-该作业明细输出物料的计划成品卷数
+             */
+            log.debug("更新输出物料：{}的 成品取消卷数+{},成品输出卷数+{},计划成品卷数-{}", apsProcessOperationOutMaterDo.getId(), cpQxNum, cpScNum, cpPlanNum);
+            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getProdcancelroll,
+                    ApsProcessOperationOutMaterDo::setProdcancelroll, cpQxNum, 1);
+            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getProdoutroll,
+                    ApsProcessOperationOutMaterDo::setProdoutroll, cpScNum, 1);
+            calculateAboutRollNum(apsProcessOperationOutMaterDo, ApsProcessOperationOutMaterDo::getProdleaveoutroll,
+                    ApsProcessOperationOutMaterDo::setProdleaveoutroll, cpPlanNum, -1);
+            // 不合格在制品更新
+            if (currentOutputUnqualifiedNum > 0) {
+                // 更新备料的在制品状态
+                updateWorkInProgressInventoryStatus(0, currentReportOutputs.size(), NO, apsWorkInProgressInventoryDos,
+                        currentReportOutputs, WAITING, REJECTS);
+            }
+            // 合格在制品更新状态
+            if (currentOutputQualifiedNum > 0) {
+                // 更新备料的在制品状态
+                updateWorkInProgressInventoryStatus(0, blScNum, YES, apsWorkInProgressInventoryDos,
+                        currentReportOutputs, WAITING, PASS);
+                // 更新流转的在制品状态
+                List<String> outputNumbers = updateWorkInProgressInventoryStatus(blScNum, lzScNum, YES,
+                        apsWorkInProgressInventoryDos, currentReportOutputs, WAIT_WORK, PASS);
+                if (outputNumbers.isEmpty()) {
+                    // 添加需要流转的编号信息
+                    toBeProcessedDataMap.put(outputId, outputNumbers);
+                }
+                // 更新成品的在制品状态
+                updateWorkInProgressInventoryStatus(blScNum + lzScNum, cpScNum, YES,
+                        apsWorkInProgressInventoryDos, currentReportOutputs, TO_BE_PUT_INTO_STORAGE, PASS);
+            }
+        }
+        log.info("开始更新在制品和工序作业输出物料信息");
+        // 保存在制品
+        apsWorkInProgressInventoryService.saveOrUpdateBatch(apsWorkInProgressInventoryDos);
+        // 保存工序作业输出物料
+        apsProcessOperationOutMaterService.saveOrUpdateBatch(operationOutMaterDoList);
+        // 批次号流转至下一工序
+        batchNumberCirculation(nextProcessOperationProcessEquDos, nextProcessList, toBeProcessedDataMap);
+        // 更新流转取消数量
+        circulationCancellation(nextProcessOperationProcessEquDos, nextProcessList, circulationCancellationMap);
+    }
+
+    /**
+     * 流转取消逻辑
+     *
+     * @param circulationCancellationMap
+     */
+    public void circulationCancellation(List<ApsProcessOperationProcessEquDo> nextProcessOperationProcessEquDos,
+                                        List<ApsProcessOperationDo> nextProcessList,
+                                        Map<String, Integer> circulationCancellationMap) {
+        if (circulationCancellationMap.isEmpty()) {
+            log.debug("暂无需要取消流转的批次号信息");
+        }
+        log.debug("本次检验不合格的输出物料id：{}",circulationCancellationMap.keySet());
+        ApsProcessOperationDo apsProcessOperationDo;
+        CancelProcessOperationVo cancelProcessOperationVo;
+        for (Map.Entry<String, Integer> entry : circulationCancellationMap.entrySet()) {
+            Integer value = entry.getValue();
+            for (ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo : nextProcessOperationProcessEquDos) {
+                if (value <= 0) {
+                    return;
+                }
+                apsProcessOperationDo = nextProcessList.stream()
+                        .filter(info -> apsProcessOperationProcessEquDo.getProcessid().equals(info.getId()))
+                        .findFirst()
+                        .orElse(null);
+                apsProcessOperationService.getById(apsProcessOperationProcessEquDo.getProcessid());
+                if (apsProcessOperationDo == null) {
+                    log.error("无法根据id：{}获取工序作业信息", apsProcessOperationProcessEquDo.getProcessid());
+                    throw new CustomException("无法获取工序作业信息");
+                }
+                // 剩余待开工卷数
+                int toBeStartedQty = apsProcessOperationProcessEquDo.getPlanprocessrall() - apsProcessOperationProcessEquDo.getStartingroll() - apsProcessOperationProcessEquDo.getCancelroll();
+                // 本次取消卷数
+                int cancelQty = toBeStartedQty >= value ? value : toBeStartedQty;
+                log.debug("工序作业:{}的本次取消卷数:{}", apsProcessOperationProcessEquDo.getId(), cancelQty);
+                // 改为取消方法更新作业输入已取消卷数
+                apsProcessOperationDo.setInputunqualifiedroll(cancelQty + apsProcessOperationDo.getInputunqualifiedroll());
+                //取消和更新作业明细
+                apsProcessOperationService.cancelProcessOperationEqu(cancelQty, apsProcessOperationDo, apsProcessOperationProcessEquDo);
+                //取消和更新工序作业
+                cancelProcessOperationVo = new CancelProcessOperationVo();
+                cancelProcessOperationVo.setCraftrouteid(null);
+                cancelProcessOperationVo.setCurcancelroll(cancelQty);
+                cancelProcessOperationVo.setApsprocessoperationdo(apsProcessOperationDo);
+                cancelProcessOperationVo.setSetincancelroll(false);
+                cancelProcessOperationVo.setUpdatecuropration(false);
+                apsProcessOperationService.cancelProcessOperation(cancelProcessOperationVo);
+                value = value - cancelQty;
+            }
+        }
+    }
+
+    /**
+     * 批次号流转逻辑
+     *
+     * @param nextProcessOperationProcessEquDos
+     * @param nextProcessList
+     * @param toBeProcessedDataMap
+     */
+    public void batchNumberCirculation(List<ApsProcessOperationProcessEquDo> nextProcessOperationProcessEquDos,
+                                       List<ApsProcessOperationDo> nextProcessList,
+                                       Map<String, List<String>> toBeProcessedDataMap) {
+        // 下一个作业明细不为空
+        if (nextProcessOperationProcessEquDos.isEmpty() || toBeProcessedDataMap.isEmpty()) {
+            log.debug("无法找到下一个工序作业或者需要流转的卷数为{}", toBeProcessedDataMap.size());
+            return;
+        }
+        log.debug("开始执行批次号流转逻辑!如下批次号需要流转：{}", toBeProcessedDataMap);
+        List<ApsProcessOperationDo> updateProcessData = new ArrayList<>();
+        List<ApsProcessOperationProcessEquDo> updateProcessEquData = new ArrayList<>();
+        ApsProcessOperationDo updateOperationDo;
+        ApsProcessOperationProcessEquDo apsProcessOperationProcessEquDo;
+        // 批次号流转
+        for (Map.Entry<String, List<String>> entryentry : toBeProcessedDataMap.entrySet()) {
+            ApsProcessOperationDo apsProcessOperationDo = nextProcessList.stream()
+                    .filter(info -> entryentry.getKey().equals(info.getPlaninputid()))
+                    .findFirst()
+                    .orElse(null);
+            updateOperationDo = new ApsProcessOperationDo();
+            // 更新ID
+            updateOperationDo.setId(apsProcessOperationDo.getId());
+            updateOperationDo.setBachmaterialprocess(strAppendListConvertStr(apsProcessOperationDo.getBachmaterialprocess(), entryentry.getValue()));
+            updateOperationDo.setModifydate(new Date());
+            updateProcessData.add(updateOperationDo);
+            log.debug("将批次号：{}流转给工序作业:{}", entryentry.getValue(), updateOperationDo.getId());
+            for (ApsProcessOperationProcessEquDo equ : nextProcessOperationProcessEquDos) {
+                if (updateOperationDo.getId().equals(equ.getProcessid())) {
+                    apsProcessOperationProcessEquDo = new ApsProcessOperationProcessEquDo();
+                    apsProcessOperationProcessEquDo.setId(equ.getId());
+                    apsProcessOperationProcessEquDo.setBachmaterialprocess(strAppendListConvertStr(equ.getBachmaterialprocess(), entryentry.getValue()));
+                    apsProcessOperationProcessEquDo.setModifydate(new Date());
+                    log.debug("将批次号：{}流转给工序作业明细:{}", entryentry.getValue(), equ.getId());
+                    updateProcessEquData.add(apsProcessOperationProcessEquDo);
+                }
+            }
+        }
+        // 保存工序作业明细信息
+        if (!updateProcessData.isEmpty()) {
+            log.debug("开始更新工序作业信息");
+            apsProcessOperationService.saveOrUpdateBatch(updateProcessData);
+        }
+        if (!updateProcessEquData.isEmpty()) {
+            log.debug("开始更新工序作业明细信息");
+            apsProcessOperationProcessEquService.saveOrUpdateBatch(updateProcessEquData);
+        }
+    }
+
+    /**
+     * 更新在制品状态
+     *
+     * @param skip
+     * @param limit
+     * @param workInProgressInventoryDos
+     * @param apsReportOutputDos
+     * @param workingProcessStatus
+     * @return
+     */
+    public List<String> updateWorkInProgressInventoryStatus(int skip, int limit,
+                                                            String qualifiedType,
+                                                            List<ApsWorkInProgressInventoryDo> workInProgressInventoryDos,
+                                                            List<ApsReportOutputDo> apsReportOutputDos,
+                                                            String workingProcessStatus,
+                                                            String workingProcessType) {
+        List<String> outputNumberList = apsReportOutputDos.stream()
+                .filter(reportOutputDo -> qualifiedType.equals(reportOutputDo.getQualified()))
+                .skip(skip)
+                .limit(limit)
+                .map(ApsReportOutputDo::getOutputnumber)
+                .collect(Collectors.toList());
+        if (outputNumberList.isEmpty()) {
+            return outputNumberList;
+        }
+        log.debug("批次号：{}在制品状态流转为：{},在制品类型流转为：{}", outputNumberList, workingProcessStatus, workingProcessType);
+        workInProgressInventoryDos.stream()
+                .filter(inventory -> outputNumberList.contains(inventory.getBatchnumber()))
+                .collect(Collectors.toList()).forEach(data -> {
+                    if (StringUtils.isNotBlank(workingProcessStatus)) {
+                        data.setWorkinprocessstatus(workingProcessStatus);
+                    }
+                    if (StringUtils.isNotBlank(workingProcessType)) {
+                        data.setWorkinprocesstype(workingProcessType);
+                    }
+
+                });
+        return outputNumberList;
+    }
+
+
     /**
      * 更新工序作业对应的输出物料信息
      *
@@ -384,6 +641,7 @@ public class ReportCheckServiceImpl implements ReportCheckService {
      * @param reportOutputDos               报工输出物料信息
      * @param operationOutMaterDoList
      */
+    @Deprecated
     public void updateProcessOutputMater(List<ApsWorkInProgressInventoryDo> apsWorkInProgressInventoryDos,
                                          List<ApsReportOutputDo> reportOutputDos,
                                          List<ApsProcessOperationOutMaterDo> operationOutMaterDoList,
@@ -399,7 +657,7 @@ public class ReportCheckServiceImpl implements ReportCheckService {
             // 获取工序作业对应的输出物料
             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);
@@ -537,7 +795,7 @@ public class ReportCheckServiceImpl implements ReportCheckService {
                 int cancellation;
                 if (toBeAllocated > 0) {
                     // 该作业明细的计划加工卷数*该作业的输出物料的计划备料卷数/该作业的计划加工卷数
-                    int  planeProcessedRolls=(int) Math.floor((double)
+                    int planeProcessedRolls = (int) Math.floor((double)
                             (currentProcessOperationEqu.getPlanprocessrall() * apsProcessOperationOutMaterDo.getPlanstockrollnum()) / currentProcessOperationMainDo.getPlanprocessrall());
                     log.info("开始更新备料相关数据!待分配卷数:{},计划备料卷数：{},输出物料id:{}", toBeAllocated, planeProcessedRolls, key);
                     // 如果该作业明细输出物料的计划备料卷数≥待分配取消卷，则本次备料取消卷数=待分配取消卷 否则 本次备料取消卷数=该作业明细输出物料的计划备料卷数；
@@ -555,9 +813,9 @@ public class ReportCheckServiceImpl implements ReportCheckService {
                 }
                 // 流转卷数相关
                 if (toBeAllocated > 0) {
-                    int planCirculationRolls=(int) Math.floor((double) (currentProcessOperationEqu.getPlanprocessrall() *
+                    int planCirculationRolls = (int) Math.floor((double) (currentProcessOperationEqu.getPlanprocessrall() *
                             apsProcessOperationOutMaterDo.getPlanmoverollnum()) / currentProcessOperationMainDo.getPlanprocessrall());
-                    log.info("开始更新流转卷数相关数据!待分配卷数:{},计划流转卷数：{},输出物料id:{}", toBeAllocated, planCirculationRolls,key);
+                    log.info("开始更新流转卷数相关数据!待分配卷数:{},计划流转卷数：{},输出物料id:{}", toBeAllocated, planCirculationRolls, key);
                     // 如果该作业明细输出物料的计划流转卷数≥待分配取消卷，则本次流转取消卷数=待分配取消卷； 则本次成品取消卷数=该作业明细输出物料的计划流转卷数；
                     cancellation = Math.min(planCirculationRolls, toBeAllocated);
                     /**
@@ -579,9 +837,9 @@ public class ReportCheckServiceImpl implements ReportCheckService {
                 }
                 // 成品输出卷数
                 if (toBeAllocated > 0) {
-                    int finishedProductRolls=(int) Math.floor((double) (currentProcessOperationEqu.getPlanprocessrall() *
+                    int finishedProductRolls = (int) Math.floor((double) (currentProcessOperationEqu.getPlanprocessrall() *
                             apsProcessOperationOutMaterDo.getPlanprodrollnum()) / currentProcessOperationMainDo.getPlanprocessrall());
-                    log.info("开始更新成品输出卷数相关数据!待分配卷数:{},计划成品卷数:{},输出物料id:{}", toBeAllocated, finishedProductRolls,key);
+                    log.info("开始更新成品输出卷数相关数据!待分配卷数:{},计划成品卷数:{},输出物料id:{}", toBeAllocated, finishedProductRolls, key);
                     // 如果该作业明细输出物料的计划成品卷数≥待分配取消卷，则本次流转取消卷数=待分配取消卷； 则本次成品取消卷数=该作业明细输出物料的计划成品卷数；
                     cancellation = Math.min(finishedProductRolls, toBeAllocated);
                     /**
@@ -640,70 +898,6 @@ public class ReportCheckServiceImpl implements ReportCheckService {
             }
         }
         log.info("更新工序作业的输出物料和在制品相关信息结束");
-        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){
-//
-//            }
-//        });
-
     }
 
     /**
@@ -714,6 +908,7 @@ public class ReportCheckServiceImpl implements ReportCheckService {
      * @param toBeAllocatedCancelRollNum
      * @return
      */
+    @Deprecated
     public int checkAndSet(ApsProcessOperationOutMaterDo materDo,
                            Function<ApsProcessOperationOutMaterDo, Integer> getPojoData,
                            int toBeAllocatedCancelRollNum) {
@@ -774,6 +969,7 @@ public class ReportCheckServiceImpl implements ReportCheckService {
      * @param productionOrderDo
      * @param unqualificationOutPutList
      */
+    @Deprecated
     public void currentProductionOrderDoDispose(ApsProductionOrderDo productionOrderDo, List<ApsReportOutputDo> unqualificationOutPutList) {
         // 存在不合格的批次信息
         if (unqualificationOutPutList.isEmpty()) {
@@ -792,6 +988,7 @@ public class ReportCheckServiceImpl implements ReportCheckService {
      * @param nextProcessOperationDo        后道工序信息
      * @return
      */
+    @Deprecated
     public void updateArticlesProcessData(List<ApsReportOutputDo> unqualificationOutPutList,
                                           List<ApsReportOutputDo> qualifiedOutPutList,
                                           ApsReportRecordsDo apsReportRecordsDo,
@@ -799,7 +996,6 @@ public class ReportCheckServiceImpl implements ReportCheckService {
                                           List<ApsProcessOperationDo> nextProcessOperationDo,
                                           ApsProcessOperationDo processOperationDo,
                                           ApsProcessOperationOutMaterDo operationOutMaterDo) {
-
         if (apsWorkInProgressInventoryDos.isEmpty()) {
             return;
         }
@@ -850,7 +1046,6 @@ public class ReportCheckServiceImpl implements ReportCheckService {
                     info.setWorkinprocesstype(WORK_IN_PROCESS);
                 }
             }
-
             processOperationDo.setOutputqualifiednum(processOperationDo.getOutputqualifiednum() + 1);
         });
     }