From 5ea8ef80312e8c1d3365abe7106622d676def195 Mon Sep 17 00:00:00 2001
From: huangzhen <867127663@qq.com>
Date: Fri, 30 Sep 2022 16:41:09 +0800
Subject: [PATCH] Merge remote-tracking branch 'origin/master'
---
src/main/java/com/ruoyi/doublePrevention/service/impl/RiskServiceImpl.java | 509 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 501 insertions(+), 8 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 ef0310c..f9f216c 100644
--- a/src/main/java/com/ruoyi/doublePrevention/service/impl/RiskServiceImpl.java
+++ b/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.*;
@@ -11,19 +12,21 @@
import com.ruoyi.doublePrevention.enums.ResultCodes;
import com.ruoyi.doublePrevention.enums.StatusEnum;
import com.ruoyi.doublePrevention.enums.SyncEnum;
+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.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;
@@ -49,6 +52,24 @@
@Autowired
private PreventRiskControlMeasureService riskControlMeasureService;
+ @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
* */
@@ -57,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);
+ }
+
/**
* 风险事件-新增
@@ -640,7 +723,417 @@
ResultVO<List<PreventRiskControlMeasurePageQueryRespDTO>> resultVO = new ResultVO<>(ResultCodes.OK,pageResult);
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;
+ }
+
+ /**
+ * 保存原检查点与管控措施的对应关系
+ */
+ @Transactional
+ @Override
+ public int insertPointAndMeasure(PreventPointAndMeasureParams pointAndMeasureParams) {
+
+ String uuid = UUID.randomUUID().toString();
+ PreventRiskCheckUnit checkUnit = new PreventRiskCheckUnit();
+ //封装数据
+ checkUnit.setUuid(uuid);
+ checkUnit.setRiskId(pointAndMeasureParams.getRiskId());
+ checkUnit.setBaseCheckPointId(pointAndMeasureParams.getBaseCheckPointId());
+ checkUnit.setControlMeasureId(pointAndMeasureParams.getControlMeasureId());
+ //执行插入
+ int result = preventRiskCheckUnitService.insertPointAndMeasure(checkUnit);
+ if (result < 1){
+ throw new RuntimeException("保存原检查点与管控措施的对应关系失败");
+ }
+
+ return result;
+ }
+ /**
+ * 删除原检查点与管控措施的对应关系
+ */
+ @Override
+ 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.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);
+ }
+
+ /**
+ * 修改隐患上报
+ * */
+ @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.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.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 updateDangerInfoRectify(HiddenDangerCheckPoint hdcp) {
+
+ //封装修改数据
+ PreventRiskDangerInfo dangerInfo = new PreventRiskDangerInfo();
+
+ dangerInfo.setDangerCheckPointId(hdcp.getId());
+ //需要根据条件，判断附属表隐患状态。
+ // 目前想法：认定后的隐患-0整改中；整改后的隐患-1待验收；整改后的隐患-9已验收。2,3状态暂时未使用
+
+ 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 0;
+ }
+}
\ No newline at end of file
--
Gitblit v1.9.2