package com.ruoyi.doublePrevention.scheduls;
|
|
|
import com.alibaba.fastjson.JSONObject;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.doublePrevention.entity.*;
|
import com.ruoyi.doublePrevention.entity.CJReport.*;
|
import com.ruoyi.doublePrevention.enums.E;
|
import com.ruoyi.doublePrevention.enums.SyncEnum;
|
import com.ruoyi.doublePrevention.exception.AusinessException;
|
import com.ruoyi.doublePrevention.repository.param.HandlerReportParam;
|
import com.ruoyi.doublePrevention.service.baseService.*;
|
import com.ruoyi.project.system.dept.domain.Dept;
|
import com.ruoyi.project.system.dept.service.IDeptService;
|
import com.ruoyi.project.system.user.domain.User;
|
import com.ruoyi.project.system.user.service.IUserService;
|
import com.ruoyi.project.tr.HiddenDangerCheckJob.domain.HiddenDangerCheckJob;
|
import com.ruoyi.project.tr.HiddenDangerCheckJob.service.IHiddenDangerCheckJobService;
|
import com.ruoyi.project.tr.hiddenDangerCheck.domain.HiddenDangerCheck;
|
import com.ruoyi.project.tr.hiddenDangerCheck.service.IHiddenDangerCheckService;
|
import com.ruoyi.project.tr.hiddenDangerCheckPoint.domain.HiddenDangerCheckPoint;
|
import com.ruoyi.project.tr.hiddenDangerCheckPoint.service.IHiddenDangerCheckPointService;
|
import com.ruoyi.project.tr.riskList.domain.RiskList;
|
import com.ruoyi.project.tr.riskList.service.IRiskListService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang3.ObjectUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.scheduling.annotation.Scheduled;
|
import org.springframework.stereotype.Component;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
|
@Slf4j
|
@Component
|
public class SearchReportDateSchedule {
|
|
|
public static SimpleDateFormat startFormat = new SimpleDateFormat("yyyy-MM-dd 06:30:00");
|
public static SimpleDateFormat endFormat = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
|
|
public static SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
|
@Autowired
|
private PreventReportConfigService preventReportConfigService;
|
|
@Autowired
|
private PreventCJReportRiskAnaUnitService CJRiskAnaUnitService;
|
@Autowired
|
private PreventCJReportRiskEventService CJEventService;
|
@Autowired
|
private PreventCJReportRiskControlMeasureService CJMeasureService;
|
@Autowired
|
private PreventCJReportCheckTaskFromWorkService CJTaskFromWorkService;
|
@Autowired
|
private PreventCJReportCheckRecordFromTaskService CJTaskRecordService;
|
@Autowired
|
private PreventCJReportDangerInfoService CJDangerInfoService;
|
@Autowired
|
private PreventCJReportPointService CJPointService;
|
|
|
@Autowired
|
private IDeptService trDeptService; //部门服务
|
@Autowired
|
private IUserService trUserService; //用户服务
|
|
@Autowired
|
private IRiskListService trRiskAnaUnitService; //风险设备、分析单元
|
@Autowired
|
private PreventRiskUnitUuidService preventRiskUnitUuidService; //风险设备、分析单元附属表
|
|
@Autowired
|
private PreventRiskEventService preventRiskEventService;
|
@Autowired
|
private PreventRiskControlMeasureService preventRiskControlMeasureService;
|
@Autowired
|
private PreventRiskControlTemplateService preventRiskControlTemplateService;
|
|
@Autowired
|
private IHiddenDangerCheckJobService trHiddenDangerCheckJobService;//排查任务job
|
@Autowired
|
private PreventRiskJobAndMeasureService preventRiskJobAndMeasureService;//排查任务附属表
|
|
@Autowired
|
private IHiddenDangerCheckService trHiddenDangerCheckService;//排查任务记录
|
@Autowired
|
private PreventRiskDangerCheckLogService preventRiskDangerCheckLogService;//排查任务记录附属表
|
|
@Autowired
|
private IHiddenDangerCheckPointService trHiddenDangerCheckPointService;//隐患信息上报、整改、验收
|
@Autowired
|
private PreventRiskDangerInfoService preventRiskDangerInfoService;//隐患信息附属表
|
|
@Autowired
|
private PreventRiskCheckUnitService preventRiskCheckUnitService;//管控措施，任务清单对应关系。基础排查点附属表
|
@Autowired
|
private PreventRiskDangerCheckAndMeasureService riskDangerCheckAndMeasureService;//管控措施，任务清单对应关系。基础排查点附属表
|
|
@Autowired
|
private PreventTaskTypeService taskTypeService;//管控措施，任务清单对应关系。基础排查点附属表
|
|
@Autowired
|
private PreventOverhaulLogService overhaulLogService;
|
@Autowired
|
private PreventCJReportOverhaulLogService reportOverhaulLogService;
|
|
|
@Transactional
|
@Scheduled(cron = "0 0/2 * * * ? ") // 分钟
|
// @Scheduled(cron = "0/10 * * * * ?") // 30秒
|
// @Scheduled(cron = "0 0/25 * * * ? ") // 分钟
|
public void searchReportDate() {
|
|
log.info("【双重预防】定时检索需要上报数据...");
|
int step = 1;
|
String companyCode = "652310082";
|
|
/**
|
* 1、检索风险分析单元
|
* */
|
//读取风险分析单元数据上报主配置信息
|
PreventReportConfig unitReportConfig = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode());
|
//如果主配置开启上报，开始
|
if (unitReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())) {
|
|
log.info("【##】1.检索风险分析单元...");
|
|
//查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
List<PreventRiskUnitUuid> riskUnitUuidList = preventRiskUnitUuidService.listRiskAnaUnit();
|
//获取上报数据list
|
// List<PreventReportRiskAnaUnit> unitLists = new ArrayList<>();
|
List<PreventCJReportRiskAnaUnit> CJUnitLists = new ArrayList<>();
|
if (ObjectUtils.isNotEmpty(riskUnitUuidList)) {
|
HandlerReportParam handlerReportParam = new HandlerReportParam();
|
//遍历，封装数据
|
for (PreventRiskUnitUuid riskUnitUuid : riskUnitUuidList) {
|
//查询漯安表中对应数据
|
RiskList infoByRiskId = trRiskAnaUnitService.getInfoByRiskListId(riskUnitUuid.getRiskUnitId());
|
//获取上报数据对象
|
PreventCJReportRiskAnaUnit CJReportRiskAnaUnit = new PreventCJReportRiskAnaUnit();
|
|
//此类方法已经修改，实际使用username
|
User createUser = trUserService.getUserByLoginName(infoByRiskId.getCreateBy());
|
User updateUser = trUserService.getUserByLoginName(infoByRiskId.getUpdateBy());
|
User userById = trUserService.getUserById(infoByRiskId.getUserId());
|
Dept depById = trDeptService.getDepById(infoByRiskId.getDeptId());
|
|
//封装上报昌吉州的风险分析单元数据
|
CJReportRiskAnaUnit.setId(riskUnitUuid.getRiskUnitUuid());//此处封装附属表的uuid
|
CJReportRiskAnaUnit.setCompanyCode(companyCode);
|
CJReportRiskAnaUnit.setRiskUnitName(infoByRiskId.getRiskListName());
|
CJReportRiskAnaUnit.setHazardCode(infoByRiskId.getRiskListNum());
|
CJReportRiskAnaUnit.setHazardDep(depById.getDeptName());
|
CJReportRiskAnaUnit.setHazardLiablePerson(userById.getUserName());
|
CJReportRiskAnaUnit.setDeleted("0");
|
// if (riskUnitUuid.getReportStatus().equals(SyncEnum.SYNC_EXEC_SUCCESS.getCode())){
|
// CJReportRiskAnaUnit.setDeleted("2");//数据更新状态标识，目前仅昌吉州需要 2022-08-10
|
// }else {
|
// CJReportRiskAnaUnit.setDeleted(riskAnaUnit.getDeleteStatus().toString());
|
// }
|
CJReportRiskAnaUnit.setCreateBy(createUser.getUserName());
|
CJReportRiskAnaUnit.setCreateDate(infoByRiskId.getCreateTime());
|
if (ObjectUtils.isEmpty(updateUser)) {
|
CJReportRiskAnaUnit.setUpdateBy(createUser.getUserName());
|
CJReportRiskAnaUnit.setUpdateDate(infoByRiskId.getUpdateTime());
|
} else {
|
CJReportRiskAnaUnit.setUpdateBy(updateUser.getUserName());
|
CJReportRiskAnaUnit.setUpdateDate(infoByRiskId.getCreateTime());
|
}
|
CJReportRiskAnaUnit.setDataSource((byte) 1);
|
CJReportRiskAnaUnit.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
CJReportRiskAnaUnit.setReportTime(null);
|
CJReportRiskAnaUnit.setZhunReportTime(null);
|
CJReportRiskAnaUnit.setZhunReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
CJReportRiskAnaUnit.setRiskUnitId(infoByRiskId.getRiskListId());//此处封装主表的id
|
//封装数据
|
CJUnitLists.add(CJReportRiskAnaUnit);
|
//修改原始数据状态为待上传
|
handlerReportParam.setId(riskUnitUuid.getId());//此处修改的是附属表
|
handlerReportParam.setReportTime(new Date());
|
handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
int result = preventRiskUnitUuidService.updateReportStatus(handlerReportParam);
|
}
|
} else {
|
log.info("【双重预防】当前无风险分析单元数据需要处理");
|
}
|
//写入昌吉州转换表
|
for (PreventCJReportRiskAnaUnit CJUnit : CJUnitLists) {
|
CJRiskAnaUnitService.insertUnitList(CJUnit);
|
log.info("【双重预防】1.风险分析单元CJ：数据处理...");
|
}
|
step = 2;
|
} else {
|
step = 2;
|
log.info("风险分析单元数据上报已关闭");
|
}
|
|
|
/**
|
* 2、检索安全风险事件数据
|
* */
|
//读取风险分析单元数据上报主配置信息
|
PreventReportConfig eventReportConfig = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_EVENT.getCode());
|
//如果风险事件主配置开启上报
|
if (eventReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())) {
|
|
//logger.info("【##】2.检索安全风险事件...");
|
//查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
List<PreventRiskEvent> riskEvents = preventRiskEventService.listReportEvent();
|
//获取上报数据对象与list
|
List<PreventCJReportRiskEvent> CJEventLists = new ArrayList<>();
|
if (ObjectUtils.isNotEmpty(riskEvents)) {
|
//遍历，封装数据
|
for (PreventRiskEvent riskEvent : riskEvents) {
|
//String eventUuid = UUID.randomUUID().toString();
|
HandlerReportParam handlerReportParam = new HandlerReportParam();
|
PreventCJReportRiskEvent CJReportRiskEvent = new PreventCJReportRiskEvent();
|
//封装上报昌吉州风险事件数据
|
CJReportRiskEvent.setId(riskEvent.getUuid());
|
CJReportRiskEvent.setCompanyCode(companyCode);
|
if (riskEvent.getReportStatus().equals(SyncEnum.SYNC_EXEC_SUCCESS.getCode())) {
|
CJReportRiskEvent.setDeleted("2");//数据更新状态标识，目前仅昌吉州需要 2022-08-10
|
} else {
|
CJReportRiskEvent.setDeleted("0");
|
}
|
CJReportRiskEvent.setCreateBy(riskEvent.getCreateByUserName());
|
CJReportRiskEvent.setCreateDate(riskEvent.getGmtCreate());
|
CJReportRiskEvent.setUpdateBy(riskEvent.getCreateByUserName());
|
CJReportRiskEvent.setUpdateDate(riskEvent.getGmtModitify());
|
CJReportRiskEvent.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
CJReportRiskEvent.setReportTime(null);
|
CJReportRiskEvent.setZhunReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
CJReportRiskEvent.setZhunReportTime(null);
|
CJReportRiskEvent.setDataSource((byte) 1);
|
PreventRiskUnitUuid riskUnitUuidByUnitId = preventRiskUnitUuidService.getRiskUnitUuidByUnitId(riskEvent.getRiskUnitId());
|
CJReportRiskEvent.setRiskUnitId(riskUnitUuidByUnitId.getRiskUnitUuid());
|
CJReportRiskEvent.setRiskEventName(riskEvent.getRiskEventName());
|
CJReportRiskEvent.setRiskEventId(riskEvent.getId());
|
//封装数据
|
CJEventLists.add(CJReportRiskEvent);
|
//设置原始数据上报状态
|
handlerReportParam.setId(riskEvent.getId());
|
handlerReportParam.setReportTime(new Date());
|
handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
preventRiskEventService.updateEventReportStatus(handlerReportParam);
|
}
|
} else {
|
log.info("【双重预防】当前无安全风险事件数据需要处理");
|
}
|
//写入昌吉州转换表
|
for (PreventCJReportRiskEvent CJEvent : CJEventLists) {
|
CJEventService.insertEventLists(CJEvent);
|
log.info("【双重预防】2.风险分析事件CJ：数据处理...");
|
}
|
step = 3;
|
} else {
|
step = 3;
|
log.info("安全风险事件数据上报已关闭");
|
}
|
|
|
/**
|
* 3、检索安全风险管控措施数据
|
* */
|
//读取安全风险管控措施数据上报主配置信息
|
PreventReportConfig measureReportConfig = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_MEASURE.getCode());
|
//如果安全风险管控措施主配置开启上报
|
if (measureReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())) {
|
//logger.info("{【##】3.检索安全风险管控措施...");
|
|
//查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
List<PreventRiskControlMeasure> measures = preventRiskControlMeasureService.listReportMeasure();
|
//获取上报数据list
|
List<PreventCJReportRiskControlMeasure> CJMeasureLists = new ArrayList<>();
|
HandlerReportParam handlerReportParam = new HandlerReportParam();
|
|
if (ObjectUtils.isNotEmpty(measures)) {
|
//遍历，封装数据
|
for (PreventRiskControlMeasure measure : measures) {
|
String measureUuid = UUID.randomUUID().toString();
|
//获取上报数据对象
|
PreventCJReportRiskControlMeasure CJReportMeasure = new PreventCJReportRiskControlMeasure();
|
//转换数据
|
PreventRiskControlTemplate controlTemplateById = preventRiskControlTemplateService.getControlTemplateById(measure.getClassify2());
|
String classify2 = measure.getClassify1() + "-" + controlTemplateById.getOrderIndex();
|
|
//封装上报昌吉州管控措施数据
|
CJReportMeasure.setId(measure.getUuid());
|
CJReportMeasure.setCompanyCode(companyCode);
|
if (measure.getReportStatus().equals(SyncEnum.SYNC_EXEC_SUCCESS.getCode())) {
|
CJReportMeasure.setDeleted("2");//数据更新状态标识，目前仅昌吉州需要 2022-08-10
|
} else {
|
CJReportMeasure.setDeleted("0");
|
}
|
CJReportMeasure.setCreateBy(measure.getCreateByUserName());
|
CJReportMeasure.setCreateDate(measure.getGmtCreate());
|
CJReportMeasure.setUpdateBy(measure.getCreateByUserName());
|
CJReportMeasure.setUpdateDate(measure.getGmtModitify());
|
CJReportMeasure.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
CJReportMeasure.setReportTime(null);
|
CJReportMeasure.setZhunReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
CJReportMeasure.setZhunReportTime(null);
|
CJReportMeasure.setDataSource((byte) 1);
|
CJReportMeasure.setRiskEventId(measure.getRiskEventUuid());
|
CJReportMeasure.setRiskMeasureDesc(measure.getMeasureDesc());
|
CJReportMeasure.setDataSrc(measure.getControlType().toString());
|
CJReportMeasure.setClassify1(measure.getClassify1().toString());
|
CJReportMeasure.setClassify2(classify2);
|
CJReportMeasure.setClassify3(measure.getClassify3());
|
CJReportMeasure.setRiskMeasureId(measure.getId());
|
CJReportMeasure.setTroubleshootContent(measure.getCheckContent());
|
|
|
//封装数据
|
CJMeasureLists.add(CJReportMeasure);
|
//设置原始数据上报状态
|
handlerReportParam.setId(measure.getId());
|
handlerReportParam.setReportTime(new Date());
|
handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
preventRiskControlMeasureService.updateMeasureReportStatus(handlerReportParam);
|
}
|
} else {
|
log.info("【双重预防】当前无安全风险管控措施数据需要处理");
|
}
|
|
step = 4;
|
|
//写入上报昌吉州转换表
|
for (PreventCJReportRiskControlMeasure CJMeasure : CJMeasureLists) {
|
CJMeasureService.insertMeasureList(CJMeasure);
|
|
log.info("【双重预防】3.安全风险管控措施CJ：数据处理...");
|
}
|
} else {
|
step = 4;
|
log.info("安全风险管控措施数据上报已关闭");
|
}
|
|
/**
|
* 4、检索 任务配置 数据 prevent_report_check_record_from_task
|
* */
|
//读取任务配置数据上报主配置信息
|
PreventReportConfig workReportConfig = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_TASK_FROM_WORK.getCode());
|
//如果任务配置主配置开启上报
|
if (workReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())) {
|
// logger.info("【##】4.检索任务配置...");
|
//查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
List<PreventRiskJobAndMeasure> works = preventRiskJobAndMeasureService.listReportWork();
|
//获取上报数据对象与list
|
List<PreventCJReportCheckTaskFromWork> CJTaskFromWorkLists = new ArrayList<>();
|
HandlerReportParam handlerReportParam = new HandlerReportParam();
|
log.info("检索任务配置开始执行,{}", works.size());
|
if (ObjectUtils.isNotEmpty(works)) {
|
//遍历，封装数据
|
for (PreventRiskJobAndMeasure work : works) {
|
//通过work中的信息，查询主表数据
|
HiddenDangerCheckJob jobById = trHiddenDangerCheckJobService.getJobById(work.getJobId());
|
//获取数据对象
|
PreventCJReportCheckTaskFromWork CJTaskFromWork = new PreventCJReportCheckTaskFromWork();
|
//转换时间周期单位 (1小时,2日,3周,4月,5年)
|
if (jobById.getTroubleshootTypeCycleType() == 1) {
|
CJTaskFromWork.setCheckCycle(Math.toIntExact(jobById.getTroubleshootTypeCycleNum()));
|
CJTaskFromWork.setCheckCycleUnit("小时");
|
CJTaskFromWork.setWorkStartTime("00:00:00");
|
CJTaskFromWork.setWorkEndTime("23:59:59");
|
} else if (jobById.getTroubleshootTypeCycleType() == 2) {
|
CJTaskFromWork.setCheckCycle(Math.toIntExact(jobById.getTroubleshootTypeCycleNum()));
|
CJTaskFromWork.setCheckCycleUnit("天");
|
} else if (jobById.getTroubleshootTypeCycleType() == 3) {
|
Long num = jobById.getTroubleshootTypeCycleNum() * 7;
|
CJTaskFromWork.setCheckCycle(Math.toIntExact(num));
|
CJTaskFromWork.setCheckCycleUnit("天");
|
} else if (jobById.getTroubleshootTypeCycleType() == 4) {
|
CJTaskFromWork.setCheckCycle(Math.toIntExact(jobById.getTroubleshootTypeCycleNum()));
|
CJTaskFromWork.setCheckCycleUnit("月");
|
} else if (jobById.getTroubleshootTypeCycleType() == 5) {
|
CJTaskFromWork.setCheckCycle(Math.toIntExact(jobById.getTroubleshootTypeCycleNum()));
|
CJTaskFromWork.setCheckCycleUnit("年");
|
}
|
//获取用户信息
|
User createUser = new User();
|
User updateUser = new User();
|
createUser = trUserService.getUserByLoginName(jobById.getCreateBy());
|
if (ObjectUtils.isEmpty(createUser)) {
|
createUser = trUserService.getUserByName(jobById.getCreateBy());
|
}
|
|
updateUser = trUserService.getUserByLoginName(jobById.getUpdateBy());
|
if (ObjectUtils.isEmpty(updateUser)) {
|
updateUser = trUserService.getUserByName(jobById.getUpdateBy());
|
}
|
|
//封装上报昌吉州任务配置数据
|
CJTaskFromWork.setId(work.getJobUuid());
|
CJTaskFromWork.setCompanyCode(companyCode);
|
if (work.getReportStatus().equals(SyncEnum.SYNC_EXEC_SUCCESS.getCode())) {
|
CJTaskFromWork.setDeleted("2");//数据更新状态标识，目前仅昌吉州需要 2022-08-10
|
} else {
|
CJTaskFromWork.setDeleted("0");
|
}
|
CJTaskFromWork.setCreateBy(createUser.getUserName());
|
CJTaskFromWork.setCreateDate(jobById.getCreateTime());
|
if (ObjectUtils.isEmpty(updateUser)) {
|
CJTaskFromWork.setUpdateBy(createUser.getUserName());
|
CJTaskFromWork.setUpdateDate(jobById.getCreateTime());
|
} else {
|
CJTaskFromWork.setUpdateBy(updateUser.getUserName());
|
CJTaskFromWork.setUpdateDate(jobById.getCreateTime());
|
}
|
CJTaskFromWork.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
CJTaskFromWork.setReportTime(null);
|
CJTaskFromWork.setZhunReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
CJTaskFromWork.setZhunReportTime(null);
|
CJTaskFromWork.setDataSource((byte) 1);
|
CJTaskFromWork.setRiskMeasureId(work.getMeasureUuid());
|
CJTaskFromWork.setWorkId(jobById.getJobId());
|
|
//第二版标准新增
|
PreventRiskControlMeasure measureById = preventRiskControlMeasureService.getPreventRiskControlMeasureById(work.getMeasureId());
|
CJTaskFromWork.setTroubleshootContent(measureById.getCheckContent());
|
CJTaskFromWork.setTaskStartTime(jobById.getStartTime());
|
|
CJTaskFromWork.setWorkDayType("0");
|
List<PreventTaskType> typeByJobId = taskTypeService.getInfoByJobId(work.getJobId());
|
int typeTag = 0;
|
for (PreventTaskType taskType : typeByJobId) {
|
typeTag = taskType.getType();
|
}
|
if (typeTag != 0) {
|
CJTaskFromWork.setTaskNum("1");
|
}
|
CJTaskFromWork.setWorkType(String.valueOf(typeTag));
|
|
//封装数据
|
CJTaskFromWorkLists.add(CJTaskFromWork);
|
//设置原始数据上报状态
|
handlerReportParam.setId(work.getId());
|
handlerReportParam.setReportTime(new Date());
|
handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
preventRiskJobAndMeasureService.updateWorkReportStatus(handlerReportParam);
|
}
|
} else {
|
log.info("【双重预防】当前无任务配置数据需要处理");
|
}
|
//写入上报昌吉州数据转换表
|
log.info("【双重预防】任务配置CJ数量:{}", CJTaskFromWorkLists.size());
|
for (PreventCJReportCheckTaskFromWork CJTaskFromWorks : CJTaskFromWorkLists) {
|
CJTaskFromWorkService.insertTaskFromWorkList(CJTaskFromWorks);
|
log.info("【双重预防】任务配置CJ：数据处理...");
|
}
|
} else {
|
step = 5;
|
log.info("任务配置数据上报已关闭");
|
}
|
|
|
/**
|
* 5、排查任务记录数据 PreventReportCheckRecordFromTask
|
* */
|
//读取安全风险管控措施数据上报主配置信息
|
PreventReportConfig recordReportConfig = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG__CHECK_RECORD.getCode());
|
//如果安全风险管控措施主配置开启上报
|
if (recordReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())) {
|
|
//logger.info("【##】5.检索排查任务记录数据...");
|
log.info("【##】5.检索排查任务记录数据...");
|
|
//查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
List<PreventRiskDangerCheckLog> tasks = preventRiskDangerCheckLogService.listReportTask();
|
List<Long> taskIds = new ArrayList<>();
|
//获取上报数据对象
|
List<PreventCJReportCheckRecordFromTask> CJRecordFromTaskLists = new ArrayList<>();
|
int tag = 0;
|
// HandlerReportParam handlerReportParam = new HandlerReportParam();
|
// List<HandlerReportParam> handlerReportParamList = new ArrayList<>();
|
if (ObjectUtils.isNotEmpty(tasks)) {
|
//获取信息
|
List<User> allUserList = trUserService.getAllUser();
|
List<PreventRiskControlMeasure> allMeasureList = preventRiskControlMeasureService.getAllMeasureList();
|
List<PreventTaskType> allTaskTypeList = taskTypeService.getAllTaskTypeList();
|
//遍历，封装数据
|
for (PreventRiskDangerCheckLog task : tasks) {
|
//获取任务记录主表信息
|
HiddenDangerCheck hiddenDangerCheckById = trHiddenDangerCheckService.getHiddenDangerCheckById(task.getCheckId());
|
//转换检查结果
|
//如果已经执行过，进入方法
|
if (Integer.valueOf(hiddenDangerCheckById.getScheduleCheckStatus()) == 1) {
|
|
List<HiddenDangerCheckPoint> hiddenDangerCheckPointList = trHiddenDangerCheckPointService.getHiddenDangerCheckPointByCheckId(task.getCheckId());
|
|
//避免个别任务无检查点的情况
|
if (ObjectUtils.isEmpty(hiddenDangerCheckPointList)) {
|
log.info("【双重预防】排查任务记录CJ：异常，无检查点...");
|
} else {
|
for (HiddenDangerCheckPoint hiddenDangerCheckPoint : hiddenDangerCheckPointList) {
|
//获取上报数据对象
|
PreventCJReportCheckRecordFromTask CJRecordFromTask = new PreventCJReportCheckRecordFromTask();
|
CJRecordFromTask.setCheckStatus("0");// 0-正常；1-存在隐患；2-未处理；3-其他
|
if (Integer.valueOf(hiddenDangerCheckPoint.getWhetherDanger()) == 1) {
|
CJRecordFromTask.setCheckStatus("1");// 0-正常；1-存在隐患；2-未处理；3-其他
|
}
|
|
User createUser = new User();
|
User updateUser = new User();
|
// createUser = trUserService.getUserByLoginName(hiddenDangerCheckById.getCreateBy());
|
// if(ObjectUtils.isEmpty(createUser)){
|
// createUser = trUserService.getUserByName(hiddenDangerCheckById.getCreateBy());
|
// }
|
// updateUser = trUserService.getUserByLoginName(hiddenDangerCheckById.getUpdateBy());
|
|
|
// todo 取出所有用户信息，再循环在匹配
|
for (User user : allUserList) {
|
if (hiddenDangerCheckById.getCreateBy().equals(user.getLoginName())) {
|
createUser = user;
|
}
|
if (hiddenDangerCheckById.getUpdateBy().equals(user.getLoginName())) {
|
updateUser = user;
|
}
|
}
|
if (ObjectUtils.isEmpty(createUser)) {
|
for (User user : allUserList) {
|
if (hiddenDangerCheckById.getCreateBy().equals(user.getUserName())) {
|
createUser = user;
|
}
|
}
|
}
|
|
|
//封装上报昌吉州的任务数据
|
// String taskUuid = UUID.randomUUID().toString();
|
CJRecordFromTask.setId(UUID.randomUUID().toString());
|
CJRecordFromTask.setCompanyCode(companyCode);
|
CJRecordFromTask.setCreateBy(createUser.getUserName());
|
CJRecordFromTask.setCreateDate(hiddenDangerCheckById.getCreateTime());
|
CJRecordFromTask.setCreateByMobile(createUser.getPhonenumber());
|
if (ObjectUtils.isEmpty(updateUser)) {
|
CJRecordFromTask.setUpdateBy(createUser.getUserName());
|
CJRecordFromTask.setUpdateDate(hiddenDangerCheckById.getCreateTime());
|
CJRecordFromTask.setUpdateByMobile(createUser.getPhonenumber());
|
} else {
|
CJRecordFromTask.setUpdateBy(updateUser.getUserName());
|
CJRecordFromTask.setUpdateDate(hiddenDangerCheckById.getUpdateTime());
|
CJRecordFromTask.setUpdateByMobile(updateUser.getPhonenumber());
|
}
|
|
if (task.getReportStatus().equals(SyncEnum.SYNC_EXEC_SUCCESS.getCode())) {
|
CJRecordFromTask.setDeleted("2");//数据更新状态标识，目前仅昌吉州需要 2022-08-10
|
} else {
|
CJRecordFromTask.setDeleted("0");
|
}
|
CJRecordFromTask.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
CJRecordFromTask.setReportTime(null);
|
CJRecordFromTask.setZhunReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
CJRecordFromTask.setZhunReportTime(null);
|
CJRecordFromTask.setDataSource((byte) 1);
|
List<PreventRiskDangerCheckAndMeasure> baseCheckPointAndMeasure = riskDangerCheckAndMeasureService.getByBaseCheckPointId(hiddenDangerCheckPoint.getCheckPointId());
|
//获取该条记录对应的管控措施id，
|
Long controlMeasureId = 1L;
|
for (PreventRiskDangerCheckAndMeasure checkAndMeasure : baseCheckPointAndMeasure) {
|
controlMeasureId = checkAndMeasure.getControlMeasureId();
|
}
|
// //获取该条记录对应的管控措施uuid
|
// PreventRiskControlMeasure preventRiskControlMeasureById = preventRiskControlMeasureService.getPreventRiskControlMeasureById(controlMeasureId);
|
// //通过管控措施uuid ，jobId(workId)，在任务上报表中，找到任务对应的uuid
|
// PreventCJReportCheckTaskFromWork preventCJReportCheckTaskFromWork = CJTaskFromWorkService.geByMeasureUUidAndJobId(preventRiskControlMeasureById.getUuid(), task.getJobId());
|
// CJRecordFromTask.setCheckTaskId(preventCJReportCheckTaskFromWork.getId());
|
// todo 取出所有措施，再循环在匹配
|
boolean checkTaskIdExist = true;
|
for (PreventRiskControlMeasure measure : allMeasureList) {
|
if (controlMeasureId.equals(measure.getId())) {
|
//通过管控措施uuid ，jobId(workId)，在任务上报表中，找到任务对应的uuid
|
|
PreventCJReportCheckTaskFromWork preventCJReportCheckTaskFromWork = CJTaskFromWorkService.geByMeasureUUidAndJobId(measure.getUuid(), task.getJobId());
|
try {
|
// if(preventCJReportCheckTaskFromWork!=null) {
|
CJRecordFromTask.setCheckTaskId(preventCJReportCheckTaskFromWork.getId());
|
//}
|
} catch (Exception e) {
|
checkTaskIdExist = false;
|
log.info("chekcPointId={},PreventRiskDangerCheckLogId={},controlMeasureId={},measure uuid={},jobId={}", hiddenDangerCheckPoint.getId(), task.getId(), controlMeasureId, measure.getUuid(), task.getJobId());
|
log.error(e.getMessage());
|
}
|
}
|
}
|
|
if (!checkTaskIdExist) {
|
continue;
|
}
|
CJRecordFromTask.setCheckTime(hiddenDangerCheckById.getCheckTime());
|
CJRecordFromTask.setTaskId(task.getCheckId());
|
//第二版标准新增
|
CJRecordFromTask.setMobileCode(task.getMobileCode().toString());
|
|
int typeTag = 0;
|
// List<PreventTaskType> typeByJobIds = taskTypeService.getInfoByJobId(task.getJobId());
|
// for (PreventTaskType typeByJobId : typeByJobIds) {
|
// if (typeByJobId.getType()!= 0) {
|
// typeTag = 1;
|
// }
|
// }
|
|
// todo 取出所有任务信息表，再循环在匹配
|
for (PreventTaskType taskType : allTaskTypeList) {
|
if (taskType.getJobId().equals(task.getJobId())) {
|
if (taskType.getType() != 0) {
|
typeTag = 1;
|
}
|
}
|
}
|
|
|
CJRecordFromTask.setDefend(String.valueOf(typeTag));
|
//封装数据
|
CJRecordFromTaskLists.add(CJRecordFromTask);
|
}
|
}
|
|
//设置原始数据上报状态
|
// handlerReportParam.setId(task.getId());
|
// handlerReportParam.setReportTime(new Date());
|
// handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
// handlerReportParamList.add(handlerReportParam);
|
// preventRiskDangerCheckLogService.updateTaskReportStatus(handlerReportParam);
|
int i = 1;
|
taskIds.add(task.getId());
|
tag++;
|
}
|
log.info("【##】5.数据封装完成...");
|
|
}
|
} else {
|
log.info("【双重预防】当前无排查任务记录需要处理");
|
}
|
|
if (CJRecordFromTaskLists.size() > 0) {
|
log.info("【双重预防】排查任务记录CJ：数据处理...");
|
log.info("【双重预防】排查任务记录CJ：数据处理开始taskIds..." + JSONObject.toJSONString(taskIds));
|
|
|
//设置原始数据状态
|
int taskUpdateResult = preventRiskDangerCheckLogService.updateTaskReportStatusByList(taskIds);
|
if (taskUpdateResult < taskIds.size()) {
|
log.error("【双重预防】排查任务记录CJ：数据处理开始taskIds...排查任务记录原始数据更新失败, 取消操作");
|
throw new AusinessException(E.ADD_FAIL.getCode(), "排查任务记录原始数据更新失败, 取消操作");
|
}
|
|
log.info("【双重预防】排查任务记录CJ：数据处理开始CJRecordFromTaskLists..." + JSONObject.toJSONString(CJRecordFromTaskLists));
|
int result = CJTaskRecordService.insertRecordList(CJRecordFromTaskLists);
|
if (result < CJRecordFromTaskLists.size()) {
|
log.error("【双重预防】排查任务记录CJ：数据处理开始taskIds...排查任务记录插入失败, 取消操作");
|
throw new AusinessException(E.ADD_FAIL.getCode(), "排查任务记录插入失败, 取消操作");
|
}
|
|
|
}
|
step = 6;
|
} else {
|
step = 6;
|
log.info("排查任务记录数据上报已关闭");
|
}
|
|
|
/**
|
* 6、隐患信息数据
|
* */
|
//读取安全风险管控措施数据上报主配置信息
|
PreventReportConfig dangerReportConfig = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
|
//如果安全风险管控措施主配置开启上报
|
if (dangerReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())) {
|
|
//logger.info("【##】6.检索隐患数据...");
|
|
//查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
List<PreventRiskDangerInfo> dangerManages = preventRiskDangerInfoService.listReportDanger();
|
//获取上报数据list
|
List<PreventCJReportDangerInfo> CJDangerInfoLists = new ArrayList<>();
|
|
if (ObjectUtils.isNotEmpty(dangerManages)) {
|
HandlerReportParam handlerReportParam = new HandlerReportParam();
|
//遍历，封装数据
|
for (PreventRiskDangerInfo dangerManage : dangerManages) {
|
|
//获取隐患信息主表信息
|
HiddenDangerCheckPoint hiddenDanger = trHiddenDangerCheckPointService.getHiddenDangerCheckPointById(dangerManage.getDangerCheckPointId());
|
//获取上报数据对象
|
PreventCJReportDangerInfo CJDangerInfo = new PreventCJReportDangerInfo();
|
|
//通过用户名，获取涉及到的各位用户的真实姓名
|
User createUser = new User();
|
createUser = trUserService.getUserByLoginName(hiddenDanger.getCreateBy());
|
// createUser = trUserService.getUserByLoginName("guotai");
|
if (ObjectUtils.isEmpty(createUser)) {
|
createUser = trUserService.getUserByName(hiddenDanger.getCreateBy());
|
}
|
User updateUser = trUserService.getUserByLoginName(hiddenDanger.getUpdateBy());
|
// User updateUser = trUserService.getUserByLoginName("guotai");
|
if (ObjectUtils.isNotEmpty(hiddenDanger.getRegisterUserName())) {
|
User registerUser = trUserService.getUserByLoginName(hiddenDanger.getRegisterUserName());
|
//登记人信息
|
CJDangerInfo.setRegistrant(registerUser.getUserName());//登记人
|
CJDangerInfo.setRegistTime(hiddenDanger.getRegisterCreateTime());//登记时间
|
}
|
|
CJDangerInfo.setCost(String.valueOf(0));//初始值给0
|
if (ObjectUtils.isNotEmpty(hiddenDanger.getRectifyUserName())) {
|
User rectifyUser = trUserService.getUserByLoginName(hiddenDanger.getRectifyUserName());
|
//整改人信息
|
CJDangerInfo.setLiablePerson(rectifyUser.getUserName());//整改责任人
|
if (!StringUtils.isEmpty(hiddenDanger.getRectifyFund())) {
|
String REGEX_CHINESE = "[\u4e00-\u9fa5]";// 中文正则
|
String cost = hiddenDanger.getRectifyFund().replaceAll(REGEX_CHINESE, "").trim();
|
if (StringUtils.isEmpty(cost)) {
|
CJDangerInfo.setCost(null);//资金
|
} else {
|
CJDangerInfo.setCost(cost);//资金
|
}
|
} else {
|
CJDangerInfo.setCost(null);//资金
|
}
|
|
}
|
|
if (ObjectUtils.isNotEmpty(hiddenDanger.getAcceptUserName())) {
|
//验收人信息
|
CJDangerInfo.setCheckAcceptPerson(hiddenDanger.getAcceptUserName());//验收人
|
CJDangerInfo.setCheckAcceptComment(hiddenDanger.getAcceptOpinion());//验收情况
|
CJDangerInfo.setCheckAcceptTime(hiddenDanger.getAcceptCreateTime());//验收时间
|
}
|
|
//如果排查任务正常存在，封装任务相关数据
|
// if (Integer.parseInt(hiddenDanger.getDangerSources()) != 2){
|
// HiddenDangerCheck dangerCheckById = trHiddenDangerCheckService.getHiddenDangerCheckById(hiddenDanger.getCheckId());
|
//
|
// PreventRiskDangerCheckLog dangerCheckLogByCheckId = preventRiskDangerCheckLogService.getByDangerCheckByCheckId(hiddenDanger.getCheckId());
|
// CJDangerInfo.setCheckRecordId(dangerCheckLogByCheckId.getUuid());//隐患排查任务记录uuid
|
// //找排查点，然后查措施
|
// PreventRiskCheckUnit unit = preventRiskCheckUnitService.getUnitByBaseCheckPointId(hiddenDanger.getCheckPointId());
|
// //查管控措施
|
// PreventRiskControlMeasure controlMeasureById = preventRiskControlMeasureService.getPreventRiskControlMeasureById(unit.getControlMeasureId());
|
// CJDangerInfo.setRiskMeasureId(controlMeasureById.getUuid());//管控措施uuid
|
// CJDangerInfo.setControlMeasures(controlMeasureById.getCheckContent());//控制措施 ,整改措施
|
// }else {
|
// CJDangerInfo.setCheckRecordId(null);
|
// CJDangerInfo.setRiskMeasureId(null);
|
// }
|
CJDangerInfo.setCheckRecordId(null);
|
CJDangerInfo.setRiskMeasureId(null);//默认无任务
|
CJDangerInfo.setDeleted("0");
|
CJDangerInfo.setId(dangerManage.getUuid());
|
CJDangerInfo.setCompanyCode(companyCode);
|
CJDangerInfo.setHazardCode(dangerManage.getHazardCode());
|
CJDangerInfo.setCreateBy(createUser.getUserName());
|
CJDangerInfo.setCreateDate(hiddenDanger.getCreateTime());
|
|
if (ObjectUtils.isEmpty(updateUser)) {
|
CJDangerInfo.setUpdateBy(createUser.getUserName());
|
CJDangerInfo.setUpdateDate(hiddenDanger.getCreateTime());
|
} else {
|
CJDangerInfo.setUpdateBy(updateUser.getUserName());
|
CJDangerInfo.setUpdateDate(hiddenDanger.getUpdateTime());
|
}
|
// todo 2024-07-01 需要检查
|
CJDangerInfo.setHazardCategory("0");
|
if (dangerManage.getId() <= 383) {
|
PreventTaskType taskTypeInfo = taskTypeService.getInfoByTaskId(dangerManage.getId());
|
int i = 1;
|
CJDangerInfo.setHazardCategory(taskTypeInfo.getType().toString());
|
}
|
CJDangerInfo.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
CJDangerInfo.setReportTime(null);
|
CJDangerInfo.setZhunReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
CJDangerInfo.setZhunReportTime(null);
|
CJDangerInfo.setDataSource((byte) 1);
|
CJDangerInfo.setDangerName(hiddenDanger.getDangerName());
|
CJDangerInfo.setDangerLevel(hiddenDanger.getDangerLevel());
|
CJDangerInfo.setDangerSrc(dangerManage.getDangerSrc().toString());
|
if (hiddenDanger.getRectifyType().equals("1")) {
|
CJDangerInfo.setDangerManageType("0");
|
} else {
|
CJDangerInfo.setDangerManageType("1");
|
}
|
CJDangerInfo.setDangerDesc(hiddenDanger.getDangerDescription());
|
CJDangerInfo.setDangerReason(dangerManage.getDangerReason());
|
CJDangerInfo.setDangerManageDeadline(hiddenDanger.getRectifyDeadlineTime());
|
if (ObjectUtils.isNotEmpty(dangerManage.getDangerState())) {
|
CJDangerInfo.setDangerState(dangerManage.getDangerState().toString());
|
}
|
CJDangerInfo.setHazardDangerType(dangerManage.getHazardDangerType().toString());
|
CJDangerInfo.setDangerManagerId(dangerManage.getId());
|
|
CJDangerInfoLists.add(CJDangerInfo);
|
//设置原始数据上报状态
|
handlerReportParam.setId(dangerManage.getId());
|
handlerReportParam.setReportTime(new Date());
|
handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
//修改隐患信息附属表状态
|
preventRiskDangerInfoService.updateDangerInfoReportStatus(handlerReportParam);
|
}
|
} else {
|
log.info("【双重预防】当前无隐患信息需要处理");
|
}
|
|
//插入上报昌吉州转换表
|
for (PreventCJReportDangerInfo CJDanger : CJDangerInfoLists) {
|
log.info("【双重预防】隐患信息插入...");
|
int result = CJDangerInfoService.insert(CJDanger);
|
if (result < 0) {
|
throw new AusinessException(E.ADD_FAIL.getCode(), "隐患信息插入失败");
|
}
|
log.info("【双重预防】隐患信息：数据处理...");
|
}
|
} else {
|
log.info("隐患信息数据上报已关闭");
|
}
|
|
|
// /**
|
// * 7、检索检修记录数据
|
// * */
|
// //读取风险分析单元数据上报主配置信息
|
// PreventReportConfig overhaulReportConfig = preventReportConfigService.getReportConfigById(SyncEnum.OVERHAUL_LOG_DANGER_INFO.getCode());
|
// //如果风险事件主配置开启上报
|
// if (overhaulReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())){
|
//
|
// //logger.info("【##】2.检索检修记录...");
|
// //查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
// List<PreventOverhaulLog> preventOverhaulLogList = overhaulLogService.listReportOverhaulLog();
|
// //获取上报数据对象与list
|
// List<PreventCJReportOverhaulLog> CJOverhaulLogLists = new ArrayList<>();
|
// if (ObjectUtils.isNotEmpty(preventOverhaulLogList)){
|
// //遍历，封装数据
|
// for (PreventOverhaulLog preventOverhaulLog : preventOverhaulLogList) {
|
// HandlerReportParam handlerReportParam = new HandlerReportParam();
|
// PreventCJReportOverhaulLog CJOverhaulLog = new PreventCJReportOverhaulLog();
|
//
|
// //封装上报昌吉州检修记录数据
|
// CJOverhaulLog.setId(preventOverhaulLog.getUuid());
|
// if (preventOverhaulLog.getReportStatus().equals(SyncEnum.SYNC_EXEC_SUCCESS.getCode())){
|
// CJOverhaulLog.setDeleted("2");//数据更新状态标识，目前仅昌吉州需要 2022-08-10
|
// }else {
|
// CJOverhaulLog.setDeleted("0");
|
// }
|
// CJOverhaulLog.setCompanyCode(companyCode);
|
// CJOverhaulLog.setHazardCode(preventOverhaulLog.getHazardCode());
|
// CJOverhaulLog.setRiskUnitId(preventOverhaulLog.getRiskUnitUuid());
|
// CJOverhaulLog.setStopStartTime(preventOverhaulLog.getStopStartTime());
|
// CJOverhaulLog.setStopEndTime(preventOverhaulLog.getStopEndTime());
|
// CJOverhaulLog.setStopReason(preventOverhaulLog.getStopReason());
|
// CJOverhaulLog.setCreateBy(preventOverhaulLog.getCreateByUserName());
|
// CJOverhaulLog.setCreateDate(preventOverhaulLog.getGmtCreate());
|
// CJOverhaulLog.setUpdateBy(preventOverhaulLog.getCreateByUserName());
|
// CJOverhaulLog.setUpdateDate(preventOverhaulLog.getGmtModitify());
|
// CJOverhaulLog.setReportTime(null);
|
// CJOverhaulLog.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
// CJOverhaulLog.setDataSource((byte) 1);
|
//
|
// //封装数据
|
// CJOverhaulLogLists.add(CJOverhaulLog);
|
// //设置原始数据上报状态
|
// handlerReportParam.setId(preventOverhaulLog.getId());
|
// handlerReportParam.setReportTime(new Date());
|
// handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
// int result = overhaulLogService.updateOverhaulReportStatus(handlerReportParam);
|
// if (result < 1){
|
// throw new AusinessException(E.ADD_FAIL.getCode(), "检修记录数据状态修改失败");
|
// }
|
// }
|
// }else {
|
// logger.info("【检修记录】当前无检修记录数据需要处理");
|
// }
|
// //写入昌吉州转换表
|
// for (PreventCJReportOverhaulLog cjOverhaulLog : CJOverhaulLogLists) {
|
// int result = reportOverhaulLogService.insertCJOverhaulLists(cjOverhaulLog);
|
// if (result < 1){
|
// throw new AusinessException(E.ADD_FAIL.getCode(), "检修记录数据状态修改失败");
|
// }
|
// logger.info("【检修记录】2.检修记录CJ：数据处理...");
|
// }
|
// step = 3;
|
// }else {
|
// step = 3;
|
// logger.info("检修记录数据上报已关闭");
|
// }
|
//
|
|
|
// TODO 目前应急厅没有风险点概念，此处暂时不写。目前看，风险点概念，类似管控措施，对用某个具体的风险位置
|
// /**
|
// * 7、检索风险点-（可能对应风险管控措施?）数据
|
// * */
|
// //读取风险分析单元数据上报主配置信息
|
// PreventReportConfig pointReportConfig = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_POINT_INFO.getCode());
|
// //如果风险事件主配置开启上报
|
// if (pointReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())){
|
// //logger.info("【##】2.检索安全风险事件...");
|
// //查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
// List<PreventRiskEvent> riskEvents = preventRiskEventService.listReportEvent();
|
// //获取上报数据对象与list
|
// List<PreventCJReportPoint> CJPointLists = new ArrayList<>();
|
// if (ObjectUtils.isNotEmpty(riskEvents)){
|
// //遍历，封装数据
|
// for (PreventRiskEvent riskEvent : riskEvents) {
|
// String pointUuid = UUID.randomUUID().toString();
|
// HandlerReportParam handlerReportParam = new HandlerReportParam();
|
// PreventCJReportPoint CJReportPoint = new PreventCJReportPoint();
|
// //TODO 公司编码，暂时没有
|
// //封装上报昌吉州风险事件数据
|
// CJReportPoint.setId(pointUuid);
|
// CJReportPoint.setCompanyCode("test001");
|
// CJReportPoint.setDeleted(riskEvent.getDeleteStatus().toString());
|
// CJReportPoint.setCreateBy(riskEvent.getCreateByUserName());
|
// CJReportPoint.setCreateDate(riskEvent.getGmtCreate());
|
// CJReportPoint.setUpdateBy(riskEvent.getCreateByUserName());
|
// CJReportPoint.setUpdateDate(riskEvent.getGmtModitify());
|
// CJReportPoint.setRiskUnitIds();
|
// CJReportPoint.setRiskEventIds();
|
// CJReportPoint.setRiskMeasureIds();
|
// CJReportPoint.setHazardDep();
|
// CJReportPoint.setHazardLiablePerson();
|
// CJReportPoint.setHazardCode();
|
// CJReportPoint.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
// CJReportPoint.setReportTime(null);
|
// CJReportPoint.setDataSource((byte) 1);
|
// CJReportPoint.setRiskEventId(riskEvent.getId());
|
// //封装数据
|
// CJPointLists.add(CJReportPoint);
|
// //设置原始数据上报状态
|
// handlerReportParam.setId(riskEvent.getId());
|
// handlerReportParam.setReportTime(new Date());
|
// handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
// preventRiskEventService.updateEventReportStatus(handlerReportParam);
|
// }
|
// }else {
|
// logger.info("【##】当前无安全风险事件数据需要处理");
|
// }
|
// //写入昌吉州转换表
|
// for (PreventCJReportRiskEvent CJEvent : CJEventLists) {
|
// CJEventService.insertEventLists(CJEvent);
|
// logger.info("【##】2.风险分析事件CJ：数据处理...");
|
// }
|
// step = 3;
|
// }else {
|
// step = 3;
|
// logger.info("安全风险事件数据上报已关闭");
|
// }
|
|
|
}
|
}
|
