new-LIMS-after.git

package com.ruoyi.process.controller;
 
 
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.core.domain.Result;
import com.ruoyi.framework.exception.ErrorException;
import com.ruoyi.process.dto.QualityMonitorDetailsDto;
import com.ruoyi.process.dto.QualityMonitorDto;
import com.ruoyi.process.mapper.QualityMonitorDetailsEvaluateFileMapper;
import com.ruoyi.process.mapper.QualityMonitorDetailsEvaluateMapper;
import com.ruoyi.process.pojo.*;
import com.ruoyi.process.service.QualityMonitorDetailsService;
import com.ruoyi.process.service.QualityMonitorService;
import com.ruoyi.process.service.QualityMonitorTaskService;
import com.ruoyi.process.service.QualityMonitorInspectionEvaluationService;
import com.ruoyi.inspect.pojo.InsOrder;
import com.ruoyi.system.mapper.UserMapper;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
 
import jakarta.annotation.Resource;
import jakarta.servlet.http.HttpServletResponse;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
 
 
/**
 * 质量监控计划主表
 *
 * @author zhuo
 * @since 2024-11-06
 */
@Tag(name = "质量监控计划")
@AllArgsConstructor
@RestController
@RequestMapping("/qualityMonitor")
public class QualityMonitorController {
 
    @Operation(summary = "新建年度质量控制计划")
    @PostMapping("/createAnnualPlan")
    public Result<QualityMonitorDto> createAnnualPlan(@RequestBody QualityMonitor qualityMonitor) {
        return Result.success(qualityMonitorService.createAnnualPlan(qualityMonitor));
    }
 
    @Operation(summary = "按年度查询当前质量控制计划")
    @GetMapping("/getAnnualPlan")
    public Result<QualityMonitorDto> getAnnualPlan(String monitorYear, Integer qualityMonitorId) {
        return Result.success(qualityMonitorService.getAnnualPlan(monitorYear, qualityMonitorId));
    }
 
    @Operation(summary = "提交年度质量控制计划审核")
    @PostMapping("/submitAnnualPlan")
    public Result submitAnnualPlan(@RequestBody Map<String, Integer> request) {
        return Result.success(qualityMonitorService.submitAnnualPlan(request.get("qualityMonitorId")));
    }
 
    @Resource
    private QualityMonitorService qualityMonitorService;
 
    @Resource
    private QualityMonitorDetailsService qualityMonitorDetailsService;
 
    @Resource
    private QualityMonitorDetailsEvaluateFileMapper qualityMonitorDetailsEvaluateFileMapper;
 
    @Resource
    private QualityMonitorDetailsEvaluateMapper qualityMonitorDetailsEvaluateMapper;
 
    @Resource
    private QualityMonitorTaskService qualityMonitorTaskService;
 
    @Resource
    private QualityMonitorInspectionEvaluationService inspectionEvaluationService;
 
    @Resource
    private UserMapper userMapper;
 
    @Operation(summary = "获取质量监控检验评价")
    @GetMapping("/getInspectionEvaluation")
    public Result<QualityMonitorDetailsEvaluate> getInspectionEvaluation(Integer qualityMonitorDetailsId) {
        return Result.success(inspectionEvaluationService.get(qualityMonitorDetailsId));
    }
 
    @Operation(summary = "提交质量监控检验评价")
    @PostMapping("/submitInspectionEvaluation")
    public Result<QualityMonitorDetailsEvaluate> submitInspectionEvaluation(@RequestBody QualityMonitorDetailsEvaluate evaluation) {
        return Result.success(inspectionEvaluationService.submit(evaluation));
    }
 
    @Operation(summary = "批准或退回质量监控检验评价")
    @PostMapping("/approveInspectionEvaluation")
    public Result approveInspectionEvaluation(@RequestBody Map<String, Object> request) {
        Integer detailId = (Integer) request.get("qualityMonitorDetailsId");
        boolean approved = Boolean.TRUE.equals(request.get("approved"));
        inspectionEvaluationService.approve(detailId, approved, (String) request.get("opinion"));
        return Result.success();
    }
 
