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 riskAnaUnitList = preventRiskUnitService.listRiskAnaUnit(); //获取上报数据list List 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 riskEvents = preventRiskEventService.listReportEvent(); //获取上报数据对象与list List 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 measures = preventRiskControlMeasureService.listReportMeasure(); //获取上报数据list List 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 works = preventDangerCheckWorkService.listReportWork(); //获取上报数据对象与list List taskFromWorkLists = new ArrayList<>(); HandlerReportParam handlerReportParam = new HandlerReportParam(); if (ObjectUtils.isNotEmpty(works)){ //遍历，封装数据 for (PreventDangerCheckWork work : works) { //获取work与措施关联信息 List 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 tasks = preventDangerCheckTaskService.listReportTask(); //获取上报数据对象 List 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 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 dangerManages = preventDangerManageService.listReportDanger(); //获取上报数据list List 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("检索需要上报数据完成..."); } }