双重预防项目-国泰新华二开定制版
16639036659
2022-09-27 7e7195766eb018b4ba00b2d0663f6dcb11adefc8
src/main/java/com/ruoyi/doublePrevention/service/impl/RiskServiceImpl.java
@@ -4,6 +4,7 @@
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.text.Convert;
import com.ruoyi.doublePrevention.entity.*;
import com.ruoyi.doublePrevention.entity.dto.req.*;
import com.ruoyi.doublePrevention.entity.dto.resp.*;
@@ -16,16 +17,16 @@
import com.ruoyi.doublePrevention.service.baseService.*;
import com.ruoyi.doublePrevention.vo.ResultVO;
import com.ruoyi.project.system.user.domain.User;
import com.ruoyi.project.tr.HiddenDangerCheckJob.domain.HiddenDangerCheckJob;
import com.ruoyi.project.tr.HiddenDangerCheckJob.mapper.HiddenDangerCheckJobMapper;
import com.ruoyi.project.tr.hiddenDangerCheck.domain.HiddenDangerCheck;
import com.ruoyi.project.tr.hiddenDangerCheckPoint.domain.HiddenDangerCheckPoint;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import java.util.*;
import java.util.stream.Collectors;
import static com.ruoyi.common.utils.security.ShiroUtils.getSysUser;
@@ -54,6 +55,21 @@
    @Autowired
    private PreventRiskCheckUnitService preventRiskCheckUnitService;
    @Autowired
    private PreventRiskJobAndMeasureService preventRiskJobAndMeasureService;
    @Autowired
    private HiddenDangerCheckJobMapper hiddenDangerCheckJobMapper;
    @Autowired
    private PreventRiskDangerCheckLogService preventRiskDangerCheckLogService;
    @Autowired
    private PreventRiskDangerCheckAndMeasureService preventRiskDangerCheckAndMeasureService;
    @Autowired
    private PreventRiskDangerInfoService preventRiskDangerInfoService;
    /**
     * 为设施设备清单附属表添加uuid
     * */