    @Operation(summary = "下发质量监控检验任务")
    @PostMapping("/dispatchInspectionTask")
    public Result<InsOrder> dispatchInspectionTask(@RequestBody Map<String, Integer> request) {
        return Result.success(qualityMonitorTaskService.dispatch(request.get("qualityMonitorDetailsId")));
    }
 
    @Operation(summary = "查询质量监控明细关联的检验任务")
    @GetMapping("/getInspectionTask")
    public Result<InsOrder> getInspectionTask(Integer qualityMonitorDetailsId) {
        return Result.success(qualityMonitorTaskService.getTask(qualityMonitorDetailsId));
    }
 
    @Operation(summary = "取消未开始的质量监控检验任务")
    @PostMapping("/cancelInspectionTask")
    public Result cancelInspectionTask(@RequestBody Map<String, Integer> request) {
        qualityMonitorTaskService.cancel(request.get("qualityMonitorDetailsId"));
        return Result.success();
    }
 
    /**
     * 导入监控计划
     * @return
     */
    @Operation(summary = "导入监控计划")
    @PostMapping("/importQualityMonitor")
    public Result importQualityMonitor(MultipartFile file, QualityMonitor qualityMonitor) {
        return Result.success(qualityMonitorService.importQualityMonitor(file, qualityMonitor));
    }
 
    /**
     * 监控计划审核
     * @return
     */
    @Operation(summary = "监控计划审核")
    @PostMapping("/examineQualityMonitor")
    public Result examineQualityMonitor(@RequestBody QualityMonitor qualityMonitor) {
        return Result.success(qualityMonitorService.examineQualityMonitor(qualityMonitor));
    }
 
    /**
     * 监控计划删除
     * @return
     */
    @Operation(summary = "监控计划删除")
    @DeleteMapping("/delQualitySupervise")
    public Result delQualitySupervise(Integer qualityMonitorId) {
        return Result.success(qualityMonitorService.removeById(qualityMonitorId));
    }
 
    /**
     * 监控计划批准
     * @return
     */
    @Operation(summary = "监控计划批准")
    @PostMapping("/ratifyQualityMonitor")
    public Result ratifyQualityMonitor(@RequestBody QualityMonitor qualityMonitor) {
        return Result.success(qualityMonitorService.ratifyQualityMonitor(qualityMonitor));
    }
 
 
    /**
     * 监控计划列表
     * @return
     */
    @Operation(summary = "监控计划列表")
    @GetMapping("/pageQualityMonitor")
    public Result<IPage<QualityMonitorDto>> pageQualityMonitor(QualityMonitor qualityMonitor,Page page) throws Exception {
        return Result.success(qualityMonitorService.pageQualityMonitor(page, qualityMonitor));
    }
 
    /**
     * 监控计划详情列表
     * @param data
     * @return
     */
    @Operation(summary = "监控计划详情列表")
    @GetMapping("/pageQualityMonitorDetail")
    public Result<IPage<QualityMonitorDetailsDto>> pageQualityMonitorDetail(QualityMonitorDetails qualityMonitorDetails, Page page) throws Exception {
        return Result.success(qualityMonitorService.pageQualityMonitorDetail(page, qualityMonitorDetails));
    }
 
    /**
     * 新增监控计划详情
     * @return
     */
    @Operation(summary = "新增监控计划详情")
    @PostMapping("/addQualityMonitorDetail")
    public Result addQualityMonitorDetail(@RequestBody QualityMonitorDetails qualityMonitorDetails) {
        if (qualityMonitorDetails.getQualityMonitorId() == null) {
            throw new ErrorException("缺少监控计划主表id");
        }
        qualityMonitorService.validateDetailEditable(qualityMonitorDetails.getQualityMonitorId());
        normalizeTemplateIds(qualityMonitorDetails);
        validateAnnualDetail(qualityMonitorDetails);
        if (qualityMonitorDetails.getSortNo() == null) {
            qualityMonitorDetails.setSortNo((int) qualityMonitorDetailsService.count(
                    com.baomidou.mybatisplus.core.toolkit.Wrappers.<QualityMonitorDetails>lambdaQuery()
                            .eq(QualityMonitorDetails::getQualityMonitorId, qualityMonitorDetails.getQualityMonitorId())) + 1);
        }
        return Result.success(qualityMonitorDetailsService.save(qualityMonitorDetails));
    }
 
