原始检验记录修改

xuhy

2026-03-03 a1ba395da85bed4e5163837a9071eab00fc0b1d9

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

@@ -86,6 +86,19 @@
    @PostMapping(value = "/api/t-project-team/pageList")
    public R<PageInfo<TProjectTeamVO>> pageList(@RequestBody String param) {
        TProjectTeamQuery query = JSON.parseObject(param, TProjectTeamQuery.class);
        // 查询所在项目组
        Long userId = tokenService.getLoginUser().getUserId();
        Integer roleType = tokenService.getLoginUser().getUser().getRoleType();
        if(roleType != 1){
            // 获取用户所在项目组
            List<TProjectTeamStaff> projectTeamStaffs = projectTeamStaffService.list(Wrappers.lambdaQuery(TProjectTeamStaff.class)
                    .eq(TProjectTeamStaff::getUserId, userId));
            if(CollectionUtils.isEmpty(projectTeamStaffs)){
                return R.ok(new PageInfo<>());
            }
            List<String> teamIds = projectTeamStaffs.stream().map(TProjectTeamStaff::getTeamId).collect(Collectors.toList());
            query.setTeamIds(teamIds);
        }
        PageInfo<TProjectTeamVO> tProjectTeamVOPageInfo = projectTeamService.pageList(query);
        return R.ok(tProjectTeamVOPageInfo);
    }
@@ -101,18 +114,18 @@
        TProjectTeamDTO dto = JSON.parseObject(param,TProjectTeamDTO.class);
        List<TProjectTeamStaff> staffs = dto.getStaffs();
        // 判断工艺工程师是否存在其他项目组中
        staffs.stream().filter(staff -> staff.getRoleType() == 3).forEach(staff -> {
            long count = projectTeamStaffService.count(Wrappers.lambdaQuery(TProjectTeamStaff.class).eq(TProjectTeamStaff::getUserId, staff.getUserId()));
            if(count > 0){
                throw new ServiceException("该工艺工程师已存在项目组");
            }
        });
        staffs.stream().filter(staff -> staff.getRoleType() == 2).forEach(staff -> {
            long count = projectTeamStaffService.count(Wrappers.lambdaQuery(TProjectTeamStaff.class).eq(TProjectTeamStaff::getUserId, staff.getUserId()));
            if(count > 0){
                throw new ServiceException("该审批人已存在项目组");
            }
        });
//        staffs.stream().filter(staff -> staff.getRoleType() == 3).forEach(staff -> {
//            long count = projectTeamStaffService.count(Wrappers.lambdaQuery(TProjectTeamStaff.class).eq(TProjectTeamStaff::getUserId, staff.getUserId()));
//            if(count > 0){
//                throw new ServiceException("该工艺工程师已存在项目组");
//            }
//        });
//        staffs.stream().filter(staff -> staff.getRoleType() == 2).forEach(staff -> {
//            long count = projectTeamStaffService.count(Wrappers.lambdaQuery(TProjectTeamStaff.class).eq(TProjectTeamStaff::getUserId, staff.getUserId()));
//            if(count > 0){
//                throw new ServiceException("该审批人已存在项目组");
//            }
//        });
        projectTeamService.save(dto);
        // 保存项目组成员
        for (TProjectTeamStaff staff : staffs) {
@@ -223,98 +236,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();
    }