package com.gk.hotwork.doublePrevention.scheduls;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.gk.hotwork.Config.Log.HiddenDangerLogAspect;
import com.gk.hotwork.doublePrevention.entity.dto.report.ReportResultDTO;
import com.gk.hotwork.doublePrevention.utils.BeanCopyUtils;
import com.gk.hotwork.doublePrevention.entity.*;
import com.gk.hotwork.doublePrevention.entity.dto.report.HandlerDO.*;
import com.gk.hotwork.doublePrevention.enums.SyncEnum;
import com.gk.hotwork.doublePrevention.repository.param.HandlerReportParam;
import com.gk.hotwork.doublePrevention.service.ReportService;
import com.gk.hotwork.doublePrevention.service.baseService.*;
import com.gk.hotwork.doublePrevention.utils.AesGcm256Util;
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.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.*;

@Component
public class ExecReportDateSchedule {

    private static final org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(ExecReportDateSchedule.class);

    @Autowired
    private ReportService reportService;

    @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;
    @Autowired
    private PreventReportBatchService preventReportBatchService;

    @Transactional
    @Scheduled(cron = "0 0 0/2 * * ? ")
//    @Scheduled(cron = "0/10 * * * * ?")
    public void execReportDateSchedule(){
        logger.info("【￥￥】上报数据开始...");
        System.out.println("【￥￥】上报数据开始...");
        Date date = new Date();
        HttpURLConnection con = null;
        BufferedReader buffer = null;
        int responseCode = 200;
        //格式化时间，作为token的时间戳
        SimpleDateFormat tokenDate= new SimpleDateFormat("yyyyMMddHHMMssSSS");
        String formatDate = tokenDate.format(date);

        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:MM:ss");

        String token = "4348187236";
        String key = "84702E415A73CE27077B5F726E7BDBB0";
        String iv = "1C7AA98593AA69F4AAE119BD5C01D9ED";

        /**1、处理安全风险分析单元数据*/
        logger.info("【【##】】处理安全风险分析单元数据");
        System.out.println("【【##】】1、处理安全风险分析单元数据...");
        List<PreventReportRiskAnaUnit> riskAnaUnits = riskAnaUnitService.listReportUnitDate();
        if (ObjectUtils.isNotEmpty(riskAnaUnits)){
            //封装上报数据
            List<ReportRiskAnaUnitDTO> reportRiskAnaUnitList = new ArrayList<>();
            for (PreventReportRiskAnaUnit riskAnaUnit : riskAnaUnits) {
                ReportRiskAnaUnitDTO unit = BeanCopyUtils.copyBean(riskAnaUnit, ReportRiskAnaUnitDTO.class);
                unit.setCreateDate(dateFormat.format(riskAnaUnit.getCreateDate()));
                unit.setUpdateDate(dateFormat.format(riskAnaUnit.getUpdateDate()));
                reportRiskAnaUnitList.add(unit);
            }
            //加密数据
            String reportUnitDate = AesGcm256Util.encrypt(JSONArray.toJSON(reportRiskAnaUnitList).toString(),
                    AesGcm256Util.hexToByte("84702E415A73CE27077B5F726E7BDBB0"),
                    AesGcm256Util.hexToByte("1C7AA98593AA69F4AAE119BD5C01D9ED"));
            StringBuffer unitResultBuffer = null;
            System.out.println("安全风险分析单元数据加密完成");
            //上报数据
            try {
                URL url = new URL("http://220.171.99.118:6022/v2/data/receive/receiveUnitList");
                //得到连接对象
                con = (HttpURLConnection) url.openConnection();
                //设置请求类型
                con.setRequestMethod("POST");
                //设置Content-Type，此处根据实际情况确定
                con.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
                //允许写出
                con.setDoOutput(true);
                //允许读入
                con.setDoInput(true);
                //不使用缓存
                con.setUseCaches(false);
                //设置请求头
                con.setRequestProperty("Authorization",token + formatDate.toString());
                OutputStream os = con.getOutputStream();
                Map paraMap = new HashMap();
                paraMap.put("data", reportUnitDate); /**封装数据*/
                //组装入参，设置请求体
                os.write(JSON.toJSONString(paraMap).getBytes());
                //本段日志，测试成功后，可注释掉
                if (responseCode == HttpURLConnection.HTTP_OK) {
                    System.out.println("获取响应流");
                    //得到响应流
                    InputStream inputStream = con.getInputStream();
                    //将响应流转换成字符串
                    unitResultBuffer = new StringBuffer();
                    String line;
                    buffer = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
                    while ((line = buffer.readLine()) != null) {
                        unitResultBuffer.append(line);
                    }
                    logger.info("【【##】】riskUnitResult:" + date + "\n" + unitResultBuffer.toString());
                    System.out.println("分析单元上报结果:" + date + unitResultBuffer.toString());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            //遍历数据，更改原始表、上报表状态

            //拼接上报数据的uuid
            StringBuffer idTextBuffer = new StringBuffer();

            for (PreventReportRiskAnaUnit riskAnaUnit : riskAnaUnits) {
                HandlerReportParam handlerReportParam = new HandlerReportParam();
                //封装数据
                handlerReportParam.setId(riskAnaUnit.getRiskUnitId());
                handlerReportParam.setReportStatus(SyncEnum.SYNC_EXEC_SUCCESS.getCode());
                handlerReportParam.setReportTime(date);
                riskAnaUnitService.updateReportStatus(handlerReportParam);
                preventRiskUnitService.updateReportStatus(handlerReportParam);

                idTextBuffer.append(riskAnaUnit.getId() + ";");
            }
            ReportResultDTO unitResult = JSONObject.parseObject(unitResultBuffer.toString(), ReportResultDTO.class);
            //获取返回值封装对象
            PreventReportBatch reportBatch = new PreventReportBatch();
            reportBatch.setBatchId(unitResult.getObj().getBatchId());
            reportBatch.setDataSource(idTextBuffer.toString());
            reportBatch.setReportTime(date);
            reportBatch.setDataType(SyncEnum.REPORT_CONFIG_RISK_ANA_UNIT.getCode());
            preventReportBatchService.insertBatchId(reportBatch);

            System.out.println("安全风险分析单元数据处理完成。");
        }else {
            System.out.println("***安全风险分析单元数据处理完成。");
        }


        /**2、处理安全风险事件数据*/
        logger.info("【【##】】处理安全风险事件数据");
        System.out.println("【【##】】2、处理安全风险事件数据...");
        List<PreventReportRiskEvent> events = eventService.listReportEventDate();
        if (ObjectUtils.isNotEmpty(events)){
            //封装上报数据
            List<ReportRiskEventDTO> reportRiskEventList = new ArrayList<>();
            for (PreventReportRiskEvent event : events) {
                ReportRiskEventDTO riskEvent = BeanCopyUtils.copyBean(event, ReportRiskEventDTO.class);
                riskEvent.setCreateDate(dateFormat.format(event.getCreateDate()));
                riskEvent.setUpdateDate(dateFormat.format(event.getUpdateDate()));
                reportRiskEventList.add(riskEvent);
            }
            //加密数据
            String reportEventDate = AesGcm256Util.encrypt(JSONArray.toJSON(reportRiskEventList).toString(),
                    AesGcm256Util.hexToByte("84702E415A73CE27077B5F726E7BDBB0"),
                    AesGcm256Util.hexToByte("1C7AA98593AA69F4AAE119BD5C01D9ED"));

            StringBuffer eventResultBuffer = null;

            //上报数据
            try {
                URL url = new URL("http://220.171.99.118:6022/v2/data/receive/receiveEventList");
                //得到连接对象
                con = (HttpURLConnection) url.openConnection();
                //设置请求类型
                con.setRequestMethod("POST");
                //设置Content-Type，此处根据实际情况确定
                con.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
                //允许写出
                con.setDoOutput(true);
                //允许读入
                con.setDoInput(true);
                //不使用缓存
                con.setUseCaches(false);
                //设置请求头
                con.setRequestProperty("Authorization",token+formatDate.toString());
                OutputStream os = con.getOutputStream();
                Map paraMap = new HashMap();
                paraMap.put("data", reportEventDate); /**封装数据*/
                //组装入参，设置请求体
                os.write(JSON.toJSONString(paraMap).getBytes());
                //得到响应码
                responseCode = con.getResponseCode();
                //本段日志，测试成功后，可注释掉
                if (responseCode == HttpURLConnection.HTTP_OK) {
                    //得到响应流
                    InputStream inputStream = con.getInputStream();
                    //将响应流转换成字符串
                    eventResultBuffer = new StringBuffer();
                    String line;
                    buffer = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
                    while ((line = buffer.readLine()) != null) {
                        eventResultBuffer.append(line);
                    }
                    logger.info("【【##】】eventResult:"  + date + "\n" +  eventResultBuffer.toString());
                    System.out.println("风险事件上报结果:"  + date + "\n" +  eventResultBuffer.toString());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            //拼接上报数据的uuid
            StringBuffer idTextBuffer = new StringBuffer();

            //遍历数据，更改原始表、上报表状态
            for (PreventReportRiskEvent event : events) {
                HandlerReportParam handlerReportParam = new HandlerReportParam();
                //封装数据
                handlerReportParam.setId(event.getRiskEventId());
                handlerReportParam.setReportStatus(SyncEnum.SYNC_EXEC_SUCCESS.getCode());
                handlerReportParam.setReportTime(date);
                eventService.updateEventReportStatus(handlerReportParam);
                preventRiskEventService.updateEventReportStatus(handlerReportParam);

                idTextBuffer.append(event.getId() + ";");
            }
            ReportResultDTO eventResult = JSONObject.parseObject(eventResultBuffer.toString(), ReportResultDTO.class);
            //获取返回值封装对象
            PreventReportBatch reportBatch = new PreventReportBatch();
            reportBatch.setBatchId(eventResult.getObj().getBatchId());
            reportBatch.setDataSource(idTextBuffer.toString());
            reportBatch.setReportTime(date);
            reportBatch.setDataType(SyncEnum.REPORT_CONFIG_RISK_EVENT.getCode());
            preventReportBatchService.insertBatchId(reportBatch);

            System.out.println("安全风险分析事件数据处理完成。");
        }else {
            System.out.println("***安全风险分析事件数据处理完成。");
        }



        /**3、处理风险管控措施数据*/
        logger.info("【【##】】处理风险管控措施数据");
        System.out.println("【【##】3、处理风险管控措施数据...");
        List<PreventReportRiskControlMeasure> measures = measureService.listReportMeasureDate();
        if (ObjectUtils.isNotEmpty(measures)){
            //封装上报数据
            List<ReportRiskControlMeasureDTO> reportMeasureList = new ArrayList<>();
            for (PreventReportRiskControlMeasure measure : measures) {
                ReportRiskControlMeasureDTO controlMeasure = BeanCopyUtils.copyBean(measure, ReportRiskControlMeasureDTO.class);
                controlMeasure.setCreateDate(dateFormat.format(measure.getCreateDate()));
                controlMeasure.setUpdateDate(dateFormat.format(measure.getUpdateDate()));
                reportMeasureList.add(controlMeasure);
            }

            //数据上报
            String reportMeasureDate = AesGcm256Util.encrypt(JSONArray.toJSON(reportMeasureList).toString(),
                    AesGcm256Util.hexToByte("84702E415A73CE27077B5F726E7BDBB0"),
                    AesGcm256Util.hexToByte("1C7AA98593AA69F4AAE119BD5C01D9ED"));
            StringBuffer measureResultBuffer = null;
            //上报数据
            try {
                URL url = new URL("http://220.171.99.118:6022/v2/data/receive/receiveControlMeasuresList");
                //得到连接对象
                con = (HttpURLConnection) url.openConnection();
                //设置请求类型
                con.setRequestMethod("POST");
                //设置Content-Type，此处根据实际情况确定
                con.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
                //允许写出
                con.setDoOutput(true);
                //允许读入
                con.setDoInput(true);
                //不使用缓存
                con.setUseCaches(false);
                //设置请求头
                con.setRequestProperty("Authorization",token + formatDate.toString());
                OutputStream os = con.getOutputStream();
                Map paraMap = new HashMap();
                paraMap.put("data", reportMeasureDate); /**封装数据*/
                //组装入参，设置请求体
                os.write(JSON.toJSONString(paraMap).getBytes());
                //得到响应码
                responseCode = con.getResponseCode();
                //本段日志，测试成功后，可注释掉
                if (responseCode == HttpURLConnection.HTTP_OK) {
                    //得到响应流
                    InputStream inputStream = con.getInputStream();
                    //将响应流转换成字符串
                    measureResultBuffer = new StringBuffer();
                    String line;
                    buffer = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
                    while ((line = buffer.readLine()) != null) {
                        measureResultBuffer.append(line);
                    }
                    logger.info("【【##】】measureResult:"  + date + "\n" +  measureResultBuffer.toString());
                    System.out.println("管控措施数据上报结果:"  + date + "\n" +  measureResultBuffer.toString());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

            //拼接上报数据的uuid
            StringBuffer idTextBuffer = new StringBuffer();

            //遍历数据，更改原始表、上报表状态
            for (PreventReportRiskControlMeasure measure : measures) {
                HandlerReportParam handlerReportParam = new HandlerReportParam();
                //封装数据
                handlerReportParam.setId(measure.getRiskMeasureId());
                handlerReportParam.setReportStatus(SyncEnum.SYNC_EXEC_SUCCESS.getCode());
                handlerReportParam.setReportTime(date);
                measureService.updateMeasureReportStatus(handlerReportParam);
                preventRiskControlMeasureService.updateMeasureReportStatus(handlerReportParam);

                idTextBuffer.append(measure.getId() + ";");
            }
            ReportResultDTO measureResult = JSONObject.parseObject(measureResultBuffer.toString(), ReportResultDTO.class);
            //获取返回值封装对象
            PreventReportBatch reportBatch = new PreventReportBatch();
            reportBatch.setBatchId(measureResult.getObj().getBatchId());
            reportBatch.setDataSource(idTextBuffer.toString());
            reportBatch.setReportTime(date);
            reportBatch.setDataType(SyncEnum.REPORT_CONFIG_RISK_MEASURE.getCode());
            preventReportBatchService.insertBatchId(reportBatch);


            System.out.println("管控措施数据处理完成。");
        }else {
            System.out.println("***管控措施数据处理完成。");
        }


        /**4、处理 任务-配置 数据*/
        logger.info("【【##】】处理任务配置 数据");
        System.out.println("【【##】4、处理任务配置数据...");
        List<PreventReportCheckTaskFromWork> taskFromWorks = taskFromWorkService.listReportTaskFromWorkDate();
        if (ObjectUtils.isNotEmpty(taskFromWorks)){
            //封装上报数据
            List<ReportCheckTaskFromWorkDTO> reportCheckTaskFromWorkList = new ArrayList<>();
            for (PreventReportCheckTaskFromWork taskFromWork : taskFromWorks) {
                ReportCheckTaskFromWorkDTO checkWork = BeanCopyUtils.copyBean(taskFromWork, ReportCheckTaskFromWorkDTO.class);
                checkWork.setCreateDate(dateFormat.format(taskFromWork.getCreateDate()));
                checkWork.setUpdateDate(dateFormat.format(taskFromWork.getUpdateDate()));
                reportCheckTaskFromWorkList.add(checkWork);
            }

            //数据上报
            String reportTaskFromWorkDate = AesGcm256Util.encrypt(JSONArray.toJSON(reportCheckTaskFromWorkList).toString(),
                    AesGcm256Util.hexToByte("84702E415A73CE27077B5F726E7BDBB0"),
                    AesGcm256Util.hexToByte("1C7AA98593AA69F4AAE119BD5C01D9ED"));
            StringBuffer taskFromWorkResultBuffer = null;
            //上报数据
            try {
                URL url = new URL("http://220.171.99.118:6022/v2/data/receive/receiveMeasuresTaskList");
                //得到连接对象
                con = (HttpURLConnection) url.openConnection();
                //设置请求类型
                con.setRequestMethod("POST");
                //设置Content-Type，此处根据实际情况确定
                con.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
                //允许写出
                con.setDoOutput(true);
                //允许读入
                con.setDoInput(true);
                //不使用缓存
                con.setUseCaches(false);
                //设置请求头
                con.setRequestProperty("Authorization",token+formatDate.toString());
                OutputStream os = con.getOutputStream();
                Map paraMap = new HashMap();
                paraMap.put("data", reportTaskFromWorkDate); /**封装数据*/
                //组装入参，设置请求体
                os.write(JSON.toJSONString(paraMap).getBytes());
                //得到响应码
                responseCode = con.getResponseCode();
                //本段日志，测试成功后，可注释掉
                if (responseCode == HttpURLConnection.HTTP_OK) {
                    //得到响应流
                    InputStream inputStream = con.getInputStream();
                    //将响应流转换成字符串
                    taskFromWorkResultBuffer = new StringBuffer();
                    String line;
                    buffer = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
                    while ((line = buffer.readLine()) != null) {
                        taskFromWorkResultBuffer.append(line);
                    }
                    logger.info("【【##】】workResult:"  + date + "\n" +  taskFromWorkResultBuffer.toString());
                    System.out.println("任务配置上报结果:"  + date + "\n" +  taskFromWorkResultBuffer.toString());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

            //拼接上报数据的uuid
            StringBuffer idTextBuffer = new StringBuffer();

            //遍历数据，更改原始表、上报表状态
            for (PreventReportCheckTaskFromWork taskFromWork : taskFromWorks) {
                HandlerReportParam handlerReportParam = new HandlerReportParam();
                //封装数据
                handlerReportParam.setId(taskFromWork.getWorkId());
                handlerReportParam.setReportStatus(SyncEnum.SYNC_EXEC_SUCCESS.getCode());
                handlerReportParam.setReportTime(date);
                taskFromWorkService.updateWorkReportStatus(handlerReportParam);
                preventDangerCheckWorkService.updateWorkReportStatus(handlerReportParam);

                idTextBuffer.append(taskFromWork.getId() + ";");
            }
            ReportResultDTO taskFromWorkResult = JSONObject.parseObject(taskFromWorkResultBuffer.toString(), ReportResultDTO.class);

            //获取返回值封装对象
            PreventReportBatch reportBatch = new PreventReportBatch();
            reportBatch.setBatchId(taskFromWorkResult.getObj().getBatchId());
            reportBatch.setDataSource(idTextBuffer.toString());
            reportBatch.setReportTime(date);
            reportBatch.setDataType(SyncEnum.REPORT_CONFIG_TASK_FROM_WORK.getCode());
            preventReportBatchService.insertBatchId(reportBatch);

            System.out.println("任务配置数据处理完成。");
        }else {
            System.out.println("***任务配置数据处理完成。");
        }


        /**5、处理 任务-记录 数据*/
        logger.info("【【##】】处理任务记录数据");
        System.out.println("【【##】】5、处理任务记录数据...");
        List<PreventReportCheckRecordFromTask> recordFromTasks = taskRecordService.listReportTaskRecordDate();
        if (ObjectUtils.isNotEmpty(recordFromTasks)){
            //封装上报数据
            List<ReportCheckRecordFromTaskDTO> reportRecordFromTaskList = new ArrayList<>();
            for (PreventReportCheckRecordFromTask recordFromTask : recordFromTasks) {
                ReportCheckRecordFromTaskDTO checkTask = BeanCopyUtils.copyBean(recordFromTask, ReportCheckRecordFromTaskDTO.class);
                checkTask.setCreateDate(dateFormat.format(recordFromTask.getCreateDate()));
                checkTask.setUpdateDate(dateFormat.format(recordFromTask.getUpdateDate()));
                checkTask.setCheckTime(dateFormat.format(recordFromTask.getCheckTime()));
                reportRecordFromTaskList.add(checkTask);
            }

            //数据上报
            String reportRecordFromTaskDate = AesGcm256Util.encrypt(JSONArray.toJSON(reportRecordFromTaskList).toString(),
                    AesGcm256Util.hexToByte("84702E415A73CE27077B5F726E7BDBB0"),
                    AesGcm256Util.hexToByte("1C7AA98593AA69F4AAE119BD5C01D9ED"));
            StringBuffer recordFromTaskResultBuffer = null;
            //上报数据
            try {
                URL url = new URL("http://220.171.99.118:6022/v2/data/receive/receiveMeasuresTaskRecordList");
                //得到连接对象
                con = (HttpURLConnection) url.openConnection();
                //设置请求类型
                con.setRequestMethod("POST");
                //设置Content-Type，此处根据实际情况确定
                con.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
                //允许写出
                con.setDoOutput(true);
                //允许读入
                con.setDoInput(true);
                //不使用缓存
                con.setUseCaches(false);
                //设置请求头
                con.setRequestProperty("Authorization",token+formatDate.toString());
                OutputStream os = con.getOutputStream();
                Map paraMap = new HashMap();
                paraMap.put("data", reportRecordFromTaskDate);/**封装数据*/
                //组装入参，设置请求体
                os.write(JSON.toJSONString(paraMap).getBytes());
                //得到响应码
                responseCode = con.getResponseCode();
                //本段日志，测试成功后，可注释掉
                if (responseCode == HttpURLConnection.HTTP_OK) {
                    //得到响应流
                    InputStream inputStream = con.getInputStream();
                    //将响应流转换成字符串
                    recordFromTaskResultBuffer = new StringBuffer();
                    String line;
                    buffer = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
                    while ((line = buffer.readLine()) != null) {
                        recordFromTaskResultBuffer.append(line);
                    }
                    logger.info("【【##】】taskResult:"  + date + "\n" +  recordFromTaskResultBuffer.toString());
                    System.out.println("任务记录上报结果:"  + date + "\n" +  recordFromTaskResultBuffer.toString());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

            //拼接上报数据的uuid
            StringBuffer idTextBuffer = new StringBuffer();

            //遍历数据，更改原始表、上报表状态
            for (PreventReportCheckRecordFromTask recordFromTask : recordFromTasks) {
                HandlerReportParam handlerReportParam = new HandlerReportParam();
                //封装数据
                handlerReportParam.setId(recordFromTask.getTaskId());
                handlerReportParam.setReportStatus(SyncEnum.SYNC_EXEC_SUCCESS.getCode());
                handlerReportParam.setReportTime(date);
                taskRecordService.updateTaskReportStatus(handlerReportParam);
                preventDangerCheckTaskService.updateTaskReportStatus(handlerReportParam);

                idTextBuffer.append(recordFromTask.getId() + ";");
            }
            ReportResultDTO recordFromTaskResult = JSONObject.parseObject(recordFromTaskResultBuffer.toString(), ReportResultDTO.class);

            //获取返回值封装对象
            PreventReportBatch reportBatch = new PreventReportBatch();
            reportBatch.setBatchId(recordFromTaskResult.getObj().getBatchId());
            reportBatch.setDataSource(idTextBuffer.toString());
            reportBatch.setReportTime(date);
            reportBatch.setDataType(SyncEnum.REPORT_CONFIG__CHECK_RECORD.getCode());
            preventReportBatchService.insertBatchId(reportBatch);

            System.out.println("任务记录数据处理完成。");
        }else {
            System.out.println("***任务记录数据处理完成。");
        }


        /**6、处理隐患信息数据*/
        logger.info("【【##】】处理隐患信息数据");
        System.out.println("【【##】】6、处理隐患信息数据...");
        List<PreventReportDangerInfo> dangerInfos = dangerInfoService.listReportDangerDate();
        if (ObjectUtils.isNotEmpty(dangerInfos)){
            //封装上报数据
            List<ReportDangerInfoDTO> reportDangerInfoLists = new ArrayList<>();
            for (PreventReportDangerInfo dangerInfo : dangerInfos) {
                ReportDangerInfoDTO danger = BeanCopyUtils.copyBean(dangerInfo, ReportDangerInfoDTO.class);
                danger.setCreateDate(dateFormat.format(dangerInfo.getCreateDate()));
                danger.setUpdateDate(dateFormat.format(dangerInfo.getUpdateDate()));
                danger.setRegistTime(dateFormat.format(dangerInfo.getRegistTime()));
                danger.setDangerManageDeadline(dateFormat.format(dangerInfo.getDangerManageDeadline()));
                if (ObjectUtils.isNotEmpty(dangerInfo.getCheckAcceptTime())){
                    danger.setCheckAcceptTime(dateFormat.format(dangerInfo.getCheckAcceptTime()));
                }else {
                    danger.setCheckAcceptTime(null);
                }
                reportDangerInfoLists.add(danger);
            }

            //数据上报
            String reportDangerInfoDate = AesGcm256Util.encrypt(JSONArray.toJSON(reportDangerInfoLists).toString(),
                    AesGcm256Util.hexToByte("84702E415A73CE27077B5F726E7BDBB0"),
                    AesGcm256Util.hexToByte("1C7AA98593AA69F4AAE119BD5C01D9ED"));
            StringBuffer dangerInfoResultBuffer = null;
            //上报数据
            try {
                URL url = new URL("http://220.171.99.118:6022/v2/data/receive/receiveDangerInvestigationList");
                //得到连接对象
                con = (HttpURLConnection) url.openConnection();
                //设置请求类型
                con.setRequestMethod("POST");
                //设置Content-Type，此处根据实际情况确定
                con.setRequestProperty("Content-Type", "application/json;charset=UTF-8");
                //允许写出
                con.setDoOutput(true);
                //允许读入
                con.setDoInput(true);
                //不使用缓存
                con.setUseCaches(false);
                //设置请求头
                con.setRequestProperty("Authorization",token + formatDate.toString());
                OutputStream os = con.getOutputStream();
                Map paraMap = new HashMap();
                paraMap.put("data", reportDangerInfoDate);/**封装数据*/
                //组装入参，设置请求体
                os.write(JSON.toJSONString(paraMap).getBytes());
                //得到响应码
                responseCode = con.getResponseCode();
                //本段日志，测试成功后，可注释掉
                if (responseCode == HttpURLConnection.HTTP_OK) {
                    //得到响应流
                    InputStream inputStream = con.getInputStream();
                    //将响应流转换成字符串
                    dangerInfoResultBuffer = new StringBuffer();
                    String line;
                    buffer = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
                    while ((line = buffer.readLine()) != null) {
                        dangerInfoResultBuffer.append(line);
                    }
                    logger.info("【【##】】dangerResult:"  + date + "\n" +  dangerInfoResultBuffer.toString());
                    System.out.println("隐患信息上传结果:"  + date + "\n" +  dangerInfoResultBuffer.toString());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

            //拼接上报数据的uuid
            StringBuffer idTextBuffer = new StringBuffer();

            //遍历数据，更改原始表、上报表状态
            for (PreventReportDangerInfo dangerInfo : dangerInfos) {
                HandlerReportParam handlerReportParam = new HandlerReportParam();
                //封装数据
                handlerReportParam.setId(dangerInfo.getDangerManagerId());
                handlerReportParam.setReportStatus(SyncEnum.SYNC_EXEC_SUCCESS.getCode());
                handlerReportParam.setReportTime(date);
                dangerInfoService.updateTaskReportStatus(handlerReportParam);
                preventDangerManageService.updateManageReportStatus(handlerReportParam);
                preventDangerRectifyService.updateRectifyReportStatus(handlerReportParam);

                idTextBuffer.append(dangerInfo.getId() + ";");

            }
            ReportResultDTO dangerInfoResult = JSONObject.parseObject(dangerInfoResultBuffer.toString(), ReportResultDTO.class);

            //获取返回值封装对象
            PreventReportBatch reportBatch = new PreventReportBatch();
            reportBatch.setBatchId(dangerInfoResult.getObj().getBatchId());
            reportBatch.setDataSource(idTextBuffer.toString());
            reportBatch.setDataType(SyncEnum.REPORT_CONFIG_DANGER_INFO.getCode());
            reportBatch.setReportTime(date);
            preventReportBatchService.insertBatchId(reportBatch);

            System.out.println("隐患信息数据处理完成。");
        }else {
            System.out.println("***隐患信息数据处理完成。");
        }


        logger.info("【【##】】本批次上报数据完成...");

    }
}