    /**
     * 修改监控计划详情
     * @return
     */
    @Operation(summary = "修改监控计划详情")
    @PostMapping("/updateQualityMonitorDetail")
    public Result updateQualityMonitorDetail(@RequestBody QualityMonitorDetails qualityMonitorDetails) {
        QualityMonitorDetails stored = qualityMonitorDetailsService.getById(qualityMonitorDetails.getQualityMonitorDetailsId());
        if (stored == null) throw new ErrorException("质控项目不存在");
        qualityMonitorDetails.setQualityMonitorId(stored.getQualityMonitorId());
        qualityMonitorService.validateDetailEditable(stored.getQualityMonitorId());
        normalizeTemplateIds(qualityMonitorDetails);
        validateAnnualDetail(qualityMonitorDetails);
        if (qualityMonitorTaskService.getTask(qualityMonitorDetails.getQualityMonitorDetailsId()) != null) {
            throw new ErrorException("已下发检验任务的计划明细不可直接修改");
        }
        return Result.success(qualityMonitorDetailsService.updateById(qualityMonitorDetails));
    }
 
    /**
     * 删除监控计划详情
     * @return
     */
    @Operation(summary = "删除监控计划详情")
    @DeleteMapping("/delQualityMonitorDetail")
    public Result delQualityMonitorDetail(Integer qualityMonitorDetailsId) {
        QualityMonitorDetails stored = qualityMonitorDetailsService.getById(qualityMonitorDetailsId);
        if (stored == null) throw new ErrorException("质控项目不存在");
        qualityMonitorService.validateDetailEditable(stored.getQualityMonitorId());
        if (qualityMonitorTaskService.getTask(qualityMonitorDetailsId) != null) {
            throw new ErrorException("已下发检验任务的计划明细不可删除");
        }
        return Result.success(qualityMonitorDetailsService.removeById(qualityMonitorDetailsId));
    }
 
    private void validateAnnualDetail(QualityMonitorDetails detail) {
        if (!org.springframework.util.StringUtils.hasText(detail.getMonitorProject())
                || !org.springframework.util.StringUtils.hasText(detail.getTechnicalStandardText())
                || !org.springframework.util.StringUtils.hasText(detail.getMonitorWay())
                || !org.springframework.util.StringUtils.hasText(detail.getCompletionMonth())
                || !detail.getCompletionMonth().matches("\\d{4}-\\d{2}")
                || detail.getResponsibleUserId() == null) {
            throw new ErrorException("请补齐质控项目、技术标准、质控方式、完成时限和负责人");
        }
        QualityMonitor plan = qualityMonitorService.getById(detail.getQualityMonitorId());
        if (plan == null || !detail.getCompletionMonth().startsWith(plan.getMonitorYear() + "-")) {
            throw new ErrorException("完成时限必须属于当前计划年度");
        }
        int month = Integer.parseInt(detail.getCompletionMonth().substring(5));
        if (month < 1 || month > 12) throw new ErrorException("完成时限月份不正确");
        if (userMapper.selectById(detail.getResponsibleUserId()) == null) {
            throw new ErrorException("负责人不存在");
        }
    }
 
