隐患来源功能外加仓吉基础数据定时上报

heheng

2025-06-24 e98eeaaa5766511fdb8e6d5e412eb1c59d1f07ce

 src/main/java/com/ruoyi/doublePrevention/scheduls/SearchReportDateSchedule.java

@@ -1,6 +1,7 @@
package com.ruoyi.doublePrevention.scheduls;


import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.doublePrevention.entity.*;
import com.ruoyi.doublePrevention.entity.CJReport.*;
import com.ruoyi.doublePrevention.enums.E;
@@ -20,6 +21,7 @@
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;
@@ -31,10 +33,10 @@
import java.text.SimpleDateFormat;
import java.util.*;

@Slf4j
@Component
public class SearchReportDateSchedule {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    public static SimpleDateFormat startFormat = new SimpleDateFormat("yyyy-MM-dd 06:30:00");
    public static SimpleDateFormat endFormat = new SimpleDateFormat("yyyy-MM-dd 23:59:59");
@@ -107,12 +109,12 @@


    @Transactional
    @Scheduled(cron = "0 0/10 * * * ? ")    // 分钟
    @Scheduled(cron = "0 0/2 * * * ? ")    // 分钟
//    @Scheduled(cron = "0/10 * * * * ?")  // 30秒
 //   @Scheduled(cron = "0 0/25 * * * ? ")    // 分钟
    public void searchReportDate(){

        logger.info("【双重预防】定时检索需要上报数据...");
        log.info("【双重预防】定时检索需要上报数据...");
        int step = 1;
        String companyCode = "652310082";

@@ -124,7 +126,7 @@
        //如果主配置开启上报，开始
        if (unitReportConfig.getReportState().equals(SyncEnum.REPORT_ON.getCode())){

            logger.info("【##】1.检索风险分析单元...");
            log.info("【##】1.检索风险分析单元...");

            //查询所有 选择上报的数据 && (reportTime == null 或者 reportTime < updateReportDataTime）
            List<PreventRiskUnitUuid> riskUnitUuidList = preventRiskUnitUuidService.listRiskAnaUnit();
@@ -171,6 +173,8 @@
                    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);
@@ -181,17 +185,17 @@
                    int result = preventRiskUnitUuidService.updateReportStatus(handlerReportParam);
                }
            }else {
                logger.info("【双重预防】当前无风险分析单元数据需要处理");
                log.info("【双重预防】当前无风险分析单元数据需要处理");
            }
            //写入昌吉州转换表
            for (PreventCJReportRiskAnaUnit CJUnit : CJUnitLists) {
                CJRiskAnaUnitService.insertUnitList(CJUnit);
                logger.info("【双重预防】1.风险分析单元CJ：数据处理...");
                log.info("【双重预防】1.风险分析单元CJ：数据处理...");
            }
            step = 2;
        }else {
            step = 2;
            logger.info("风险分析单元数据上报已关闭");
            log.info("风险分析单元数据上报已关闭");
        }


@@ -228,6 +232,8 @@
                    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());
@@ -242,17 +248,17 @@
                    preventRiskEventService.updateEventReportStatus(handlerReportParam);
                }
            }else {
                logger.info("【双重预防】当前无安全风险事件数据需要处理");
                log.info("【双重预防】当前无安全风险事件数据需要处理");
            }
            //写入昌吉州转换表
            for (PreventCJReportRiskEvent CJEvent : CJEventLists) {
                CJEventService.insertEventLists(CJEvent);
                logger.info("【双重预防】2.风险分析事件CJ：数据处理...");
                log.info("【双重预防】2.风险分析事件CJ：数据处理...");
            }
            step = 3;
        }else {
            step = 3;
            logger.info("安全风险事件数据上报已关闭");
            log.info("安全风险事件数据上报已关闭");
        }


@@ -295,6 +301,8 @@
                    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());
@@ -315,7 +323,7 @@
                    preventRiskControlMeasureService.updateMeasureReportStatus(handlerReportParam);
                }
            }else {
                logger.info("【双重预防】当前无安全风险管控措施数据需要处理");
                log.info("【双重预防】当前无安全风险管控措施数据需要处理");
            }

            step = 4;
