提交最新代码

puzhibing

6 天以前 2fa7f761cf80802f54f727381b282d3b264501a7

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

@@ -6,24 +6,29 @@
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.basic.PageInfo;
import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.framework.web.service.TokenService;
import com.ruoyi.system.dto.TExperimentResultReportDTO;
import com.ruoyi.system.model.TExperimentResultReport;
import com.ruoyi.system.model.TExperimentScheme;
import com.ruoyi.system.model.TInspectionReport;
import com.ruoyi.system.model.TResultWorkEvaluate;
import com.ruoyi.system.dto.TExperimentResultReportRejectDTO;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.system.model.*;
import com.ruoyi.system.query.OriginalPageListQuery;
import com.ruoyi.system.query.TExperimentResultReportQuery;
import com.ruoyi.system.service.*;
import com.ruoyi.system.vo.TExperimentResultReportVO;
import com.ruoyi.system.vo.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * <p>
@@ -41,82 +46,306 @@
    private final TExperimentResultReportService experimentResultReportService;
    private final TokenService tokenService;
    private final ISysUserService sysUserService;
    private final SysUserMapper sysUserMapper;
    private final TResultWorkEvaluateService resultWorkEvaluateService;
    private final TExperimentSchemeService experimentSchemeService;
    private final TInspectionReportService inspectionReportService;
    private final TProjectTeamStaffService projectTeamStaffService;
    private final TProjectTeamService projectTeamService;
    private final TExperimentDispatchParticipantsService experimentDispatchParticipantsService;
    private final TExperimentDispatchService experimentDispatchService;
    private final TProjectProposalService projectProposalService;
    private final TNoticeService noticeService;
    private final TTestMethodConfirmSheetService testMethodConfirmSheetService;
    private final TTestMethodConfirmSheetTermService testMethodConfirmSheetTermService;
    private final TTestMethodConfirmSheetOriginalService testMethodConfirmSheetOriginalService;
    @Autowired
    public TExperimentResultReportController(TExperimentResultReportService experimentResultReportService, TokenService tokenService, ISysUserService sysUserService, TResultWorkEvaluateService resultWorkEvaluateService, TExperimentSchemeService experimentSchemeService, TInspectionReportService inspectionReportService) {
    public TExperimentResultReportController(TExperimentResultReportService experimentResultReportService, TokenService tokenService, ISysUserService sysUserService, SysUserMapper sysUserMapper, TResultWorkEvaluateService resultWorkEvaluateService, TExperimentSchemeService experimentSchemeService, TInspectionReportService inspectionReportService, TProjectTeamStaffService projectTeamStaffService, TProjectTeamService projectTeamService, TExperimentDispatchParticipantsService experimentDispatchParticipantsService, TExperimentDispatchService experimentDispatchService, TProjectProposalService projectProposalService, TNoticeService noticeService, TTestMethodConfirmSheetService testMethodConfirmSheetService, TTestMethodConfirmSheetTermService testMethodConfirmSheetTermService, TTestMethodConfirmSheetOriginalService testMethodConfirmSheetOriginalService) {
        this.experimentResultReportService = experimentResultReportService;
        this.tokenService = tokenService;
        this.sysUserService = sysUserService;
        this.sysUserMapper = sysUserMapper;
        this.resultWorkEvaluateService = resultWorkEvaluateService;
        this.experimentSchemeService = experimentSchemeService;
        this.inspectionReportService = inspectionReportService;
        this.projectTeamStaffService = projectTeamStaffService;
        this.projectTeamService = projectTeamService;
        this.experimentDispatchParticipantsService = experimentDispatchParticipantsService;
        this.experimentDispatchService = experimentDispatchService;
        this.projectProposalService = projectProposalService;
        this.noticeService = noticeService;
        this.testMethodConfirmSheetService = testMethodConfirmSheetService;
        this.testMethodConfirmSheetTermService = testMethodConfirmSheetTermService;
        this.testMethodConfirmSheetOriginalService = testMethodConfirmSheetOriginalService;
    }

    /**
     * 获取实验结果汇报管理列表
     */
    @PreAuthorize("@ss.hasPermi('system:experimentResultReport:list')")
    @ApiOperation(value = "获取实验结果汇报分页列表")
    //@PreAuthorize("@ss.hasPermi('system:experimentResultReport:list')")
    @ApiOperation(value = "获取实验结果汇报分页列表",response = TExperimentResultReportQuery.class)
    @PostMapping(value = "/api/t-experiment-result-report/pageList")
    public R<PageInfo<TExperimentResultReportVO>> pageList(@RequestBody String param) {
        TExperimentResultReportQuery query = JSON.parseObject(param, TExperimentResultReportQuery.class);
        Long userId = tokenService.getLoginUser().getUserId();
        Integer roleType = tokenService.getLoginUser().getUser().getRoleType();
        query.setRoleType(roleType);
        if(roleType != 1){
            if(roleType ==2){
                // 查询项目组
                TProjectTeamStaff projectTeamStaff = projectTeamStaffService.getOne(Wrappers.lambdaQuery(TProjectTeamStaff.class)
                        .eq(TProjectTeamStaff::getUserId, userId));
                if(Objects.isNull(projectTeamStaff)){
                    return R.fail("当前用户未加入项目组,无法进行操作");
                }
                // 查询项目的工艺工程师id
                TProjectTeamStaff teamStaff = projectTeamStaffService.getOne(Wrappers.lambdaQuery(TProjectTeamStaff.class)
                        .eq(TProjectTeamStaff::getTeamId, projectTeamStaff.getTeamId())
                        .eq(TProjectTeamStaff::getRoleType, 3)
                        .last("LIMIT 1"));
                // 查询实验参与人员
                List<TExperimentDispatchParticipants> experimentDispatchParticipants = experimentDispatchParticipantsService.list(Wrappers.lambdaQuery(TExperimentDispatchParticipants.class)
                        .eq(TExperimentDispatchParticipants::getUserId, teamStaff.getUserId()));
                if(!CollectionUtils.isEmpty(experimentDispatchParticipants)){
                    List<String> dispatchIds = experimentDispatchParticipants.stream().map(TExperimentDispatchParticipants::getDispatchId).distinct().collect(Collectors.toList());
                    query.setDispatchIds(dispatchIds);
                }
            }else {
                // 查询用户所参与的实验调度
                List<TExperimentDispatchParticipants> experimentDispatchParticipants = experimentDispatchParticipantsService.list(Wrappers.lambdaQuery(TExperimentDispatchParticipants.class)
                        .eq(TExperimentDispatchParticipants::getUserId, userId));
                if (!CollectionUtils.isEmpty(experimentDispatchParticipants)) {
                    // 查询项目组id
                    List<String> dispatchIds = experimentDispatchParticipants.stream().map(TExperimentDispatchParticipants::getDispatchId).distinct().collect(Collectors.toList());
                    query.setDispatchIds(dispatchIds);
                }
            }
        }
        return R.ok(experimentResultReportService.pageList(query));
    }

    /**
     * 获取实验结果汇报评定列表
     */
    //@PreAuthorize("@ss.hasPermi('system:experimentResultReport:list')")
    @ApiOperation(value = "获取实验结果汇报评定列表-审批人使用",response = TExperimentResultReportQuery.class)
    @PostMapping(value = "/api/t-experiment-result-report/evaluatePageList")
    public R<PageInfo<TExperimentResultReportVO>> evaluatePageList(@RequestBody String param) {
        TExperimentResultReportQuery query = JSON.parseObject(param, TExperimentResultReportQuery.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)
                    .in(TProjectTeamStaff::getRoleType, 2,3));
            if(!CollectionUtils.isEmpty(projectTeamStaffs)){
                List<String> teamIds = projectTeamStaffs.stream().map(TProjectTeamStaff::getTeamId).collect(Collectors.toList());
                // 查询分组
                List<TProjectTeamStaff> tProjectTeamStaffs = projectTeamStaffService.list(Wrappers.lambdaQuery(TProjectTeamStaff.class)
                        .in(TProjectTeamStaff::getTeamId, teamIds)
                        .eq(TProjectTeamStaff::getRoleType, 3));
                List<Long> userIds = tProjectTeamStaffs.stream().map(TProjectTeamStaff::getUserId).collect(Collectors.toList());
                // 查询用户所参与的实验调度
                List<TExperimentDispatchParticipants> experimentDispatchParticipants = experimentDispatchParticipantsService.list(Wrappers.lambdaQuery(TExperimentDispatchParticipants.class)
                        .in(TExperimentDispatchParticipants::getUserId, userIds));
                if(!experimentDispatchParticipants.isEmpty()){
                    // 查询项目组id
                    List<String> dispatchIds = experimentDispatchParticipants.stream().map(TExperimentDispatchParticipants::getDispatchId).distinct().collect(Collectors.toList());
                    query.setDispatchIds(dispatchIds);
                }
            }
        }
        return R.ok(experimentResultReportService.evaluatePageList(query));
    }

    /**
     * 添加实验结果汇报管理
     */
    @PreAuthorize("@ss.hasPermi('system:experimentResultReport:add')")
    //@PreAuthorize("@ss.hasPermi('system:experimentResultReport:add')")
    @Log(title = "实验结果汇报信息-新增实验结果汇报", businessType = BusinessType.INSERT)
    @ApiOperation(value = "添加实验结果汇报",response = TExperimentResultReportDTO.class)
    @PostMapping(value = "/api/t-experiment-result-report/add")
    public R<Boolean> add(@RequestBody String param) {
        TExperimentResultReportDTO dto = JSON.parseObject(param,TExperimentResultReportDTO.class);
        experimentResultReportService.save(dto);
        // 获取当前用户的项目组id
        Long userId = tokenService.getLoginUser().getUserId();
        TProjectTeamStaff projectTeamStaff = projectTeamStaffService.getOne(Wrappers.lambdaQuery(TProjectTeamStaff.class)
                .eq(TProjectTeamStaff::getUserId, userId));
        // 添加实验结果工作评价
        List<TResultWorkEvaluate> resultWorkEvaluates = dto.getResultWorkEvaluates();
        for (TResultWorkEvaluate resultWorkEvaluate : resultWorkEvaluates) {
            resultWorkEvaluate.setResultReportId(dto.getId());
            resultWorkEvaluate.setTeamId(projectTeamStaff.getTeamId());
        }
        resultWorkEvaluateService.saveBatch(resultWorkEvaluates);
        resultWorkEvaluateService.saveOrUpdateBatch(resultWorkEvaluates);

        // 查询实验调度
        TExperimentDispatch dispatch = experimentDispatchService.getById(dto.getDispatchId());
        if(Objects.nonNull(dispatch)){
            // 修改结束时间
            dispatch.setExperimentEndTime(LocalDateTime.now());
            experimentDispatchService.updateById(dispatch);
        }

        // 查询项目组
        TProjectTeam projectTeam = projectTeamService.getById(projectTeamStaff.getTeamId());
        // MESSAGE 添加消息
        TProjectTeamStaff teamStaff = projectTeamStaffService.getOne(Wrappers.lambdaQuery(TProjectTeamStaff.class)
                .eq(TProjectTeamStaff::getTeamId, projectTeam.getId())
                .eq(TProjectTeamStaff::getRoleType, 2)
                .last("LIMIT 1"));
        if(Objects.nonNull(teamStaff)){
            noticeService.saveNotice(teamStaff.getUserId(), "您有【1】条【实验结果汇报】等待评定", tokenService.getLoginUser().getUser().getNickName(),3);
        }

        return R.ok();
    }

    /**
     * 修改实验结果汇报
     */
    @PreAuthorize("@ss.hasPermi('system:experimentResultReport:edit')")
    //@PreAuthorize("@ss.hasPermi('system:experimentResultReport:edit')")
    @Log(title = "实验结果汇报信息-修改实验结果汇报", businessType = BusinessType.UPDATE)
    @ApiOperation(value = "修改实验结果汇报")
    @PostMapping(value = "/api/t-experiment-result-report/update")
    public R<Boolean> update(@RequestBody String param) {
        TExperimentResultReportDTO dto = JSON.parseObject(param,TExperimentResultReportDTO.class);

        if (SecurityUtils.isAdmin(SecurityUtils.getUserId())){
            dto.setStatus(null);
        }

        experimentResultReportService.updateById(dto);
        // 修改实验结果工作评价
        List<TResultWorkEvaluate> resultWorkEvaluates = dto.getResultWorkEvaluates();
        resultWorkEvaluateService.updateBatchById(resultWorkEvaluates);
        resultWorkEvaluateService.saveOrUpdateBatch(resultWorkEvaluates);

        // 获取当前用户的项目组id
        Long userId = tokenService.getLoginUser().getUserId();
        TProjectTeamStaff projectTeamStaff = projectTeamStaffService.getOne(Wrappers.lambdaQuery(TProjectTeamStaff.class)
                .eq(TProjectTeamStaff::getUserId, userId));

        // 查询实验调度
        TExperimentDispatch dispatch = experimentDispatchService.getById(dto.getDispatchId());
        if(Objects.nonNull(dispatch)){
            // 修改结束时间
            dispatch.setExperimentEndTime(LocalDateTime.now());
            experimentDispatchService.updateById(dispatch);
        }

        // 查询项目组
        if (projectTeamStaff != null) {
            TProjectTeam projectTeam = projectTeamService.getById(projectTeamStaff.getTeamId());
            if(dto.getStatus() != null || dto.getStatus() != -1){
                // MESSAGE 添加消息
                TProjectTeamStaff teamStaff = projectTeamStaffService.getOne(Wrappers.lambdaQuery(TProjectTeamStaff.class)
                        .eq(TProjectTeamStaff::getTeamId, projectTeam.getId())
                        .eq(TProjectTeamStaff::getRoleType, 2)
                        .last("LIMIT 1"));
                if(Objects.nonNull(teamStaff)){
                    noticeService.saveNotice(teamStaff.getUserId(), "您有【1】条【实验结果汇报】等待评定", tokenService.getLoginUser().getUser().getNickName(),3);
                }
            }
        }
        return R.ok();
    }

    /**
     * 修改实验结果汇报
     */
    @PreAuthorize("@ss.hasPermi('system:experimentResultReport:edit')")
    //@PreAuthorize("@ss.hasPermi('system:experimentResultReport:edit')")
    @Log(title = "实验结果汇报信息-评定工艺工程师实验", businessType = BusinessType.UPDATE)
    @ApiOperation(value = "评定工艺工程师实验")
    @ApiOperation(value = "评定工艺工程师实验",response = TResultWorkEvaluate.class)
    @PostMapping(value = "/api/t-experiment-result-report/evaluateProcess")
    public R<Boolean> evaluateProcess(@RequestBody String param) {
        TResultWorkEvaluate resultWorkEvaluate = JSON.parseObject(param,TResultWorkEvaluate.class);
        Long userId = tokenService.getLoginUser().getUserId();
        Integer roleType = tokenService.getLoginUser().getUser().getRoleType();
        if (roleType != 1 && roleType != 2) {
            return R.fail("仅管理员或审批人可以评定工艺工程师");
        }
        TExperimentResultReport experimentResultReport = experimentResultReportService.getById(resultWorkEvaluate.getResultReportId());
        if (Objects.isNull(experimentResultReport)) {
            return R.fail("实验结果汇报不存在");
        }
        if (!Objects.equals(experimentResultReport.getStatus(), 2)) {
            return R.fail("当前实验结果汇报不是待评定状态");
        }
        long evaluatedCount = resultWorkEvaluateService.count(Wrappers.lambdaQuery(TResultWorkEvaluate.class)
                .eq(TResultWorkEvaluate::getResultReportId, resultWorkEvaluate.getResultReportId())
                .eq(TResultWorkEvaluate::getEvaluateType, 1)
                .eq(TResultWorkEvaluate::getDisabled, 0));
        if (evaluatedCount > 0) {
            return R.fail("该工艺工程师工作评定已提交");
        }
        resultWorkEvaluate.setEvaluatePersonId(userId);
        resultWorkEvaluate.setEvaluateTime(LocalDateTime.now());
        resultWorkEvaluate.setStatus(1);
        resultWorkEvaluate.setEvaluateType(1);
        TExperimentDispatch dispatch = experimentDispatchService.getById(experimentResultReport.getDispatchId());
        if (Objects.isNull(dispatch)) {
            return R.fail("实验调度不存在");
        }
        TProjectProposal proposal = projectProposalService.getById(dispatch.getProposalId());
        if (Objects.isNull(proposal)) {
            return R.fail("项目课题方案不存在");
        }
        TExperimentDispatchParticipants processEngineer = experimentDispatchParticipantsService.getOne(
                Wrappers.lambdaQuery(TExperimentDispatchParticipants.class)
                .eq(TExperimentDispatchParticipants::getDispatchId, dispatch.getId())
                .eq(TExperimentDispatchParticipants::getRoleType, 3)
                .last("LIMIT 1"));
        if (Objects.isNull(processEngineer)) {
            return R.fail("当前实验调度未分配工艺工程师,无法进行评定");
        }
        resultWorkEvaluate.setDispatchId(dispatch.getId());
        resultWorkEvaluate.setUserId(processEngineer.getUserId());
        resultWorkEvaluate.setTeamId(proposal.getTeamId());
        resultWorkEvaluateService.save(resultWorkEvaluate);
        experimentResultReport.setStatus(3);
        experimentResultReportService.updateById(experimentResultReport);
        return R.ok();
    }


    /**
     * 驳回实验结果汇报
     */
    //@PreAuthorize("@ss.hasPermi('system:experimentResultReport:edit')")
    @Log(title = "实验结果汇报信息-评定工艺工程师实验-驳回实验结果汇报", businessType = BusinessType.UPDATE)
    @ApiOperation(value = "评定工艺工程师实验-驳回实验结果汇报",response = TExperimentResultReportRejectDTO.class)
    @PostMapping(value = "/api/t-experiment-result-report/rejectResult")
    public R<Boolean> rejectResult(@RequestBody String param) {
        TExperimentResultReportRejectDTO experimentResultReportRejectDTO = JSON.parseObject(param,TExperimentResultReportRejectDTO.class);
        Long userId = tokenService.getLoginUser().getUserId();
        // 查询当前用户组
        TProjectTeamStaff projectTeamStaff = projectTeamStaffService.getOne(Wrappers.lambdaQuery(TProjectTeamStaff.class)
                .eq(TProjectTeamStaff::getUserId, userId)
                .last("LIMIT 1"));
        if(Objects.isNull(projectTeamStaff)){
            return R.fail("当前用户未分配项目组,无法进行评定");
        }
        TProjectTeamStaff projectTeamStaff1 = projectTeamStaffService.getOne(Wrappers.lambdaQuery(TProjectTeamStaff.class)
                .eq(TProjectTeamStaff::getTeamId, projectTeamStaff.getTeamId())
                .eq(TProjectTeamStaff::getRoleType, 2)
                .last("LIMIT 1"));
        if(Objects.isNull(projectTeamStaff1)){
            return R.fail("当前项目组未分配审批人,无法进行评定");
        }
        // 查询实验结果汇报
        TExperimentResultReport experimentResultReport = experimentResultReportService.getById(experimentResultReportRejectDTO.getResultReportId());
        experimentResultReport.setStatus(1);
        experimentResultReport.setRejectRemark(experimentResultReportRejectDTO.getRejectRemark());
        experimentResultReportService.updateById(experimentResultReport);
        return R.ok();
    }

    /**
     * 查看实验结果汇报详情
     */
    @PreAuthorize("@ss.hasPermi('system:experimentResultReport:detail')")
    //@PreAuthorize("@ss.hasPermi('system:experimentResultReport:detail')")
    @ApiOperation(value = "查看实验结果汇报详情")
    @GetMapping(value = "/open/t-experiment-result-report/getDetailById")
    public R<TExperimentResultReportVO> getDetailById(@RequestParam String id) {
@@ -128,20 +357,47 @@
                .eq(TResultWorkEvaluate::getResultReportId, id));
        experimentResultReportVO.setResultWorkEvaluates(resultWorkEvaluates);
        // 查询实验结果列表
        List<TExperimentScheme> experimentSchemes = experimentSchemeService.list(Wrappers.lambdaQuery(TExperimentScheme.class)
                .eq(TExperimentScheme::getDispatchId, experimentResultReport.getDispatchId()));
        experimentResultReportVO.setExperimentSchemes(experimentSchemes);
        List<TExperimentSchemeVO> experimentSchemes = experimentSchemeService.getList(experimentResultReport.getDispatchId());
        experimentResultReportVO.setExperimentSchemeVOS(experimentSchemes);
        // 查询检验报告列表
        List<TInspectionReport> inspectionReports = inspectionReportService.list(Wrappers.lambdaQuery(TInspectionReport.class)
                .eq(TInspectionReport::getDispatchId, experimentResultReport.getDispatchId()));
        experimentResultReportVO.setInspectionReports(inspectionReports);
        // 获取实验参与人员
        List<TExperimentDispatchParticipants> experimentDispatchParticipants = experimentDispatchParticipantsService.list(Wrappers.lambdaQuery(TExperimentDispatchParticipants.class)
                .eq(TExperimentDispatchParticipants::getDispatchId, experimentResultReport.getDispatchId()));
        experimentResultReportVO.setExperimentDispatchParticipants(experimentDispatchParticipants);
        // 查询实验调度
        TExperimentDispatch experimentDispatch = experimentDispatchService.getById(experimentResultReport.getDispatchId());
        TExperimentDispatchVO experimentDispatchVO = new TExperimentDispatchVO();
        BeanUtils.copyProperties(experimentDispatch, experimentDispatchVO);
        // 查询项目课题
        TProjectProposal proposal = projectProposalService.getById(experimentDispatch.getProposalId());
        experimentDispatchVO.setProjectName(proposal.getProjectName());
        experimentDispatchVO.setProjectCode(proposal.getProjectCode());
        // 查询参与人员
        List<TExperimentDispatchParticipants> tExperimentDispatchParticipants = experimentDispatchParticipantsService.list(Wrappers.lambdaQuery(TExperimentDispatchParticipants.class)
                .eq(TExperimentDispatchParticipants::getDispatchId, experimentResultReport.getDispatchId()));
        List<Long> userIds = tExperimentDispatchParticipants.stream().map(TExperimentDispatchParticipants::getUserId).distinct().collect(Collectors.toList());
        List<SysUser> sysUsers = sysUserMapper.selectUserByIds(userIds);
        String participantsName = sysUsers.stream().map(SysUser::getNickName).collect(Collectors.joining(";"));
        experimentDispatchVO.setParticipantsName(participantsName);
        // 设置nickName
        experimentDispatchParticipants.forEach(tExperimentDispatchParticipant -> {
            SysUser sysUser = sysUsers.stream().filter(user -> user.getUserId().equals(tExperimentDispatchParticipant.getUserId())).findFirst().orElse(null);
            if(sysUser != null){
                tExperimentDispatchParticipant.setNickName(sysUser.getNickName());
                tExperimentDispatchParticipant.setAvatar(sysUser.getAvatar());
            }
        });
        experimentResultReportVO.setExperimentDispatchVO(experimentDispatchVO);
        return R.ok(experimentResultReportVO);
    }

    /**
     * 删除实验结果汇报
     */
    @PreAuthorize("@ss.hasPermi('system:experimentResultReport:delete')")
    //@PreAuthorize("@ss.hasPermi('system:experimentResultReport:delete')")
    @Log(title = "实验结果汇报信息-删除实验结果汇报", businessType = BusinessType.DELETE)
    @ApiOperation(value = "删除实验结果汇报")
    @DeleteMapping(value = "/open/t-experiment-result-report/deleteById")