    private void normalizeTemplateIds(QualityMonitorDetails detail) {
        String rawIds = detail.getTemplateIds();
        if (!org.springframework.util.StringUtils.hasText(rawIds) && detail.getTemplateId() != null) {
            rawIds = String.valueOf(detail.getTemplateId());
        }
        if (!org.springframework.util.StringUtils.hasText(rawIds)) {
            detail.setTemplateIds(null);
            detail.setTemplateId(null);
            return;
        }
        Set<Integer> templateIds = new LinkedHashSet<>();
        try {
            for (String rawId : rawIds.split(",")) {
                if (!org.springframework.util.StringUtils.hasText(rawId)) continue;
                int templateId = Integer.parseInt(rawId.trim());
                if (templateId <= 0) throw new NumberFormatException();
                templateIds.add(templateId);
            }
        } catch (NumberFormatException exception) {
            throw new ErrorException("原始记录模板参数不正确");
        }
        if (templateIds.size() > 50) throw new ErrorException("原始记录模板最多选择50个");
        if (templateIds.isEmpty()) {
            detail.setTemplateIds(null);
            detail.setTemplateId(null);
            return;
        }
        detail.setTemplateIds(templateIds.stream().map(String::valueOf).collect(Collectors.joining(",")));
        detail.setTemplateId(templateIds.iterator().next());
    }
 
    /**
     * 导出监控计划
     * @return
     */
    @Operation(summary = "导出监控计划")
    @GetMapping("/exportQualityMonitorDetail")
    public void exportQualityMonitorDetail(Integer qualityMonitorId, HttpServletResponse response) {
        qualityMonitorService.exportQualityMonitorDetail(qualityMonitorId, response);
    }
 
 
    /************************************************************  实施  *******************************************************************/
 
    /**
     * 查询监控计划详情实施信息
     * @return
     */
    @Operation(summary = "查询监控计划详情实施信息")
    @GetMapping("/getQualityMonitorRatify")
    public Result<QualityMonitorDetailsRatify> getQualityMonitorRatify(Integer qualityMonitorDetailsId) {
        return Result.success(qualityMonitorService.getQualityMonitorRatify(qualityMonitorDetailsId));
    }
 
    /**
     * 新增监控计划详情实施信息
     * @return
     */
    @Operation(summary = "新增监控计划详情实施信息")
    @PostMapping("/addQualityMonitorRatify")
    public Result addQualityMonitorRatify(@RequestBody QualityMonitorDetailsRatify qualityMonitorDetailsRatify) {
        return Result.success(qualityMonitorService.addQualityMonitorRatify(qualityMonitorDetailsRatify));
    }
 
    /**
     * 监控计划详情提交批准意见
     * @return
     */
    @Operation(summary = "监控计划详情提交批准意见")
    @PostMapping("/addQualityMonitorRatifyOpinion")
    public Result addQualityMonitorRatifyOpinion(@RequestBody QualityMonitorDetailsRatify qualityMonitorDetailsRatify) {
        return Result.success(qualityMonitorService.addQualityMonitorRatifyOpinion(qualityMonitorDetailsRatify));
    }
 
    /**
     * 导出监控计划详情实施信息
     * @param qualityMonitorDetailsId 监控计划详情实施id
     */
    @Operation(summary = "导出监控计划详情实施信息")
    @GetMapping("/exportQualityMonitorRatify")
    public void exportQualityMonitorRatify(Integer qualityMonitorDetailsId, HttpServletResponse response){
        qualityMonitorService.exportQualityMonitorRatify(qualityMonitorDetailsId, response);
    }
 
    /************************************************************  评价  *******************************************************************/
 
    /**
     * 查询监控评价
     * @return
     */
    @Operation(summary = "查询监控评价")
    @GetMapping("/getQualityMonitorEvaluate")
    public Result<QualityMonitorDetailsEvaluate> getQualityMonitorEvaluate(Integer qualityMonitorDetailsId) {
        return Result.success(qualityMonitorService.getQualityMonitorEvaluate(qualityMonitorDetailsId));
    }
 
    /**
     * 新增监控评价
     * @return
     */
    @Operation(summary = "新增监控评价")
    @PostMapping("/addQualityMonitorEvaluate")
    public Result addQualityMonitorEvaluate(@RequestBody QualityMonitorDetailsEvaluate qualityMonitorDetailsEvaluate) {
        if (qualityMonitorTaskService.getTask(qualityMonitorDetailsEvaluate.getQualityMonitorDetailsId()) != null) {
            throw new ErrorException("质量监控检验评价请使用检验评价入口");
        }
        return Result.success(qualityMonitorService.addQualityMonitorEvaluate(qualityMonitorDetailsEvaluate));
    }
 
