bug修改

xuhy

1 天以前 b7ec3aff011f05e236e76be844540dbe776f7353

 ruoyi-admin/src/main/java/com/ruoyi/web/controller/api/TProjectTeamController.java

@@ -223,98 +223,136 @@
        projectTeam.setStatus(dto.getStatus());
        projectTeamService.updateById(projectTeam);

        // 封存项目课题方案
        List<TProjectProposal> projectProposals = projectProposalService.list(Wrappers.lambdaQuery(TProjectProposal.class)
                .eq(TProjectProposal::getTeamId, dto.getId()));
        if(!CollectionUtils.isEmpty(projectProposals)){
            for (TProjectProposal projectProposal : projectProposals) {
                projectProposal.setAuditStatus(5);
        if(dto.getStatus() == 2){
            // 封存项目课题方案
            List<TProjectProposal> projectProposals = projectProposalService.list(Wrappers.lambdaQuery(TProjectProposal.class)
                    .eq(TProjectProposal::getTeamId, dto.getId()));
            if(!CollectionUtils.isEmpty(projectProposals)){
                for (TProjectProposal projectProposal : projectProposals) {
                    projectProposal.setOldStatus(projectProposal.getAuditStatus());
                    projectProposal.setAuditStatus(5);
                }
                projectProposalService.updateBatchById(projectProposals);
                List<String> projectIds = projectProposals.stream().map(TProjectProposal::getId).collect(Collectors.toList());
                // 封存实验调度
                List<TExperimentDispatch> experimentDispatches = experimentDispatchService.list(Wrappers.lambdaQuery(TExperimentDispatch.class)
                        .in(TExperimentDispatch::getProposalId, projectIds));
                if(!CollectionUtils.isEmpty(experimentDispatches)){
                    experimentDispatches.forEach(experimentDispatch -> {
                        experimentDispatch.setOldStatus(experimentDispatch.getStatus());
                        experimentDispatch.setStatus(3);
                    });
                    experimentDispatchService.updateBatchById(experimentDispatches);

                    // 封存检验方法
                    List<String> dispatchIds = experimentDispatches.stream().map(TExperimentDispatch::getId).collect(Collectors.toList());
                    List<TTestMethodConfirmSheet> testMethodConfirmSheets = testMethodConfirmSheetService.list(Wrappers.lambdaQuery(TTestMethodConfirmSheet.class)
                            .in(TTestMethodConfirmSheet::getDispatchId, dispatchIds));
                    if(!CollectionUtils.isEmpty(testMethodConfirmSheets)){
                        testMethodConfirmSheets.forEach(testMethodConfirmSheet -> {
                            testMethodConfirmSheet.setOldStatus(testMethodConfirmSheet.getAuditStatus());
                            testMethodConfirmSheet.setAuditStatus(5);
                        });
                        testMethodConfirmSheetService.updateBatchById(testMethodConfirmSheets);
                    }

                    // 封存试验方案
                    List<TExperimentScheme> experimentSchemes = experimentSchemeService.list(Wrappers.lambdaQuery(TExperimentScheme.class)
                            .in(TExperimentScheme::getDispatchId, dispatchIds));
                    if(!CollectionUtils.isEmpty(experimentSchemes)){
                        experimentSchemes.forEach(experimentScheme -> {
                            experimentScheme.setOldStatus(experimentScheme.getStatus());
                            experimentScheme.setStatus(5);
                        });
                        experimentSchemeService.updateBatchById(experimentSchemes);
                    }

                    // 封存取样记录
                    List<TSamplingRecord> samplingRecords = samplingRecordService.list(Wrappers.lambdaQuery(TSamplingRecord.class)
                            .in(TSamplingRecord::getDispatchId, dispatchIds));
                    if(!CollectionUtils.isEmpty(samplingRecords)){
                        samplingRecords.forEach(samplingRecord -> {
                            samplingRecord.setOldStatus(samplingRecord.getStatus());
                            samplingRecord.setStatus(3);
                        });
                        samplingRecordService.updateBatchById(samplingRecords);
                    }

                    // 封存结果汇报
                    List<TExperimentResultReport> experimentResultReports = experimentResultReportService.list(Wrappers.lambdaQuery(TExperimentResultReport.class)
                            .in(TExperimentResultReport::getDispatchId, dispatchIds));
                    if(!CollectionUtils.isEmpty(experimentResultReports)){
                        experimentResultReports.forEach(experimentResultReport -> {
                            experimentResultReport.setOldStatus(experimentResultReport.getStatus());
                            experimentResultReport.setStatus(4);
                        });
                        experimentResultReportService.updateBatchById(experimentResultReports);
                    }

                }
            }
            projectProposalService.updateBatchById(projectProposals);
            List<String> projectIds = projectProposals.stream().map(TProjectProposal::getId).collect(Collectors.toList());
            // 封存实验调度
            List<TExperimentDispatch> experimentDispatches = experimentDispatchService.list(Wrappers.lambdaQuery(TExperimentDispatch.class)
                    .in(TExperimentDispatch::getProposalId, projectIds));
            if(!CollectionUtils.isEmpty(experimentDispatches)){
                experimentDispatches.forEach(experimentDispatch -> {
                    experimentDispatch.setStatus(3);
                });
                experimentDispatchService.updateBatchById(experimentDispatches);

                // 封存检验方法
                List<String> dispatchIds = experimentDispatches.stream().map(TExperimentDispatch::getId).collect(Collectors.toList());
                List<TTestMethodConfirmSheet> testMethodConfirmSheets = testMethodConfirmSheetService.list(Wrappers.lambdaQuery(TTestMethodConfirmSheet.class)
                        .in(TTestMethodConfirmSheet::getDispatchId, dispatchIds));
                if(!CollectionUtils.isEmpty(testMethodConfirmSheets)){
                    testMethodConfirmSheets.forEach(testMethodConfirmSheet -> {
                        testMethodConfirmSheet.setAuditStatus(5);
                    });
                    testMethodConfirmSheetService.updateBatchById(testMethodConfirmSheets);
        }else {
            // 解封项目课题方案
            List<TProjectProposal> projectProposals = projectProposalService.list(Wrappers.lambdaQuery(TProjectProposal.class)
                    .eq(TProjectProposal::getTeamId, dto.getId()));
            if(!CollectionUtils.isEmpty(projectProposals)){
                for (TProjectProposal projectProposal : projectProposals) {
                    projectProposal.setAuditStatus(projectProposal.getOldStatus());
                }

                // 封存试验方案
                List<TExperimentScheme> experimentSchemes = experimentSchemeService.list(Wrappers.lambdaQuery(TExperimentScheme.class)
                        .in(TExperimentScheme::getDispatchId, dispatchIds));
                if(!CollectionUtils.isEmpty(experimentSchemes)){
                    experimentSchemes.forEach(experimentScheme -> {
                        experimentScheme.setStatus(5);
                projectProposalService.updateBatchById(projectProposals);
                List<String> projectIds = projectProposals.stream().map(TProjectProposal::getId).collect(Collectors.toList());
                // 封存实验调度
                List<TExperimentDispatch> experimentDispatches = experimentDispatchService.list(Wrappers.lambdaQuery(TExperimentDispatch.class)
                        .in(TExperimentDispatch::getProposalId, projectIds));
                if(!CollectionUtils.isEmpty(experimentDispatches)){
                    experimentDispatches.forEach(experimentDispatch -> {
                        experimentDispatch.setStatus(experimentDispatch.getOldStatus());
                    });
                    experimentSchemeService.updateBatchById(experimentSchemes);
                }
                    experimentDispatchService.updateBatchById(experimentDispatches);

                // 封存取样记录
                List<TSamplingRecord> samplingRecords = samplingRecordService.list(Wrappers.lambdaQuery(TSamplingRecord.class)
                        .in(TSamplingRecord::getDispatchId, dispatchIds));
                if(!CollectionUtils.isEmpty(samplingRecords)){
                    samplingRecords.forEach(samplingRecord -> {
                        samplingRecord.setStatus(3);
                    });
                    samplingRecordService.updateBatchById(samplingRecords);
                }
                    // 封存检验方法
                    List<String> dispatchIds = experimentDispatches.stream().map(TExperimentDispatch::getId).collect(Collectors.toList());
                    List<TTestMethodConfirmSheet> testMethodConfirmSheets = testMethodConfirmSheetService.list(Wrappers.lambdaQuery(TTestMethodConfirmSheet.class)
                            .in(TTestMethodConfirmSheet::getDispatchId, dispatchIds));
                    if(!CollectionUtils.isEmpty(testMethodConfirmSheets)){
                        testMethodConfirmSheets.forEach(testMethodConfirmSheet -> {
                            testMethodConfirmSheet.setAuditStatus(testMethodConfirmSheet.getAuditStatus());
                        });
                        testMethodConfirmSheetService.updateBatchById(testMethodConfirmSheets);
                    }

                // 封存结果汇报
                List<TExperimentResultReport> experimentResultReports = experimentResultReportService.list(Wrappers.lambdaQuery(TExperimentResultReport.class)
                        .in(TExperimentResultReport::getDispatchId, dispatchIds));
                if(!CollectionUtils.isEmpty(experimentResultReports)){
                    experimentResultReports.forEach(experimentResultReport -> {
                        experimentResultReport.setStatus(4);
                    });
                    experimentResultReportService.updateBatchById(experimentResultReports);
                }
                    // 封存试验方案
                    List<TExperimentScheme> experimentSchemes = experimentSchemeService.list(Wrappers.lambdaQuery(TExperimentScheme.class)
                            .in(TExperimentScheme::getDispatchId, dispatchIds));
                    if(!CollectionUtils.isEmpty(experimentSchemes)){
                        experimentSchemes.forEach(experimentScheme -> {
                            experimentScheme.setStatus(experimentScheme.getOldStatus());
                        });
                        experimentSchemeService.updateBatchById(experimentSchemes);
                    }

                    // 封存取样记录
                    List<TSamplingRecord> samplingRecords = samplingRecordService.list(Wrappers.lambdaQuery(TSamplingRecord.class)
                            .in(TSamplingRecord::getDispatchId, dispatchIds));
                    if(!CollectionUtils.isEmpty(samplingRecords)){
                        samplingRecords.forEach(samplingRecord -> {
                            samplingRecord.setStatus(samplingRecord.getOldStatus());
                        });
                        samplingRecordService.updateBatchById(samplingRecords);
                    }

                    // 封存结果汇报
                    List<TExperimentResultReport> experimentResultReports = experimentResultReportService.list(Wrappers.lambdaQuery(TExperimentResultReport.class)
                            .in(TExperimentResultReport::getDispatchId, dispatchIds));
                    if(!CollectionUtils.isEmpty(experimentResultReports)){
                        experimentResultReports.forEach(experimentResultReport -> {
                            experimentResultReport.setStatus(experimentResultReport.getOldStatus());
                        });
                        experimentResultReportService.updateBatchById(experimentResultReports);
                    }
                }
            }
        }

        // 封存检测项
//        List<TQaTestItem> qaTestItems = qaTestItemService.list(Wrappers.lambdaQuery(TQaTestItem.class)
//                .eq(TQaTestItem::getTeamId, dto.getId()));
//        if(!CollectionUtils.isEmpty(qaTestItems)){
//            qaTestItems.forEach(qaTestItem -> {
//                qaTestItem.setStatus(4);
//            });
//            qaTestItemService.updateBatchById(qaTestItems);
//        }

        // 封存中试
//        List<TQaProduceReport> qaProduceReports = qaProduceReportService.list(Wrappers.lambdaQuery(TQaProduceReport.class)
//                .eq(TQaProduceReport::getTeamId, dto.getId()));
//        if(!CollectionUtils.isEmpty(qaProduceReports)){
//            qaProduceReports.forEach(qaProduceReport -> {
//                qaProduceReport.setStatus(4);
//            });
//            qaProduceReportService.updateBatchById(qaProduceReports);
//        }

        // 封存可行等报告
//        List<TFeasibilityStudyReport> feasibilityStudyReports = feasibilityStudyReportService.list(Wrappers.lambdaQuery(TFeasibilityStudyReport.class)
//                .eq(TFeasibilityStudyReport::getTeamId, dto.getId()));
//        if(!CollectionUtils.isEmpty(feasibilityStudyReports)){
//            feasibilityStudyReports.forEach(feasibilityStudyReport -> {
//                feasibilityStudyReport.setStatus(4);
//            });
//            feasibilityStudyReportService.updateBatchById(feasibilityStudyReports);
//        }


        return R.ok();
    }