From 326c87fed063066712ebb9e408a30d669f8681d3 Mon Sep 17 00:00:00 2001
From: 马宇豪 <978517621@qq.com>
Date: 星期一, 17 六月 2024 09:36:08 +0800
Subject: [PATCH] 添加
---
src/main/java/com/ruoyi/doublePrevention/service/impl/RiskServiceImpl.java | 780 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
1 files changed, 746 insertions(+), 34 deletions(-)
diff --git a/src/main/java/com/ruoyi/doublePrevention/service/impl/RiskServiceImpl.java b/src/main/java/com/ruoyi/doublePrevention/service/impl/RiskServiceImpl.java
index 54d1aa2..7173b16 100644
--- a/src/main/java/com/ruoyi/doublePrevention/service/impl/RiskServiceImpl.java
+++ b/src/main/java/com/ruoyi/doublePrevention/service/impl/RiskServiceImpl.java
@@ -1,31 +1,31 @@
package com.ruoyi.doublePrevention.service.impl;
-import com.baomidou.mybatisplus.core.metadata.IPage;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
+import com.ruoyi.common.constant.TrHiddenDangerCheckConstants;
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.*;
-import com.ruoyi.doublePrevention.enums.ErrorCodes;
-import com.ruoyi.doublePrevention.enums.ResultCodes;
-import com.ruoyi.doublePrevention.enums.StatusEnum;
-import com.ruoyi.doublePrevention.enums.SyncEnum;
+import com.ruoyi.doublePrevention.enums.*;
+import com.ruoyi.doublePrevention.exception.AusinessException;
import com.ruoyi.doublePrevention.repository.param.PreventPointAndMeasureParams;
import com.ruoyi.doublePrevention.service.RiskService;
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.apache.commons.lang3.ObjectUtils;
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 +54,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 +77,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);
+ }
+
/**
* 风险事件-新增
@@ -85,11 +162,11 @@
resultVO.setMsg("安全风险分析单元名称不能为空");
return resultVO;
}
- PreventRiskUnitUuid riskUnit = preventRiskUnitUuidService.getRiskUnitUuidById(riskUnitId);
- if (riskUnit == null){
- resultVO.setMsg("安全风险分析单元名称不存在");
- return resultVO;
- }
+// PreventRiskUnitUuid riskUnit = preventRiskUnitUuidService.getRiskUnitUuidById(riskUnitId);
+// if (riskUnit == null){
+// resultVO.setMsg("安全风险分析单元名称不存在");
+// return resultVO;
+// }
if (StringUtils.isEmpty(riskEventName)){
resultVO.setMsg("安全风险事件名称不能为空");
return resultVO;
@@ -111,7 +188,7 @@
riskEvent.setEventResult(eventResult);
riskEvent.setRiskEventName(riskEventName);
riskEvent.setRiskUnitId(riskUnitId);
- riskEvent.setRiskUnitUuid(riskUnit.getRiskUnitUuid());
+// riskEvent.setRiskUnitUuid(riskUnit.getRiskUnitUuid());
riskEvent.setDeleteStatus(StatusEnum.DELETE_STATUS_USE.getCode());
riskEvent.setGmtCreate(date);
riskEvent.setGmtModitify(date);
@@ -204,11 +281,11 @@
resultVO.setMsg("安全风险分析单元名称不能为空");
return resultVO;
}
- PreventRiskUnitUuid riskUnit = preventRiskUnitUuidService.getRiskUnitUuidById(riskUnitId);
- if (riskUnit == null){
- resultVO.setMsg("安全风险分析单元名称不存在");
- return resultVO;
- }
+// PreventRiskUnitUuid riskUnit = preventRiskUnitUuidService.getRiskUnitUuidById(riskUnitId);
+// if (riskUnit == null){
+// resultVO.setMsg("安全风险分析单元名称不存在");
+// return resultVO;
+// }
if (StringUtils.isEmpty(riskEventName)){
resultVO.setMsg("安全风险事件名称不能为空");
return resultVO;
@@ -292,7 +369,7 @@
*/
@Override
public ResultVO<List<PreventRiskEventPageQueryRespDTO>> listRiskEventPage(PreventRiskEventPageQueryReqDTO riskEventQueryReqDTO) {
- Integer pageIndex = riskEventQueryReqDTO.getPageIndex();
+ Integer pageIndex = riskEventQueryReqDTO.getPageNum();
Integer pageSize = riskEventQueryReqDTO.getPageSize();
if (pageIndex == 0 || pageSize == 0){
return new ResultVO<>(ErrorCodes.REQUEST_PARAM_ERROR.getCode(),"当前页码或当前页显示数不能为0");
@@ -404,7 +481,6 @@
controlMeasure.setCreateByUserName(sysUser.getUserName());
controlMeasure.setRiskEventUuid(riskEvent.getUuid());
- //todo 对所属企业id和uuid没有进行设置
PreventReportConfig reportConfigById = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode());
//设置上报时间为空
controlMeasure.setReportTime(null);
@@ -511,6 +587,7 @@
resultVO.setCode(ResultCodes.OK.getCode());
resultVO.setMsg(ResultCodes.OK.getDesc());
resultVO.setData(dto);
+
return resultVO;
}
@@ -612,7 +689,7 @@
*/
@Override
public ResultVO<List<PreventRiskControlMeasurePageQueryRespDTO>> getRiskControlMeasurePage(PreventRiskControlMeasureQueryReqDTO measureQueryReqDTO) {
- Integer pageIndex = measureQueryReqDTO.getPageIndex();
+ Integer pageIndex = measureQueryReqDTO.getPageNum();
Integer pageSize = measureQueryReqDTO.getPageSize();
if (pageIndex == 0 || pageSize == 0){
return new ResultVO<>(ErrorCodes.REQUEST_PARAM_ERROR.getCode(),"当前页码或当前页显示数不能为0");
@@ -621,7 +698,7 @@
Long riskEventId = measureQueryReqDTO.getRiskEventId();
Page<PreventRiskControlMeasure> page = PageHelper.startPage(pageIndex, pageSize);
- riskControlMeasureService.listRiskEvenByCondition(controlType,riskEventId);
+ riskControlMeasureService.listRiskControlMeasureByCondition(controlType,riskEventId);
List<PreventRiskControlMeasure> result = page.getResult();
Long total = page.getTotal();
@@ -646,6 +723,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;
+ }
/**
* 保存原检查点与管控措施的对应关系
@@ -654,10 +749,22 @@
@Override
public int insertPointAndMeasure(PreventPointAndMeasureParams pointAndMeasureParams) {
+ //参数校验-管控措施id
+ if (pointAndMeasureParams.getControlMeasureId() == null){
+ throw new RuntimeException("管控措施不能为空");
+ }
+ PreventRiskControlMeasure preventRiskControlMeasureById
+ = riskControlMeasureService.getPreventRiskControlMeasureById(pointAndMeasureParams.getControlMeasureId());
+ if (preventRiskControlMeasureById == null){
+ throw new RuntimeException("管控措施不存在");
+ }
+ if (pointAndMeasureParams.getBaseCheckPointId() == null){
+ throw new RuntimeException("检查点添加失败");
+ }
+
String uuid = UUID.randomUUID().toString();
PreventRiskCheckUnit checkUnit = new PreventRiskCheckUnit();
- //封装数据 todo
-
+ //封装数据
checkUnit.setUuid(uuid);
checkUnit.setRiskId(pointAndMeasureParams.getRiskId());
checkUnit.setBaseCheckPointId(pointAndMeasureParams.getBaseCheckPointId());
@@ -670,12 +777,617 @@
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, HiddenDangerCheckJob hiddenDangerCheckJob) {
+
+
+ PreventRiskJobAndMeasure jobAndMeasure = new PreventRiskJobAndMeasure();
+
+ //根据RiskId查询对应的管控措施
+ List<PreventRiskCheckUnit> unitByRiskId = preventRiskCheckUnitService.getUnitByRiskId(hiddenDangerCheckJob.getRiskId());
+
+ //遍历管控措施集合
+ for (PreventRiskCheckUnit checkUnit : unitByRiskId) {
+ String jobUuid = UUID.randomUUID().toString();
+ PreventRiskControlMeasure preventRiskControlMeasureById = riskControlMeasureService.getPreventRiskControlMeasureById(checkUnit.getControlMeasureId());
+ //封装数据
+ jobAndMeasure.setJobId(jobId);
+ jobAndMeasure.setJobUuid(jobUuid);
+ jobAndMeasure.setMeasureId(checkUnit.getControlMeasureId());
+ jobAndMeasure.setMeasureUuid(preventRiskControlMeasureById.getUuid());//如果删除了措施 此处可能为空，后续处理
+ //获取上报主配置信息
+ 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());//如果删除了措施 此处可能为空，后续处理
+
+ //获取上报主配置信息
+ 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((byte) 2);//
+ 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 int insertCheckAndMeasure(Long id, HiddenDangerCheckPoint hdcp) {
+ System.out.println("进入核查点保存方法");
+ PreventRiskDangerCheckAndMeasure checkAndMeasure = new PreventRiskDangerCheckAndMeasure();
+
+ //根据检查点信息，查询对应管控措施
+ PreventRiskCheckUnit checkUnit = preventRiskCheckUnitService.getUnitByBaseCheckPointId(hdcp.getCheckPointId());
+ if (checkUnit == null){
+ throw new RuntimeException("基础检查点不存在");
+ }
+// System.out.println("通过一次检验");
+ PreventRiskControlMeasure controlMeasure = riskControlMeasureService.getPreventRiskControlMeasureById(checkUnit.getControlMeasureId());
+ if (controlMeasure == null){
+ throw new RuntimeException("管控措施已经被删除");
+ }
+// System.out.println("通过二次检验");
+ //封装数据
+ checkAndMeasure.setCheckId(hdcp.getCheckId());
+ checkAndMeasure.setDangerCheckPointId(id);
+ checkAndMeasure.setBaseCheckPointId(hdcp.getCheckPointId());
+ checkAndMeasure.setControlMeasureId(controlMeasure.getId());
+ checkAndMeasure.setCheckContent(controlMeasure.getCheckContent());
+ checkAndMeasure.setCheckResult((byte) 4);
+// System.out.println("数据封装完成");
+ //写入核查任务检查点与管控措施信息
+ int result = preventRiskDangerCheckAndMeasureService.insertCheckAndMeasure(checkAndMeasure);
+ if (result <1){
+ return StatusEnum.EXEC_FAIL.getCode();
+ }
+ return StatusEnum.EXEC_SUCCESS.getCode();
+ }
+ /**
+ * todo-2022 填报时的操作
+ */
+
+ /**
+ * 删除定时核查任务
+ * */
+ @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();
+// if (ObjectUtils.isEmpty(hdcp.getDangerSrc())){
+// throw new RuntimeException("隐患来源为空");
+// }
+// if (ObjectUtils.isEmpty(hdcp.getHazardDangerType())){
+// throw new RuntimeException("隐患类型为空");
+// }
+
+ dangerInfo.setUuid(dangerInfoUuid);
+ dangerInfo.setDangerCheckPointId(id);
+ dangerInfo.setHazardCode(hdcp.getHazardCode());
+ dangerInfo.setDangerSrc(hdcp.getDangerSrc());
+ dangerInfo.setDangerDesc(hdcp.getDangerDescription());
+ dangerInfo.setDangerReason(hdcp.getDangerReason());
+ dangerInfo.setDangerResult(hdcp.getDangerResult());
+ dangerInfo.setHazardDangerType(hdcp.getHazardDangerType());
+// if (ObjectUtils.isNotEmpty(hdcp.getsta))
+ //隐患状态 0未验收 1验收通过 2验收未通过
+ if (hdcp.getAcceptStatus() == null){
+ //设置为 空
+ dangerInfo.setDangerState(StatusEnum.RECTIFY_ING.getCode());
+ } else if (hdcp.getAcceptStatus().equals("0")){
+ //设置为整改中
+ dangerInfo.setDangerState(StatusEnum.RECTIFY_ING.getCode());
+ } else if (hdcp.getAcceptStatus().equals("1")) {
+ //设置为已验收
+ dangerInfo.setDangerState(StatusEnum.ACCEPT_SUCCESS.getCode());
+ }else if (hdcp.getAcceptStatus().equals("2")){
+ //设置为超期未整改
+ dangerInfo.setDangerState(StatusEnum.RECTIFY_TIMEOUT_AND_FAIL.getCode());
+ }
+// dangerInfo.setDangerState(null); //设置为 空
+ 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());
+ }
+ int result = preventRiskDangerInfoService.insertDangerInfo(dangerInfo);
+ return result;
+ }
+
+ /**
+ * 修改隐患上报
+ * */
+ @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.getDangerDescription());
+ dangerInfo.setDangerReason(hdcp.getDangerReason());
+ dangerInfo.setDangerResult(hdcp.getDangerResult());
+ dangerInfo.setHazardDangerType(hdcp.getHazardDangerType());
+ //隐患状态 0未验收 1验收通过 2验收未通过 ，新建时为空
+ if (hdcp.getAcceptStatus() == null){
+ //设置为 空
+ dangerInfo.setDangerState(null);
+ } else if (hdcp.getAcceptStatus().equals(0)){
+ //设置为整改中
+ dangerInfo.setDangerState(StatusEnum.RECTIFY_ING.getCode());
+ } else if (hdcp.getAcceptStatus().equals(1)) {
+ //设置为已验收
+ dangerInfo.setDangerState(StatusEnum.ACCEPT_SUCCESS.getCode());
+ }else if (hdcp.getAcceptStatus().equals(2)){
+ //设置为超期未整改
+ dangerInfo.setDangerState(StatusEnum.RECTIFY_TIMEOUT_AND_FAIL.getCode());
+ }
+ 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);
+ }
+
+ /**
+ * 隐患判定，如果是隐患，修改为整改中
+ */
+ @Override
+ public int updateDangerInfoJudge(HiddenDangerCheckPoint hdcp) {
+
+ //封装修改数据
+ PreventRiskDangerInfo dangerInfo = new PreventRiskDangerInfo();
+
+ dangerInfo.setDangerCheckPointId(hdcp.getId());
+ //需要根据条件，判断附属表隐患状态。
+ //目前想法：认定后的隐患-0整改中；整改后的隐患-1待验收；验收后的隐患-9已验收。2,3状态暂时未使用
+ //设置为整改中
+ dangerInfo.setDangerState(StatusEnum.RECTIFY_ING.getCode());
+ //获取上报主配置信息
+ 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.updateDangerInfoState(dangerInfo);
+ }
+
+ /**
+ * 隐患整改信息 - 修改
+ */
+ @Override
+ public int updateDangerInfoRectify(HiddenDangerCheckPoint hdcp) {
+
+ //封装修改数据
+ PreventRiskDangerInfo dangerInfo = new PreventRiskDangerInfo();
+
+ dangerInfo.setDangerCheckPointId(hdcp.getId());
+ //需要根据条件，判断附属表隐患状态。
+ //目前想法：认定后的隐患-0整改中；整改后的隐患-1待验收；验收后的隐患-9已验收。2,3状态暂时未使用
+ //待验收验收
+ dangerInfo.setDangerState(StatusEnum.RECTIFY_WAIT_ACCEPT.getCode());
+
+ //获取上报主配置信息
+ 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.updateDangerInfoState(dangerInfo);
+ }
+
+ /**
+ * 隐患验收 - 保存验收信息
+ */
+ @Override
+ public int updateDangerInfoAccept(HiddenDangerCheckPoint hdcp) {
+
+ //封装修改数据
+ PreventRiskDangerInfo dangerInfo = new PreventRiskDangerInfo();
+
+ dangerInfo.setDangerCheckPointId(hdcp.getId());
+ int acceptStatus = Integer.parseInt(hdcp.getAcceptStatus());
+ //如果验收通过，设置为验收成功；验收失败，打回上一级进行整改，设置为整改中
+ if (acceptStatus == 0){
+ dangerInfo.setDangerState(StatusEnum.RECTIFY_ING.getCode());
+ }else if (acceptStatus == 1){
+ dangerInfo.setDangerState(StatusEnum.ACCEPT_SUCCESS.getCode());
+ }
+
+ //获取上报主配置信息
+ 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.updateDangerInfoState(dangerInfo);
+ }
+
+ /**
+ * @description 获取所有的风险分析单元的编码和姓名
+ */
+ @Override
+ public List<PreventRiskUnitCodeAndNameListQueryRespDTO> listRiskUnitCodeAndName() {
+ List<PreventRiskList> riskLists = preventRiskListService.listRiskUnitCodeAndName();
+ if (riskLists == null){
+ return null;
+ }
+ List<PreventRiskUnitCodeAndNameListQueryRespDTO> listQueryRespDTOs= riskLists.stream().map((riskList)->{
+ PreventRiskUnitCodeAndNameListQueryRespDTO listQueryRespDTO = new PreventRiskUnitCodeAndNameListQueryRespDTO();
+ BeanUtils.copyProperties(riskList,listQueryRespDTO);
+ return listQueryRespDTO;
+ }).collect(Collectors.toList());
+ return listQueryRespDTOs;
+ }
+
+ /**
+ * 管控措施-不分页查询
+ */
+ @Override
+ public ResultVO<List<PreventRiskControlMeasureListQueryRespDTO>> listRiskControlMeasure() {
+
+ List<PreventRiskControlMeasure> controlMeasures = riskControlMeasureService.listRiskControlMeasure();
+ List<PreventRiskControlMeasureListQueryRespDTO> pageResult = null;
+ if (controlMeasures != null) {
+ pageResult = controlMeasures.stream().map((preventRiskControlMeasure) -> {
+ PreventRiskControlMeasureListQueryRespDTO dto = new PreventRiskControlMeasureListQueryRespDTO();
+ BeanUtils.copyProperties(preventRiskControlMeasure, dto);
+ return dto;
+ }).collect(Collectors.toList());
+ }
+
+ ResultVO<List<PreventRiskControlMeasureListQueryRespDTO>> resultVO = new ResultVO<>(ResultCodes.OK,pageResult);
+ return resultVO;
+ }
+
+ /**
+ * 通过排查点，查找管控措施id
+ */
+ @Override
+ public PreventRiskCheckUnit getRiskControlMeasureByCheckPointId(Long checkPointId) {
+ return preventRiskCheckUnitService.getUnitByBaseCheckPointId(checkPointId);
+ }
+
+ /**
+ * 查询管控措施信息
+ */
+ @Override
+ public PreventRiskControlMeasure getRiskControlMeasureInfo(Long checkPointId) {
+
+ PreventRiskCheckUnit unitByBaseCheckPointId = preventRiskCheckUnitService.getUnitByBaseCheckPointId(checkPointId);
+// if (ObjectUtils.isEmpty(unitByBaseCheckPointId)){
+// throw new AusinessException(E.DATA_DATABASE_DUPLICATED, "数据不存在或已被删除");
+// }
+ return riskControlMeasureService.getPreventRiskControlMeasureById(unitByBaseCheckPointId.getControlMeasureId());
+ }
+
+ /**
+ * 查询隐患附属表信息
+ */
+ @Override
+ public PreventRiskDangerInfo getDangerInfoById(Long id) {
+ PreventRiskDangerInfo dangerInfobyHiddenDangerId = preventRiskDangerInfoService.getByHiddenDangerId(id);
+ return dangerInfobyHiddenDangerId;
+ }
+
+ @Override
+ public int updateCheckLog(Long checkId, HiddenDangerCheckPoint hdcp) {
+ return preventRiskDangerCheckLogService.updateCheckLog(checkId, hdcp.getMobileCode());
+ }
+
+ @Override
+ public PreventRiskDangerInfo getDangerInfoByDangerCheckPointId(Long checkId) {
+ return preventRiskDangerInfoService.getDangerInfoByDangerCheckPointId(checkId);
+ }
+
+
+ // /**
+// * 全流程 隐患上报-附属表信息插入
+// * */
+// @Override
+// public int insertAllDangerInfo(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.setDangerResult(hdcp.getDangerResult());
+// 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);
+// }
+
+
+}
\ No newline at end of file
--
Gitblit v1.9.2