    /**
     * 导出监控评价
     * @param qualityMonitorDetailsId 监控评价id
     */
    @Operation(summary = "导出监控评价")
    @GetMapping("/exportQualityMonitorEvaluate")
    public void exportQualityMonitorEvaluate(Integer qualityMonitorDetailsId, HttpServletResponse response){
        qualityMonitorService.exportQualityMonitorEvaluate(qualityMonitorDetailsId, response);
    }
 
    /**
     * 监控评价批准意见
     * @return
     */
    @Operation(summary = "监控评价批准意见")
    @PostMapping("/addMonitorEvaluateOpinion")
    public Result addMonitorEvaluateOpinion(@RequestBody QualityMonitorDetailsEvaluate qualityMonitorDetailsEvaluate) {
        QualityMonitorDetailsEvaluate stored = qualityMonitorDetailsEvaluateMapper.selectById(qualityMonitorDetailsEvaluate.getDetailsEvaluateId());
        if (stored != null && qualityMonitorTaskService.getTask(stored.getQualityMonitorDetailsId()) != null) {
            throw new ErrorException("质量监控检验评价请使用检验评价审批入口");
        }
        return Result.success(qualityMonitorService.addMonitorEvaluateOpinion(qualityMonitorDetailsEvaluate));
    }
 
 
    /**
     * 新增监控评价附件表
     * @param qualityMonitorDetailsId
     * @param file
     * @return
     */
    @Operation(summary = "新增监控评价附件表")
    @PostMapping("/uploadEvaluateFile")
    public Result<?> uploadEvaluateFile(Integer qualityMonitorDetailsId, MultipartFile file) {
        return Result.success(qualityMonitorService.uploadEvaluateFile(qualityMonitorDetailsId, file));
    }
 
 
    /**
     * 查询监控评价附件列表
     * @return
     */
    @Operation(summary = "查询监控评价附件列表")
    @GetMapping("/getEvaluateFileList")
    public Result<List<QualityMonitorDetailsEvaluateFile>> getEvaluateFileList(Integer qualityMonitorDetailsId) {
        return Result.success(qualityMonitorService.getEvaluateFileList(qualityMonitorDetailsId));
    }
 
    /**
     * 删除监控评价附件表
     * @return
     */
    @Operation(summary = "删除监控评价附件表")
    @DeleteMapping("/delVerifyEvaluateFileList")
    public Result delVerifyMethodFileList(Integer evaluateFileId) {
        return Result.success(qualityMonitorDetailsEvaluateFileMapper.deleteById(evaluateFileId));
    }
 
    /******************************************************** 完成报告 ***************************************************************/
 
    /**
     * 上传监控完成报告
     * @param file
     * @param qualityMonitorDetailsId
     * @return
     */
    @Operation(summary = "上传监控完成报告")
    @PostMapping("/uploadFinishReport")
    public Result uploadFinishReport(MultipartFile file, Integer qualityMonitorDetailsId) {
        if (qualityMonitorTaskService.getTask(qualityMonitorDetailsId) != null) {
            throw new ErrorException("质量监控检验任务无需上传完成报告");
        }
        return Result.success(qualityMonitorService.uploadFinishReport(file, qualityMonitorDetailsId));
    }
 
 
    /**
     * 监控计划批准
     * @return
     */
    @Operation(summary = "批准完成报告")
    @PostMapping("/ratifyFinishReport")
    public Result ratifyFinishReport(@RequestBody QualityMonitorDetails qualityMonitorDetails) {
        if (qualityMonitorTaskService.getTask(qualityMonitorDetails.getQualityMonitorDetailsId()) != null) {
            throw new ErrorException("质量监控检验任务无需批准完成报告");
        }
        return Result.success(qualityMonitorService.ratifyFinishReport(qualityMonitorDetails));
    }
}