@@ -152,7 +408,7 @@
    /**
     * 批量删除实验结果汇报
     */
    @PreAuthorize("@ss.hasPermi('system:experimentResultReport:delete')")
    //@PreAuthorize("@ss.hasPermi('system:experimentResultReport:delete')")
    @Log(title = "实验结果汇报信息-删除实验结果汇报", businessType = BusinessType.DELETE)
    @ApiOperation(value = "批量删除实验结果汇报")
    @DeleteMapping(value = "/open/t-experiment-result-report/deleteByIds")
@@ -160,5 +416,66 @@
        return R.ok(experimentResultReportService.removeByIds(ids));
    }

    /**
     * 通过实验调度id获取实验结果、检验结果、评价信息、参与人员信息
     */
    //@PreAuthorize("@ss.hasPermi('system:experimentResultReport:detail')")
    @ApiOperation(value = "通过实验调度id获取实验结果、检验结果、评价信息、参与人员信息")
    @GetMapping(value = "/open/t-experiment-result-report/getOtherInfoByDispatchId")
    public R<TExperimentResultReportVO> getOtherInfoByDispatchId(@RequestParam String dispatchId) {
        TExperimentResultReportVO experimentResultReportVO = new TExperimentResultReportVO();
        // 获取评分列表
        List<TResultWorkEvaluate> resultWorkEvaluates = resultWorkEvaluateService.list(Wrappers.lambdaQuery(TResultWorkEvaluate.class)
                .eq(TResultWorkEvaluate::getDispatchId, dispatchId));
        experimentResultReportVO.setResultWorkEvaluates(resultWorkEvaluates);
        // 查询实验结果列表
        List<TExperimentSchemeVO> experimentSchemeVOS = experimentSchemeService.getList(dispatchId);
        experimentResultReportVO.setExperimentSchemeVOS(experimentSchemeVOS);
        // 查询检验报告列表
        List<TInspectionReport> inspectionReports = inspectionReportService.list(Wrappers.lambdaQuery(TInspectionReport.class)
                .eq(TInspectionReport::getDispatchId, dispatchId));
        experimentResultReportVO.setInspectionReports(inspectionReports);
        // 获取实验参与人员
        List<TExperimentDispatchParticipants> experimentDispatchParticipants = experimentDispatchParticipantsService.list(Wrappers.lambdaQuery(TExperimentDispatchParticipants.class)
                .eq(TExperimentDispatchParticipants::getDispatchId, dispatchId));
        // 设置nickName
        List<Long> userIds = experimentDispatchParticipants.stream().map(TExperimentDispatchParticipants::getUserId).collect(Collectors.toList());
        List<SysUser> sysUsers = sysUserMapper.selectUserByIds(userIds);
        experimentDispatchParticipants.forEach(tExperimentDispatchParticipant -> {
            SysUser sysUser = sysUsers.stream().filter(user -> user.getUserId().equals(tExperimentDispatchParticipant.getUserId())).findFirst().orElse(null);
            if(sysUser != null){
                tExperimentDispatchParticipant.setNickName(sysUser.getNickName());
                tExperimentDispatchParticipant.setAvatar(sysUser.getAvatar());
            }
        });
        experimentResultReportVO.setExperimentDispatchParticipants(experimentDispatchParticipants);
        return R.ok(experimentResultReportVO);
    }

    /**
     * 通过实验调度id获取原始检验记录列表
     */
    //@PreAuthorize("@ss.hasPermi('system:experimentResultReport:detail')")
    @ApiOperation(value = "通过实验调度id获取原始检验记录列表",response = OriginalPageListQuery.class)
    @PostMapping(value = "/api/t-experiment-result-report/getOriginalPageListByDispatchId")
    public R<PageInfo<TTestMethodConfirmSheetOriginalVO>> getOriginalPageListByDispatchId(@RequestBody String param) {
        OriginalPageListQuery query = JSON.parseObject(param,OriginalPageListQuery.class);
        PageInfo<TTestMethodConfirmSheetOriginalVO> pageInfo = testMethodConfirmSheetOriginalService.getOriginalPageListByDispatchId(query);
        return R.ok(pageInfo);
    }

    /**
     * 提交接口
     */
    //@PreAuthorize("@ss.hasPermi('system:experimentResultReport:detail')")
    @ApiOperation(value = "提交接口")
    @GetMapping(value = "/open/t-experiment-result-report/commit")
    public R<TExperimentResultReportVO> commit(@RequestParam String id) {
        TExperimentResultReport experimentResultReport = experimentResultReportService.getById(id);
        experimentResultReport.setStatus(2);
        experimentResultReportService.updateById(experimentResultReport);
        return R.ok();
    }

}