@@ -324,11 +332,11 @@
            for (PreventCJReportRiskControlMeasure CJMeasure : CJMeasureLists) {
                CJMeasureService.insertMeasureList(CJMeasure);

                logger.info("【双重预防】3.安全风险管控措施CJ：数据处理...");
                log.info("【双重预防】3.安全风险管控措施CJ：数据处理...");
            }
        }else {
            step = 4;
            logger.info("安全风险管控措施数据上报已关闭");
            log.info("安全风险管控措施数据上报已关闭");
        }

        /**
@@ -344,7 +352,7 @@
            //获取上报数据对象与list
            List<PreventCJReportCheckTaskFromWork> CJTaskFromWorkLists = new ArrayList<>();
            HandlerReportParam handlerReportParam = new HandlerReportParam();

            log.info("检索任务配置开始执行,{}",works.size());
            if (ObjectUtils.isNotEmpty(works)){
                //遍历，封装数据
                for (PreventRiskJobAndMeasure work : works) {
@@ -404,6 +412,8 @@
                    }
                    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());
@@ -433,16 +443,17 @@
                    preventRiskJobAndMeasureService.updateWorkReportStatus(handlerReportParam);
                }
            }else {
                logger.info("【双重预防】当前无任务配置数据需要处理");
                log.info("【双重预防】当前无任务配置数据需要处理");
            }
            //写入上报昌吉州数据转换表
            log.info("【双重预防】任务配置CJ数量:{}",CJTaskFromWorkLists.size());
            for (PreventCJReportCheckTaskFromWork CJTaskFromWorks : CJTaskFromWorkLists) {
                CJTaskFromWorkService.insertTaskFromWorkList(CJTaskFromWorks);
                logger.info("【双重预防】任务配置CJ：数据处理...");
                log.info("【双重预防】任务配置CJ：数据处理...");
            }
        }else {
            step = 5;
            logger.info("任务配置数据上报已关闭");
            log.info("任务配置数据上报已关闭");
        }


@@ -482,7 +493,7 @@

                        //避免个别任务无检查点的情况
                        if (ObjectUtils.isEmpty(hiddenDangerCheckPointList)) {
                            logger.info("【双重预防】排查任务记录CJ：异常，无检查点...");
                            log.info("【双重预防】排查任务记录CJ：异常，无检查点...");
                        }else {
                            for (HiddenDangerCheckPoint hiddenDangerCheckPoint : hiddenDangerCheckPointList) {
                                //获取上报数据对象
@@ -544,6 +555,8 @@
                                }
                                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，
@@ -557,15 +570,27 @@
//                                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());
                                        CJRecordFromTask.setCheckTaskId(preventCJReportCheckTaskFromWork.getId());
                                        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());
                                //第二版标准新增
@@ -609,11 +634,11 @@

                }
            }else {
                logger.info("【双重预防】当前无排查任务记录需要处理");
                log.info("【双重预防】当前无排查任务记录需要处理");
            }

            if (CJRecordFromTaskLists.size() > 0){
                logger.info("【双重预防】排查任务记录CJ：数据处理...");
                log.info("【双重预防】排查任务记录CJ：数据处理...");
                //设置原始数据状态
                int taskUpdateResult = preventRiskDangerCheckLogService.updateTaskReportStatusByList(taskIds);
                if (taskUpdateResult < taskIds.size()){
@@ -627,7 +652,7 @@
            step = 6;
        }else {
            step = 6;
            logger.info("排查任务记录数据上报已关闭");
            log.info("排查任务记录数据上报已关闭");
        }


@@ -677,7 +702,18 @@
                        User rectifyUser = trUserService.getUserByLoginName(hiddenDanger.getRectifyUserName());
                        //整改人信息
                        CJDangerInfo.setLiablePerson(rectifyUser.getUserName());//整改责任人
                        CJDangerInfo.setCost(hiddenDanger.getRectifyFund());//资金
                        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())){
@@ -728,6 +764,8 @@
                    }
                    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());
@@ -755,20 +793,20 @@
                    preventRiskDangerInfoService.updateDangerInfoReportStatus(handlerReportParam);
                }
            }else {
                logger.info("【双重预防】当前无隐患信息需要处理");
                log.info("【双重预防】当前无隐患信息需要处理");
            }

            //插入上报昌吉州转换表
            for (PreventCJReportDangerInfo CJDanger : CJDangerInfoLists) {
                logger.info("【双重预防】隐患信息插入...");
                log.info("【双重预防】隐患信息插入...");
                int result = CJDangerInfoService.insert(CJDanger);
                if (result < 0){
                    throw new AusinessException(E.ADD_FAIL.getCode(), "隐患信息插入失败");
                }
                logger.info("【双重预防】隐患信息：数据处理...");
                log.info("【双重预防】隐患信息：数据处理...");
            }
        }else {
            logger.info("隐患信息数据上报已关闭");
            log.info("隐患信息数据上报已关闭");
        }