package com.gk.hotwork.doublePrevention.scheduls;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONObject;
|
import com.gk.hotwork.Domain.RiskControlClassify;
|
import com.gk.hotwork.Domain.UserInfo;
|
import com.gk.hotwork.Domain.dto.UserRPCRespDTO;
|
import com.gk.hotwork.Service.Middle.AccountAuthService;
|
import com.gk.hotwork.Domain.Exception.E;
|
import com.gk.hotwork.Domain.Exception.BusinessException;
|
import com.gk.hotwork.Domain.Vo.ResultVO;
|
import com.gk.hotwork.Service.RiskControlClassifyService;
|
import com.gk.hotwork.Service.UserService;
|
import com.gk.hotwork.doublePrevention.entity.*;
|
import com.gk.hotwork.doublePrevention.enums.SyncEnum;
|
import com.gk.hotwork.doublePrevention.repository.param.HandlerReportParam;
|
import com.gk.hotwork.doublePrevention.service.baseService.*;
|
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 javax.annotation.PostConstruct;
|
import java.util.ArrayList;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.UUID;
|
|
@Component
|
public class SearchReportDateSchedule {
|
|
private static final org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(SearchReportDateSchedule.class);
|
|
@Autowired
|
private AccountAuthService accountAuthService;
|
@Autowired
|
private UserService userService;
|
@Autowired
|
private RiskControlClassifyService riskControlClassifyService;
|
@Autowired
|
private PreventReportConfigService preventReportConfigService;
|
@Autowired
|
private PreventReportConfigLogService preventReportConfigLogService;
|
|
@Autowired
|
private PreventReportRiskAnaUnitService riskAnaUnitService;
|
@Autowired
|
private PreventReportRiskEventService eventService;
|
@Autowired
|
private PreventReportRiskControlMeasureService measureService;
|
@Autowired
|
private PreventReportCheckTaskFromWorkService taskFromWorkService;
|
@Autowired
|
private PreventReportCheckRecordFromTaskService taskRecordService;
|
@Autowired
|
private PreventReportDangerInfoService dangerInfoService;
|
|
@Autowired
|
private PreventRiskAnaUnitService preventRiskUnitService;
|
@Autowired
|
private PreventRiskEventService preventRiskEventService;
|
@Autowired
|
private PreventRiskControlMeasureService preventRiskControlMeasureService;
|
@Autowired
|
private PreventDangerCheckContentService preventDangerCheckContentService;
|
@Autowired
|
private PreventRiskControlTemplateService preventRiskControlTemplateService;
|
@Autowired
|
private PreventDangerCheckWorkService preventDangerCheckWorkService;
|
@Autowired
|
private PreventDangerCheckTaskService preventDangerCheckTaskService;
|
@Autowired
|
private PreventDangerManageService preventDangerManageService;
|
@Autowired
|
private PreventDangerRectifyService preventDangerRectifyService;
|
@Autowired
|
private PreventWorkAndMeasureService preventWorkAndMeasureService;
|
@Autowired
|
private PreventTaskAndMeasureService preventTaskAndMeasureService;
|
|
|
@Transactional
|
@Scheduled(cron = "* * 3 * * ? ")
|
// @Scheduled(cron = "0/10 * * * * ? ")
|
// @PostConstruct
|
public void searchReportDate(){
|
|
logger.info("【***】定时检索需要上报数据...");
|
// System.out.println("【***】定时检索需要上报数据...");
|
int step = 1;
|
|
String companyCode = "652910016";
|
|
/**
|
* 1、检索风险分析单元
|
* */
|
//读取风险分析单元数据上报主配置信息
|
PreventReportConfig unitReportConfig = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode());
|
//如果主配置开启上报，开始
|
if (unitReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())){
|
|
logger.info("【***】1.检索风险分析单元...");
|
// System.out.println("【***】1.检索风险分析单元...");
|
|
//查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
List<PreventRiskAnaUnit> riskAnaUnitList = preventRiskUnitService.listRiskAnaUnit();
|
//获取上报数据list
|
List<PreventReportRiskAnaUnit> unitLists = new ArrayList<>();
|
if (ObjectUtils.isNotEmpty(riskAnaUnitList)){
|
HandlerReportParam handlerReportParam = new HandlerReportParam();
|
//遍历，封装数据
|
for (PreventRiskAnaUnit riskAnaUnit : riskAnaUnitList) {
|
|
//获取上报数据对象
|
PreventReportRiskAnaUnit reportRiskAnaUnit = new PreventReportRiskAnaUnit();
|
|
//封装风险分析单元数据
|
reportRiskAnaUnit.setId(riskAnaUnit.getUuid());
|
reportRiskAnaUnit.setCompanyCode(companyCode);
|
reportRiskAnaUnit.setRiskUnitName(riskAnaUnit.getRiskUnitName());
|
reportRiskAnaUnit.setHazardCode(riskAnaUnit.getRiskCode());
|
reportRiskAnaUnit.setHazardDep(riskAnaUnit.getLiableDep());
|
reportRiskAnaUnit.setHazardLiablePerson(riskAnaUnit.getLiablePerson());
|
reportRiskAnaUnit.setDeleted(riskAnaUnit.getDeleteStatus().toString());
|
reportRiskAnaUnit.setCreateBy(riskAnaUnit.getCreateByUserName());
|
reportRiskAnaUnit.setCreateDate(riskAnaUnit.getGmtCreate());
|
reportRiskAnaUnit.setUpdateBy(riskAnaUnit.getLastEditUserName());
|
reportRiskAnaUnit.setUpdateDate(riskAnaUnit.getGmtModitify());
|
reportRiskAnaUnit.setDataSource(null);
|
reportRiskAnaUnit.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
reportRiskAnaUnit.setReportTime(null);
|
reportRiskAnaUnit.setRiskUnitId(riskAnaUnit.getId());
|
//封装数据
|
unitLists.add(reportRiskAnaUnit);
|
|
//修改原始数据状态为待上传
|
handlerReportParam.setId(riskAnaUnit.getId());
|
handlerReportParam.setReportTime(new Date());
|
handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
preventRiskUnitService.updateReportStatus(handlerReportParam);
|
}
|
}else {
|
logger.info("【***】当前无数据需要处理");
|
}
|
for (PreventReportRiskAnaUnit unitList : unitLists) {
|
PreventReportRiskAnaUnit unitById = riskAnaUnitService.getUnitById(unitList.getId());
|
if (ObjectUtils.isEmpty(unitById)){
|
riskAnaUnitService.insertUnitList(unitList);
|
}else {
|
riskAnaUnitService.updateUnitById(unitList);
|
}
|
// logger.info("【***】1.风险分析单元：数据处理...");
|
// System.out.println("【***】1.风险分析单元：数据处理...");
|
}
|
step = 2;
|
}else {
|
step = 2;
|
logger.info("【***】风险分析单元数据上报已关闭");
|
}
|
|
|
/**
|
* 2、检索安全风险事件数据
|
* */
|
//读取风险分析单元数据上报主配置信息
|
PreventReportConfig eventReportConfig = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_EVENT.getCode());
|
//如果风险事件主配置开启上报
|
if (eventReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())){
|
|
logger.info("【##】2.检索安全风险事件...");
|
// System.out.println("【***】2.检索安全风险事件...");
|
|
//查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
List<PreventRiskEvent> riskEvents = preventRiskEventService.listReportEvent();
|
//获取上报数据对象与list
|
List<PreventReportRiskEvent> eventLists = new ArrayList<>();
|
|
if (ObjectUtils.isNotEmpty(riskEvents)){
|
//遍历，封装数据
|
for (PreventRiskEvent riskEvent : riskEvents) {
|
|
HandlerReportParam handlerReportParam = new HandlerReportParam();
|
PreventReportRiskEvent reportRiskEvent = new PreventReportRiskEvent();
|
|
//封装风险事件数据
|
reportRiskEvent.setId(riskEvent.getUuid());
|
reportRiskEvent.setCompanyCode(companyCode);
|
reportRiskEvent.setDeleted(riskEvent.getDeleteStatus().toString());
|
reportRiskEvent.setCreateBy(riskEvent.getCreateByUserName());
|
reportRiskEvent.setCreateDate(riskEvent.getGmtCreate());
|
reportRiskEvent.setUpdateBy(riskEvent.getCreateByUserName());
|
reportRiskEvent.setUpdateDate(riskEvent.getGmtModitify());
|
reportRiskEvent.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
reportRiskEvent.setReportTime(null);
|
reportRiskEvent.setDataSource((byte) 1);
|
reportRiskEvent.setRiskUnitId(riskEvent.getRiskUnitUuid());
|
reportRiskEvent.setRiskEventName(riskEvent.getRiskEventName());
|
reportRiskEvent.setRiskEventId(riskEvent.getId());
|
//封装数据
|
eventLists.add(reportRiskEvent);
|
//设置原始数据上报状态
|
handlerReportParam.setId(riskEvent.getId());
|
handlerReportParam.setReportTime(new Date());
|
handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
preventRiskEventService.updateEventReportStatus(handlerReportParam);
|
}
|
}else {
|
// System.out.println("【***】当前无安全风险事件数据需要处理");
|
logger.info("【***】当前无安全风险事件数据需要处理");
|
}
|
// System.out.println("【***】安全风险事件封装完成");
|
for (PreventReportRiskEvent eventList : eventLists) {
|
PreventReportRiskEvent eventById = eventService.getEventById(eventList.getId());
|
if (ObjectUtils.isEmpty(eventById)){
|
int result = eventService.insertEventLists(eventList);
|
if (result < 0){
|
throw new BusinessException(E.ADD_FAIL.getCode(), "风险分析事件插入失败");
|
}
|
}else {
|
eventService.updateEventById(eventList);
|
}
|
// System.out.println("【***】2.风险分析事件：数据处理...");
|
}
|
step = 3;
|
}else {
|
step = 3;
|
logger.info("【***】安全风险事件数据上报已关闭");
|
}
|
|
/**
|
* 3、检索安全风险管控措施数据
|
* */
|
//读取安全风险管控措施数据上报主配置信息
|
PreventReportConfig measureReportConfig = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_RISK_MEASURE.getCode());
|
//如果安全风险管控措施主配置开启上报
|
if (measureReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())){
|
logger.info("{【##】3.检索安全风险管控措施...");
|
// System.out.println("【***】3.检索安全风险管控措施...");
|
|
//查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
List<PreventRiskControlMeasure> measures = preventRiskControlMeasureService.listReportMeasure();
|
//获取上报数据list
|
List<PreventReportRiskControlMeasure> measureLists = new ArrayList<>();
|
HandlerReportParam handlerReportParam = new HandlerReportParam();
|
|
if (ObjectUtils.isNotEmpty(measures)){
|
//遍历，封装数据
|
for (PreventRiskControlMeasure measure : measures) {
|
String classify2 = null;
|
|
//获取上报数据对象
|
PreventReportRiskControlMeasure reportMeasure = new PreventReportRiskControlMeasure();
|
|
if (measure.getClassify2() < 9 || measure.getClassify2() == 18){
|
RiskControlClassify ControlById = riskControlClassifyService.getByControlId(measure.getClassify2());
|
classify2 = measure.getClassify1() + "-" + ControlById.getOrderIndex();
|
}
|
if ((measure.getClassify2() > 8 && measure.getClassify2() < 11) || measure.getClassify2() == 19){
|
RiskControlClassify ControlById = riskControlClassifyService.getByControlId(measure.getClassify2());
|
classify2 = measure.getClassify1() + "-" + ControlById.getOrderIndex();
|
}
|
if ((measure.getClassify2() > 10 && measure.getClassify2() < 14) || measure.getClassify2() == 20){
|
RiskControlClassify ControlById = riskControlClassifyService.getByControlId(measure.getClassify2());
|
classify2 = measure.getClassify1() + "-" + ControlById.getOrderIndex();
|
}
|
if ((measure.getClassify2() > 13 && measure.getClassify2() < 18) || measure.getClassify2() == 27){
|
RiskControlClassify ControlById = riskControlClassifyService.getByControlId(measure.getClassify2());
|
classify2 = measure.getClassify1() + "-" + ControlById.getOrderIndex();
|
}
|
|
//封装风险事件数据
|
reportMeasure.setId(measure.getUuid());
|
reportMeasure.setCompanyCode(companyCode);
|
reportMeasure.setDeleted(measure.getDeleteStatus().toString());
|
reportMeasure.setCreateBy(measure.getCreateByUserName());
|
reportMeasure.setCreateDate(measure.getGmtCreate());
|
reportMeasure.setUpdateBy(measure.getCreateByUserName());
|
reportMeasure.setUpdateDate(measure.getGmtModitify());
|
reportMeasure.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
reportMeasure.setReportTime(null);
|
reportMeasure.setDataSource((byte) 1);
|
reportMeasure.setRiskEventId(measure.getRiskEventUuid());
|
reportMeasure.setRiskMeasureDesc(measure.getMeasureDesc());
|
//管控方式,措施分类
|
reportMeasure.setDataSrc(measure.getControlType().toString());
|
reportMeasure.setClassify1(measure.getClassify1().toString());
|
reportMeasure.setClassify2(classify2);
|
reportMeasure.setClassify3(measure.getClassify3());
|
reportMeasure.setRiskMeasureId(measure.getId());
|
PreventDangerCheckContent contentByMeasureId = preventDangerCheckContentService.getCheckContentByMeasureId(measure.getId());
|
reportMeasure.setTroubleshootContent(contentByMeasureId.getCheckContent());
|
//封装数据
|
measureLists.add(reportMeasure);
|
//设置原始数据上报状态
|
handlerReportParam.setId(measure.getId());
|
handlerReportParam.setReportTime(new Date());
|
handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
preventRiskControlMeasureService.updateMeasureReportStatus(handlerReportParam);
|
}
|
}else {
|
logger.info("【***】当前无安全风险管控措施数据需要处理");
|
}
|
// System.out.println("【***】安全风险管控措施数据封装完成...");
|
step = 4;
|
for (PreventReportRiskControlMeasure measureList : measureLists) {
|
PreventReportRiskControlMeasure measureById = measureService.getMeasureById(measureList.getId());
|
if (ObjectUtils.isEmpty(measureById)){
|
int result = measureService.insertMeasureList(measureList);
|
if (result < 0){
|
throw new BusinessException(E.ADD_FAIL.getCode(), "安全风险管控措施插入失败");
|
}
|
}else {
|
String id = measureList.getId();
|
measureService.updateMeasureById(measureList);
|
}
|
// System.out.println("【***】3.安全风险管控措施：数据处理...");
|
}
|
}else {
|
step = 4;
|
logger.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.检索任务配置...");
|
// System.out.println("【***】4.检索任务配置...");
|
//查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
List<PreventDangerCheckWork> works = preventDangerCheckWorkService.listReportWork();
|
//获取上报数据对象与list
|
List<PreventReportCheckTaskFromWork> taskFromWorkLists = new ArrayList<>();
|
HandlerReportParam handlerReportParam = new HandlerReportParam();
|
|
if (ObjectUtils.isNotEmpty(works)){
|
//遍历，封装数据
|
for (PreventDangerCheckWork work : works) {
|
//获取work与措施关联信息
|
List<PreventWorkAndMeasure> workAndMeasureLists = preventWorkAndMeasureService.getWorkAndMeasureByWorkUuid(work.getUuid());
|
for (PreventWorkAndMeasure workAndMeasure : workAndMeasureLists) {
|
// System.out.println("封装数据...");
|
PreventReportCheckTaskFromWork taskFromWork = new PreventReportCheckTaskFromWork();
|
//查询措施
|
PreventRiskControlMeasure controlMeasure = preventRiskControlMeasureService.getControlMeasureByUuid(workAndMeasure.getMeasureUuid());
|
PreventDangerCheckContent checkContent = preventDangerCheckContentService.getCheckContentByMeasureId(controlMeasure.getId());
|
String timeUnit = null;
|
//转成汉字
|
if (work.getCheckCycleUnit().equals(2)){
|
timeUnit = "小时";
|
}else if (work.getCheckCycleUnit().equals(3)){
|
timeUnit = "日";
|
}else if (work.getCheckCycleUnit().equals(4)){
|
timeUnit = "月";
|
}else if (work.getCheckCycleUnit().equals(5)){
|
timeUnit = "年";
|
}
|
//巡检周期 = 任务时间 + 间隔
|
int workTime;
|
workTime = work.getCheckCycle() + work.getValidTime();
|
//封装风险事件数据
|
taskFromWork.setId(workAndMeasure.getId());
|
taskFromWork.setCompanyCode(companyCode);
|
taskFromWork.setDeleted(work.getDeleteStatus().toString());
|
taskFromWork.setCreateBy(work.getCreateByUserName());
|
taskFromWork.setCreateDate(work.getGmtCreate());
|
taskFromWork.setUpdateBy(work.getCreateByUserName());
|
taskFromWork.setUpdateDate(work.getGmtModitify());
|
taskFromWork.setCheckCycle(workTime);
|
taskFromWork.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
taskFromWork.setReportTime(null);
|
taskFromWork.setDataSource((byte) 1);
|
taskFromWork.setCheckCycleUnit(timeUnit);
|
taskFromWork.setRiskMeasureId(workAndMeasure.getMeasureUuid());
|
taskFromWork.setTroubleshootContent(checkContent.getCheckContent());
|
taskFromWork.setWorkId(work.getId());
|
//设置原始数据上报状态
|
handlerReportParam.setId(work.getId());
|
handlerReportParam.setReportTime(new Date());
|
handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
preventDangerCheckWorkService.updateWorkReportStatus(handlerReportParam);
|
|
//以措施为单位，封装数据
|
taskFromWorkLists.add(taskFromWork);
|
}
|
}
|
}else {
|
logger.info("【***】当前无任务配置数据需要处理");
|
}
|
// System.out.println("【***】任务配置数据封装完成");
|
for (PreventReportCheckTaskFromWork taskFromWorks : taskFromWorkLists) {
|
PreventReportCheckTaskFromWork workById = taskFromWorkService.getWorkById(taskFromWorks.getId());
|
if (ObjectUtils.isEmpty(workById)){
|
int result = taskFromWorkService.insertTaskFromWorkList(taskFromWorks);
|
if (result < 0){
|
System.out.println(JSONObject.toJSON(taskFromWorks));
|
throw new BusinessException(E.ADD_FAIL.getCode(), "任务配置插入失败");
|
}
|
}else {
|
taskFromWorkService.updateWorkById(taskFromWorks);
|
}
|
// System.out.println("【***】任务配置：数据处理...");
|
}
|
}else {
|
step = 5;
|
logger.info("【***】任务配置数据上报已关闭");
|
}
|
|
|
/**
|
* 5、排查任务记录数据 PreventReportCheckRecordFromTask
|
* */
|
//读取安全风险管控措施数据上报主配置信息
|
PreventReportConfig recordReportConfig = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG__CHECK_RECORD.getCode());
|
//如果安全风险管控措施主配置开启上报
|
if (recordReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())){
|
|
logger.info("【##】5.检索排查任务记录数据...");
|
// System.out.println("【***】5.检索排查任务记录数据...");
|
|
//查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
List<PreventDangerCheckTask> tasks = preventDangerCheckTaskService.listReportTask();
|
//获取上报数据对象
|
List<PreventReportCheckRecordFromTask> recordFromTaskList = new ArrayList<>();
|
HandlerReportParam handlerReportParam = new HandlerReportParam();
|
if (ObjectUtils.isNotEmpty(tasks)){
|
//遍历，封装数据
|
for (PreventDangerCheckTask task : tasks) {
|
PreventReportCheckRecordFromTask recordFromTask = new PreventReportCheckRecordFromTask();
|
PreventDangerCheckWork workById = preventDangerCheckWorkService.getWorkById(task.getCheckWorkId());
|
if (ObjectUtils.isNotEmpty(workById)){
|
UserInfo userByRealName = userService.getByUserId(workById.getCreateByUserId());
|
if (ObjectUtils.isEmpty(userByRealName.getUsername())){
|
recordFromTask.setCreateByMobile(null);
|
}else {
|
recordFromTask.setCreateByMobile(userByRealName.getUsername());
|
}
|
}else {
|
UserInfo userByRealName = userService.getUserByRealName(task.getCreateUserName());
|
if (ObjectUtils.isEmpty(userByRealName.getUsername())){
|
recordFromTask.setCreateByMobile(null);
|
}else {
|
recordFromTask.setCreateByMobile(userByRealName.getUsername());
|
}
|
}
|
|
//修改人-执行人
|
// ResultVO<UserRPCRespDTO> rpcExecUserResult = accountAuthService.getUserById(task.getExecUserId());
|
// UserRPCRespDTO execUser = (UserRPCRespDTO)rpcExecUserResult.getData();
|
UserInfo execUser = userService.getById(task.getExecUserId());
|
//获取上报数据对象
|
|
//转换检查结果
|
String checkStatus = null;
|
if (ObjectUtils.isEmpty(task.getResult() )){
|
checkStatus = "2";
|
}else if (task.getResult() == 2){
|
checkStatus = "1";
|
}else if (task.getResult() == 1){
|
checkStatus = "0";
|
}
|
//封装风险事件数据
|
recordFromTask.setId(task.getUuid());
|
recordFromTask.setCompanyCode(companyCode);
|
recordFromTask.setDeleted(task.getDeleteStatus().toString());
|
recordFromTask.setCreateBy(task.getCreateUserName());
|
recordFromTask.setCreateDate(task.getGmtCreate());
|
recordFromTask.setUpdateBy(task.getExecUserName());
|
recordFromTask.setUpdateDate(task.getGmtModitify());
|
recordFromTask.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
recordFromTask.setReportTime(null);
|
recordFromTask.setDataSource((byte) 1);
|
recordFromTask.setCheckTaskId(task.getCheckWorkUuid());
|
recordFromTask.setCheckStatus(checkStatus);
|
recordFromTask.setCheckTime(task.getStartTime());
|
//TODO
|
if (ObjectUtils.isEmpty(execUser.getUsername())){
|
recordFromTask.setUpdateByMobile(null);
|
}else {
|
recordFromTask.setUpdateByMobile(execUser.getUsername());
|
}
|
|
//封装数据
|
recordFromTaskList.add(recordFromTask);
|
recordFromTask.setTaskId(task.getId());
|
//设置原始数据上报状态
|
handlerReportParam.setId(task.getId());
|
handlerReportParam.setReportTime(new Date());
|
handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
preventDangerCheckTaskService.updateTaskReportStatus(handlerReportParam);
|
}
|
}else {
|
logger.info("【***】当前无排查任务记录需要处理");
|
}
|
// System.out.println("【***】任务记录数据封装完成");
|
//批量插入
|
for (PreventReportCheckRecordFromTask recordFromTasks : recordFromTaskList) {
|
PreventReportCheckRecordFromTask taskById = taskRecordService.getTaskById(recordFromTasks.getId());
|
if (ObjectUtils.isEmpty(taskById)){
|
int result = taskRecordService.insert(recordFromTasks);
|
if (result < 0){
|
// System.out.println("排查任务记录插入失败");
|
throw new BusinessException(E.ADD_FAIL.getCode(), "排查任务记录插入失败");
|
}
|
}else {
|
taskRecordService.updateTaskById(recordFromTasks);
|
}
|
|
// System.out.println("【***】任务记录处理");
|
}
|
step = 6;
|
}else {
|
step = 6;
|
logger.info("排查任务记录数据上报已关闭");
|
}
|
|
/**
|
* 6、隐患信息数据
|
* */
|
//读取安全风险管控措施数据上报主配置信息
|
PreventReportConfig dangerReportConfig = preventReportConfigService.getReportConfigById(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
|
//如果安全风险管控措施主配置开启上报
|
if (dangerReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())){
|
|
logger.info("【##】4.检索隐患信息数据...");
|
// System.out.println("【***】6.检索隐患信息数据...");
|
|
//查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
|
List<PreventDangerManage> dangerManages = preventDangerManageService.listReportDanger();
|
//获取上报数据list
|
|
List<PreventReportDangerInfo> dangerInfoLists = new ArrayList<>();
|
if (ObjectUtils.isNotEmpty(dangerManages)){
|
HandlerReportParam handlerReportParam = new HandlerReportParam();
|
//遍历，封装数据
|
for (PreventDangerManage dangerManage : dangerManages) {
|
// System.out.println("封装隐患信息数据...");
|
//获取上报数据对象
|
PreventReportDangerInfo dangerInfo = new PreventReportDangerInfo();
|
PreventDangerRectify rectify = preventDangerRectifyService.getRectifyByManageIdForReport(dangerManage.getId());
|
|
//DangerLevel转换，减一
|
Integer level = dangerManage.getDangerLevel() - 1;
|
//DangerManageType转换，减一
|
Integer manageType = dangerManage.getDangerType() - 1;
|
//TODO 部门编码，暂时没有
|
//封装风险事件数据
|
dangerInfo.setId(dangerManage.getUuid());
|
dangerInfo.setCompanyCode(companyCode);
|
dangerInfo.setDeleted(dangerManage.getDeleteStatus().toString());
|
dangerInfo.setCreateBy(dangerManage.getCreateByUserName());
|
dangerInfo.setCreateDate(dangerManage.getGmtCreate());
|
dangerInfo.setUpdateBy(dangerManage.getLastEditUserName());
|
dangerInfo.setUpdateDate(dangerManage.getGmtModitify());
|
dangerInfo.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
dangerInfo.setReportTime(null);
|
dangerInfo.setDataSource((byte) 1);
|
|
PreventRiskAnaUnit riskUnit = preventRiskUnitService.getRiskUnitById(dangerManage.getRiskUnitId());
|
if (ObjectUtils.isNotEmpty(riskUnit)){
|
|
dangerInfo.setHazardCode(riskUnit.getRiskCode());//风险分析对象编码
|
}else {
|
dangerInfo.setHazardCode(null);//风险分析对象编码
|
}
|
|
PreventDangerCheckTask task = preventDangerCheckTaskService.getTaskById(dangerManage.getTaskId());
|
if (ObjectUtils.isNotEmpty(task)){
|
dangerInfo.setCheckRecordId(task.getUuid());//隐患排查任务记录uuid
|
PreventTaskAndMeasure taskAndMeasureByTaskId = preventTaskAndMeasureService.getTaskAndMeasureByTaskId(task.getId());
|
PreventRiskControlMeasure controlMeasure = preventRiskControlMeasureService.getControlMeasureById(taskAndMeasureByTaskId.getControlMeasureId());
|
dangerInfo.setRiskMeasureId(controlMeasure.getUuid());//管控措施uuid
|
}else {
|
dangerInfo.setCheckRecordId(null);//隐患排查任务记录uuid
|
dangerInfo.setRiskMeasureId(null);//管控措施uuid
|
}
|
dangerInfo.setDangerName(dangerManage.getDangerCode());//隐患名称--DangerCode
|
dangerInfo.setDangerLevel(level.toString());//
|
dangerInfo.setDangerSrc(dangerManage.getDangerSource().toString());//隐患来源
|
dangerInfo.setDangerManageType(rectify.getRectifyType().toString());//隐患治理类型
|
dangerInfo.setDangerDesc(dangerManage.getDangerDesc());//隐患描述
|
dangerInfo.setDangerReason(dangerManage.getDangerReason());//隐患产生原因
|
dangerInfo.setControlMeasures(rectify.getRectifyDesc());//控制措施 ,整改措施
|
|
dangerInfo.setCost(rectify.getCost().toString());//资金
|
dangerInfo.setDangerManageDeadline(rectify.getRectifyTime());//治理期限
|
dangerInfo.setDangerState(dangerManage.getDangerStatus().toString());//隐患状态
|
dangerInfo.setHazardDangerType(dangerManage.getDangerType().toString());//隐患类型
|
dangerInfo.setRegistrant(dangerManage.getCreateByUserName());//登记人
|
dangerInfo.setRegistTime(dangerManage.getGmtCreate());//登记时间
|
dangerInfo.setLiablePerson(rectify.getLiablePerson());//整改责任人
|
dangerInfo.setCheckAcceptPerson(rectify.getCheckAcceptPerson());//验收人
|
dangerInfo.setCheckAcceptComment(rectify.getCheckAcceptDesc());//验收情况
|
dangerInfo.setCheckAcceptTime(rectify.getCheckAcceptTime());//验收时间
|
|
dangerInfo.setDangerManagerId(dangerManage.getId());
|
|
//封装数据
|
dangerInfoLists.add(dangerInfo);
|
//设置原始数据上报状态
|
handlerReportParam.setId(dangerManage.getId());
|
handlerReportParam.setReportTime(new Date());
|
handlerReportParam.setReportStatus(SyncEnum.SYNC_WAIT_EXEC.getCode());
|
preventDangerManageService.updateManageReportStatus(handlerReportParam);
|
preventDangerRectifyService.updateRectifyReportStatus(handlerReportParam);
|
}
|
}else {
|
logger.info("【***】当前无隐患信息需要处理");
|
// System.out.println("【***】当前无隐患信息需要处理");
|
}
|
//插入
|
for (PreventReportDangerInfo danger : dangerInfoLists) {
|
PreventReportDangerInfo dangerById = dangerInfoService.getDangerById(danger.getId());
|
if (ObjectUtils.isEmpty(dangerById)){
|
int result = dangerInfoService.insert(danger);
|
if (result < 0){
|
throw new BusinessException(E.ADD_FAIL.getCode(), "隐患信息插入失败");
|
}
|
}else {
|
dangerInfoService.updateDangerById(danger);
|
}
|
|
logger.info("【***】隐患信息：数据处理...");
|
// System.out.println("【***】隐患信息：数据处理...");
|
}
|
}else {
|
logger.info("隐患信息数据上报已关闭");
|
}
|
|
// System.out.println("【***】检索需要上报数据完成...");
|
logger.info("检索需要上报数据完成...");
|
|
}
|
}
|