@@ -62,12 +78,74 @@
        String uuid = UUID.randomUUID().toString();
        PreventRiskUnitUuid riskUnitUuid = new PreventRiskUnitUuid();
        //封装参数 todo
        //封装参数
        riskUnitUuid.setRiskUnitId(id);
        riskUnitUuid.setRiskUnitUuid(uuid);
        riskUnitUuid.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
        //获取上报主配置信息
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode());
        //设置本条数据上报更新时间
        riskUnitUuid.setUpdateReportDataTime(new Date());
        //读取上报主配置,进行任务记录上报配置,如果开启上报功能,且设置为自动上报,开启上报相关配置
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
            //设置上报状态为-等待上报
            riskUnitUuid.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            //设置本条数据上报开关为-开启
            riskUnitUuid.setReportSwitch(SyncEnum.REPORT_ON.getCode());
            //其他情况默认不开启上报数据,如果是手动上报,可对单条数据进行操作
        }else {
            //设置上报状态为-不上报
            riskUnitUuid.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
            //设置本条数据上报开关为-关闭
            riskUnitUuid.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
        }
        return preventRiskUnitUuidService.insertRiskUnitUuid(riskUnitUuid);
    }
    /**
     * 修改风险清单附属表
     */
    @Override
    public int updateRiskUnit(Long riskListId) {
        PreventRiskUnitUuid riskUnitUuid = new PreventRiskUnitUuid();
        //封装参数
        riskUnitUuid.setRiskUnitId(riskListId);
        //获取上报主配置信息
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode());
        //设置本条数据上报更新时间
        riskUnitUuid.setUpdateReportDataTime(new Date());
        //读取上报主配置,进行任务记录上报配置,如果开启上报功能,且设置为自动上报,开启上报相关配置
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
            //设置上报状态为-等待上报
            riskUnitUuid.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            //设置本条数据上报开关为-开启
            riskUnitUuid.setReportSwitch(SyncEnum.REPORT_ON.getCode());
            //其他情况默认不开启上报数据,如果是手动上报,可对单条数据进行操作
        }else {
            //设置上报状态为-不上报
            riskUnitUuid.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
            //设置本条数据上报开关为-关闭
            riskUnitUuid.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
        }
        return preventRiskUnitUuidService.updateRiskUnitUuid(riskUnitUuid);
    }
    /**
     * 删除附属表信息
     */
    @Override
    public int deleteRiskUnit(String ids) {
        String[] riskIds = Convert.toStrArray(ids);
        return  preventRiskUnitUuidService.deleteRiskUnit(riskIds);
    }
    /**
     * 风险事件-新增
@@ -646,6 +724,24 @@
        resultVO.setCount(count);
        return resultVO;
    }
    /**
     * 查询管控措施 by 基础排查清单ID
     */
    @Override
    public List<PreventRiskControlMeasure> getRiskControlMeasureByRiskId(Long riskListId) {
        //获取管控措施list
        List<PreventRiskControlMeasure> controlMeasureList = new ArrayList<>();
        //通过riskListId ,查询对应的管控措施id
        List<PreventRiskCheckUnit> unitByRiskId = preventRiskCheckUnitService.getUnitByRiskId(riskListId.toString());
        //遍历集合,封装管控措施
        for (PreventRiskCheckUnit checkUnit : unitByRiskId) {
            PreventRiskControlMeasure controlMeasure = riskControlMeasureService.getPreventRiskControlMeasureById(checkUnit.getControlMeasureId());
            controlMeasureList.add(controlMeasure);
        }
        return controlMeasureList;
    }
    /**
     * 保存原检查点与管控措施的对应关系
@@ -656,8 +752,7 @@
        String uuid = UUID.randomUUID().toString();
        PreventRiskCheckUnit checkUnit = new PreventRiskCheckUnit();
        //封装数据 todo
        //封装数据
        checkUnit.setUuid(uuid);
        checkUnit.setRiskId(pointAndMeasureParams.getRiskId());
        checkUnit.setBaseCheckPointId(pointAndMeasureParams.getBaseCheckPointId());
@@ -670,12 +765,336 @@
        return result;
    }
    /**
     * @description 根据原检查点查询 原检查点与管控措施对应记录
     * 删除原检查点与管控措施的对应关系
     */
    @Override
    public PreventRiskCheckUnit getRiskUnitByBaseCheckPointId(Long checkPointId) {
        return preventRiskCheckUnitService.getRiskUnitByBaseCheckPointId(checkPointId);
    public int deletePointAndMeasure(String ids) {
        String[] idList = Convert.toStrArray(ids);
        for (String id : idList) {
            int result = preventRiskCheckUnitService.deletePointAndMeasure(id);
            if (result < 1){
                return StatusEnum.EXEC_FAIL.getCode();
            }
        }
        return StatusEnum.EXEC_SUCCESS.getCode();
    }
}
    /**
     * 保存job管控措施的附属表
     */
    @Override
    public int insertJobAndMeasure(Long jobId) {
        String jobUuid = UUID.randomUUID().toString();
        PreventRiskJobAndMeasure jobAndMeasure = new PreventRiskJobAndMeasure();
        //根据jobId查询对应的基础排查清单
        HiddenDangerCheckJob jobById = hiddenDangerCheckJobMapper.getJobById(jobId);
        //根据RiskId查询对应的管控措施
        List<PreventRiskCheckUnit> unitByRiskId = preventRiskCheckUnitService.getUnitByRiskId(jobById.getRiskId());
        //遍历管控措施集合
        for (PreventRiskCheckUnit checkUnit : unitByRiskId) {
            PreventRiskControlMeasure preventRiskControlMeasureById = riskControlMeasureService.getPreventRiskControlMeasureById(checkUnit.getControlMeasureId());
            //封装数据
            jobAndMeasure.setJobId(jobId);
            jobAndMeasure.setJobUuid(jobUuid);
            jobAndMeasure.setMeasureId(checkUnit.getControlMeasureId());
            jobAndMeasure.setMeasureUuid(preventRiskControlMeasureById.getUuid());//todo 如果删除了措施 此处可能为空,后续处理
            //获取上报主配置信息
            PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_TASK_FROM_WORK.getCode());
            //设置上报时间为空
            jobAndMeasure.setReportTime(null);
            //设置本条数据上报更新时间
            jobAndMeasure.setUpdateReportDataTime(new Date());
            //读取上报主配置,进行任务记录上报配置,如果开启上报功能,且设置为自动上报,开启上报相关配置
            if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                    && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
                //设置上报状态为-等待上报
                jobAndMeasure.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
                //设置本条数据上报开关为-开启
                jobAndMeasure.setReportSwitch(SyncEnum.REPORT_ON.getCode());
                //其他情况默认不开启上报数据,如果是手动上报,可对单条数据进行操作
            }else {
                //设置上报状态为-不上报
                jobAndMeasure.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
                //设置本条数据上报开关为-关闭
                jobAndMeasure.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
            }
            int result = preventRiskJobAndMeasureService.insertJobAndMeasure(jobAndMeasure);
            if (result < 1 ){
                return StatusEnum.EXEC_FAIL.getCode();
            }
        }
        return StatusEnum.EXEC_SUCCESS.getCode();
    }
    /**
     * 修改job管控措施的附属表
     */
    @Transactional
    @Override
    public int updateJobAndMeasure(HiddenDangerCheckJob hiddenDangerCheckJob) {
        // 2、若有变更,需要预先读取jobAndMeasure的uuid,保存下来
        PreventRiskJobAndMeasure jobAndMeasureByJobId = preventRiskJobAndMeasureService.getJobAndMeasureByJobId(hiddenDangerCheckJob.getJobId());
        String jobUuid = jobAndMeasureByJobId.getJobUuid();
        Date reportTime = jobAndMeasureByJobId.getReportTime();
         if (jobAndMeasureByJobId != null){
             //3、删除库中原关联关系
             int deleteResult = preventRiskJobAndMeasureService.deleteJobAndMeasure(hiddenDangerCheckJob.getJobId());
             if(deleteResult < 1){
                 throw new RuntimeException("清除job管控措施的附属表关联信息失败");
             }
         }
        //4根据RiskId查询对应的管控措施
        List<PreventRiskCheckUnit> unitByRiskId = preventRiskCheckUnitService.getUnitByRiskId(hiddenDangerCheckJob.getRiskId());
        //5封装数据,插入数据库,重新添加关联关系
        for (PreventRiskCheckUnit checkUnit : unitByRiskId) {
            PreventRiskControlMeasure preventRiskControlMeasureById = riskControlMeasureService.getPreventRiskControlMeasureById(checkUnit.getControlMeasureId());
            PreventRiskJobAndMeasure jobAndMeasure = new PreventRiskJobAndMeasure();
            //封装参数
            jobAndMeasure.setJobId(jobAndMeasureByJobId.getJobId());
            //使用保存下来的uuid,再次添加关联关系
            jobAndMeasure.setJobUuid(jobUuid);
            jobAndMeasure.setMeasureId(checkUnit.getControlMeasureId());
            jobAndMeasure.setMeasureUuid(preventRiskControlMeasureById.getUuid());//todo 如果删除了措施 此处可能为空,后续处理
            //获取上报主配置信息
            PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_TASK_FROM_WORK.getCode());
            //设置上报时间
            jobAndMeasure.setReportTime(reportTime);
            //设置本条数据上报更新时间
            jobAndMeasure.setUpdateReportDataTime(new Date());
            //读取上报主配置,进行任务记录上报配置,如果开启上报功能,且设置为自动上报,开启上报相关配置
            if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                    && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
                //设置上报状态为-等待上报
                jobAndMeasure.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
                //设置本条数据上报开关为-开启
                jobAndMeasure.setReportSwitch(SyncEnum.REPORT_ON.getCode());
                //其他情况默认不开启上报数据,如果是手动上报,可对单条数据进行操作
            }else {
                //设置上报状态为-不上报
                jobAndMeasure.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
                //设置本条数据上报开关为-关闭
                jobAndMeasure.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
            }
            int result = preventRiskJobAndMeasureService.insertJobAndMeasure(jobAndMeasure);
            if (result < 1 ){
                return StatusEnum.EXEC_FAIL.getCode();
            }
        }
        return StatusEnum.EXEC_SUCCESS.getCode();
    }
    /**
     * 删除job管控措施的附属表关联信息
     */
    @Transactional
    @Override
    public int deleteJobAndMeasure(String ids) {
        Long[] jobIds = Convert.toLongArray(ids);
        for (Long jobId : jobIds)
        {
            int result = preventRiskJobAndMeasureService.deleteJobAndMeasure(jobId);
            if (result < 1 ){
                throw new RuntimeException("删除job管控措施的附属表关联信息失败");
            }
        }
        return StatusEnum.EXEC_SUCCESS.getCode();
    }
    /**
     * 查询Job与措施
     */
    @Override
    public PreventRiskJobAndMeasure getJobAndMeasure(Long jobId) {
        return  preventRiskJobAndMeasureService.getJobAndMeasureByJobId(jobId);
    }
    /**
     * 定时生成排查任务记录时,
     * 插入排查记录附属表
     */
    @Override
    public int insertDangerCheckLog(Long checkId, HiddenDangerCheck hdc) {
        String dangerCheckUuid = UUID.randomUUID().toString();
        PreventRiskDangerCheckLog dangerCheck = new PreventRiskDangerCheckLog();
        dangerCheck.setUuid(dangerCheckUuid);
        dangerCheck.setCheckStatus(null);
        dangerCheck.setCheckId(checkId);
        dangerCheck.setJobId(hdc.getJobId());
        //获取上报主配置信息
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG__CHECK_RECORD.getCode());
        //设置上报时间为空
        dangerCheck.setReportTime(null);
        //设置本条数据上报更新时间
        dangerCheck.setUpdateReportDataTime(new Date());
        //读取上报主配置,进行任务记录上报配置,如果开启上报功能,且设置为自动上报,开启上报相关配置
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
            //设置上报状态为-等待上报
            dangerCheck.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            //设置本条数据上报开关为-开启
            dangerCheck.setReportSwitch(SyncEnum.REPORT_ON.getCode());
            //其他情况默认不开启上报数据,如果是手动上报,可对单条数据进行操作
        }else {
            //设置上报状态为-不上报
            dangerCheck.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
            //设置本条数据上报开关为-关闭
            dangerCheck.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
        }
            return preventRiskDangerCheckLogService.insertDangerCheckLog(dangerCheck);
    }
    /**
     * 定时生成排查任务记录时,
     * 插入检查点附属表
     */
    @Override
    public void insertCheckAndMeasure(Long id, HiddenDangerCheckPoint hdcp) {
        PreventRiskDangerCheckAndMeasure checkAndMeasure = new PreventRiskDangerCheckAndMeasure();
        //根据检查点信息,查询对应管控措施
        PreventRiskCheckUnit checkUnit = preventRiskCheckUnitService.getUnitByBaseCheckPointId(hdcp.getCheckPointId());
        if (checkUnit == null){
            throw new RuntimeException("基础检查点不存在");
        }
        PreventRiskControlMeasure controlMeasure = riskControlMeasureService.getPreventRiskControlMeasureById(checkUnit.getControlMeasureId());
        if (controlMeasure == null){
            throw new RuntimeException("管控措施已经被删除");
        }
        //封装数据
        checkAndMeasure.setCheckId(hdcp.getCheckId());
        checkAndMeasure.setDangerCheckPointId(id);
        checkAndMeasure.setBaseCheckPointId(hdcp.getCheckPointId());
        checkAndMeasure.setControlMeasureId(controlMeasure.getId());
        checkAndMeasure.setCheckContent(controlMeasure.getCheckContent());
        checkAndMeasure.setCheckResult(null);
        //写入核查任务检查点与管控措施信息
        preventRiskDangerCheckAndMeasureService.insertCheckAndMeasure(checkAndMeasure);
    }
    /**
     * 删除定时核查任务
     * */
    @Override
    @Transactional
    public int deleteDangerCheck(String ids) {
        Long[] dangerCheckIdList = Convert.toLongArray(ids);
        //1、删除核查任务附属表
        for (Long checkId : dangerCheckIdList) {
            int result = preventRiskDangerCheckLogService.deleteDangerCheck(checkId);
            if (result < 1){
                return StatusEnum.EXEC_FAIL.getCode();
            }
        }
        //2、删除核查任务-检查点的附属表----老代码未删除检查点信息,此处暂不做处理
        return StatusEnum.EXEC_SUCCESS.getCode();
    }
    /**
     * 新增隐患上报
     * */
    @Override
    public int insertDangerInfo(Long id, HiddenDangerCheckPoint hdcp) {
        String dangerInfoUuid = UUID.randomUUID().toString();
        PreventRiskDangerInfo dangerInfo = new PreventRiskDangerInfo();
        dangerInfo.setUuid(dangerInfoUuid);
        dangerInfo.setDangerCheckPointId(id);
        dangerInfo.setHazardCode(hdcp.getHazardCode());
        dangerInfo.setDangerSrc(hdcp.getDangerSrc());
        dangerInfo.setDangerDesc(hdcp.getDangerDesc());
        dangerInfo.setDangerReason(hdcp.getDangerReason());
        dangerInfo.setHazardDangerType(hdcp.getHazardDangerType());
        dangerInfo.setDangerState(hdcp.getDangerState());
        dangerInfo.setTimeoutFlag(null);//暂时不清楚是否需要此功能,先设为空
        //获取上报主配置信息
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
        //设置上报时间为空
        dangerInfo.setReportTime(null);
        //设置本条数据上报更新时间
        dangerInfo.setUpdateReportDataTime(new Date());
        //读取上报主配置,进行任务记录上报配置,如果开启上报功能,且设置为自动上报,开启上报相关配置
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
            //设置上报状态为-等待上报
            dangerInfo.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            //设置本条数据上报开关为-开启
            dangerInfo.setReportSwitch(SyncEnum.REPORT_ON.getCode());
            //其他情况默认不开启上报数据,如果是手动上报,可对单条数据进行操作
        }else {
            //设置上报状态为-不上报
            dangerInfo.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
            //设置本条数据上报开关为-关闭
            dangerInfo.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
        }
        return preventRiskDangerInfoService.insertDangerInfo(dangerInfo);
    }
    /**
     * 修改隐患上报
     * */
    @Override
    public int updateDangerInfo(HiddenDangerCheckPoint hdcp) {
        //封装修改数据
        PreventRiskDangerInfo dangerInfo = new PreventRiskDangerInfo();
        dangerInfo.setDangerCheckPointId(hdcp.getId());
        dangerInfo.setHazardCode(hdcp.getHazardCode());
        dangerInfo.setDangerSrc(hdcp.getDangerSrc());
        dangerInfo.setDangerDesc(hdcp.getDangerDesc());
        dangerInfo.setDangerReason(hdcp.getDangerReason());
        dangerInfo.setHazardDangerType(hdcp.getHazardDangerType());
        dangerInfo.setDangerState(hdcp.getDangerState());
        dangerInfo.setTimeoutFlag(null);//暂时不清楚是否需要此功能,先设为空
        //获取上报主配置信息
        PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
        //设置本条数据上报更新时间
        dangerInfo.setUpdateReportDataTime(new Date());
        //读取上报主配置,进行任务记录上报配置,如果开启上报功能,且设置为自动上报,开启上报相关配置
        if (reportConfigById.getReportState() == SyncEnum.REPORT_ON.getCode()
                && reportConfigById.getReportType() == SyncEnum.REPORT_HAND_EXEC_CONFIG.getCode()){
            //设置上报状态为-等待上报
            dangerInfo.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
            //设置本条数据上报开关为-开启
            dangerInfo.setReportSwitch(SyncEnum.REPORT_ON.getCode());
            //其他情况默认不开启上报数据,如果是手动上报,可对单条数据进行操作
        }else {
            //设置上报状态为-不上报
            dangerInfo.setReportStatus(SyncEnum.SYNC_NOT_EXEC.getCode());
            //设置本条数据上报开关为-关闭
            dangerInfo.setReportSwitch(SyncEnum.REPORT_OFF.getCode());
        }
        return preventRiskDangerInfoService.updateDangerInfo(dangerInfo);
    }
    /**
     * 删除隐患上报
     */
    @Override
    public int deleteDangerInfo(Long id) {
        return preventRiskDangerInfoService.deleteDangerInfo(id);
    }
}