ipp-znrh/ipp-client/src/main/java/com/jiayue/ipfcst/client/service/GenerateBackPassDataService.java

package com.jiayue.ipfcst.client.service;

import cn.hutool.core.date.DateUtil;
import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jiayue.ipfcst.client.utils.EfileUtil;
import com.jiayue.ipfcst.client.utils.GzipUtil;
import com.jiayue.ipfcst.client.utils.JsonBeanUtil;
import com.jiayue.ipfcst.client.utils.TimeUtils;
import com.jiayue.ipfcst.common.core.exception.BusinessException;
import com.jiayue.ipfcst.common.core.util.DateMomentUtil;
import com.jiayue.ipfcst.common.core.util.DateTimeUtil;
import com.jiayue.ipp.common.data.entity.*;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FileUtils;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.io.*;
import java.text.SimpleDateFormat;
import java.time.ZoneId;
import java.util.*;
import java.util.Date;
import java.util.stream.Collectors;

/**
 * 生成回传数据
 *
 * @Author: tl
 * @Date: 2023/6/29 9:47
 */
@Service
@Slf4j
public class GenerateBackPassDataService {
    private final WindPowerReal15MinFD0001Service windPowerReal15MinFD0001Service;

    private final WindPowerReal15MinFD0002Service windPowerReal15MinFD0002Service;

    private final WindPowerReal15MinFD0003Service windPowerReal15MinFD0003Service;

    private final WindPowerReal15MinFD0004Service windPowerReal15MinFD0004Service;

    private final WindPowerReal15MinFD0005Service windPowerReal15MinFD0005Service;

    private final WindPowerReal15MinFD0006Service windPowerReal15MinFD0006Service;

    private final WindPowerReal15MinFD0007Service windPowerReal15MinFD0007Service;

    private static final String IMAGE_TYPE = "jpg";
    private static final String PLACE = "-0.99|";
    private static final Long oneDay = 3600 * 24 * 1000L - 1000L;
    private static final Integer packSize = 2000;

    private final JiaYueWindPowerDqResultCoverFD0001Service jiaYueWindPowerDqResultCoverFD0001Service;

    private final JiaYueWindPowerDqResultCoverFD0002Service jiaYueWindPowerDqResultCoverFD0002Service;

    private final JiaYueWindPowerDqResultCoverFD0003Service jiaYueWindPowerDqResultCoverFD0003Service;

    private final JiaYueWindPowerDqResultCoverFD0004Service jiaYueWindPowerDqResultCoverFD0004Service;

    private final JiaYueWindPowerDqResultCoverFD0005Service jiaYueWindPowerDqResultCoverFD0005Service;

    private final JiaYueWindPowerDqResultCoverFD0006Service jiaYueWindPowerDqResultCoverFD0006Service;

    private final JiaYueWindPowerDqResultCoverFD0007Service jiaYueWindPowerDqResultCoverFD0007Service;

    private final JiaYueWindPowerCdqResultCoverFD0001Service jiaYueWindPowerCdqResultCoverFD0001Service;

    private final JiaYueWindPowerCdqResultCoverFD0002Service jiaYueWindPowerCdqResultCoverFD0002Service;

    private final JiaYueWindPowerCdqResultCoverFD0003Service jiaYueWindPowerCdqResultCoverFD0003Service;

    private final JiaYueWindPowerCdqResultCoverFD0004Service jiaYueWindPowerCdqResultCoverFD0004Service;

    private final JiaYueWindPowerCdqResultCoverFD0005Service jiaYueWindPowerCdqResultCoverFD0005Service;

    private final JiaYueWindPowerCdqResultCoverFD0006Service jiaYueWindPowerCdqResultCoverFD0006Service;

    private final JiaYueWindPowerCdqResultCoverFD0007Service jiaYueWindPowerCdqResultCoverFD0007Service;


    public GenerateBackPassDataService(WindPowerReal15MinFD0001Service windPowerReal15MinFD0001Service,WindPowerReal15MinFD0002Service windPowerReal15MinFD0002Service,WindPowerReal15MinFD0003Service windPowerReal15MinFD0003Service,WindPowerReal15MinFD0004Service windPowerReal15MinFD0004Service,WindPowerReal15MinFD0005Service windPowerReal15MinFD0005Service,
                                       WindPowerReal15MinFD0006Service windPowerReal15MinFD0006Service,WindPowerReal15MinFD0007Service windPowerReal15MinFD0007Service,JiaYueWindPowerDqResultCoverFD0001Service jiaYueWindPowerDqResultCoverFD0001Service,JiaYueWindPowerDqResultCoverFD0002Service jiaYueWindPowerDqResultCoverFD0002Service,
                                       JiaYueWindPowerDqResultCoverFD0003Service jiaYueWindPowerDqResultCoverFD0003Service,JiaYueWindPowerDqResultCoverFD0004Service jiaYueWindPowerDqResultCoverFD0004Service,JiaYueWindPowerDqResultCoverFD0005Service jiaYueWindPowerDqResultCoverFD0005Service,JiaYueWindPowerDqResultCoverFD0006Service jiaYueWindPowerDqResultCoverFD0006Service,
                                       JiaYueWindPowerDqResultCoverFD0007Service jiaYueWindPowerDqResultCoverFD0007Service,JiaYueWindPowerCdqResultCoverFD0001Service jiaYueWindPowerCdqResultCoverFD0001Service,JiaYueWindPowerCdqResultCoverFD0002Service jiaYueWindPowerCdqResultCoverFD0002Service,
                                       JiaYueWindPowerCdqResultCoverFD0003Service jiaYueWindPowerCdqResultCoverFD0003Service,JiaYueWindPowerCdqResultCoverFD0004Service jiaYueWindPowerCdqResultCoverFD0004Service,JiaYueWindPowerCdqResultCoverFD0005Service jiaYueWindPowerCdqResultCoverFD0005Service,JiaYueWindPowerCdqResultCoverFD0006Service jiaYueWindPowerCdqResultCoverFD0006Service,
                                       JiaYueWindPowerCdqResultCoverFD0007Service jiaYueWindPowerCdqResultCoverFD0007Service){
        this.windPowerReal15MinFD0001Service = windPowerReal15MinFD0001Service;
        this.windPowerReal15MinFD0002Service = windPowerReal15MinFD0002Service;
        this.windPowerReal15MinFD0003Service = windPowerReal15MinFD0003Service;
        this.windPowerReal15MinFD0004Service = windPowerReal15MinFD0004Service;
        this.windPowerReal15MinFD0005Service = windPowerReal15MinFD0005Service;
        this.windPowerReal15MinFD0006Service = windPowerReal15MinFD0006Service;
        this.windPowerReal15MinFD0007Service = windPowerReal15MinFD0007Service;
        this.jiaYueWindPowerDqResultCoverFD0001Service = jiaYueWindPowerDqResultCoverFD0001Service;
        this.jiaYueWindPowerDqResultCoverFD0002Service = jiaYueWindPowerDqResultCoverFD0002Service;
        this.jiaYueWindPowerDqResultCoverFD0003Service = jiaYueWindPowerDqResultCoverFD0003Service;
        this.jiaYueWindPowerDqResultCoverFD0004Service = jiaYueWindPowerDqResultCoverFD0004Service;
        this.jiaYueWindPowerDqResultCoverFD0005Service = jiaYueWindPowerDqResultCoverFD0005Service;
        this.jiaYueWindPowerDqResultCoverFD0006Service = jiaYueWindPowerDqResultCoverFD0006Service;
        this.jiaYueWindPowerDqResultCoverFD0007Service = jiaYueWindPowerDqResultCoverFD0007Service;
        this.jiaYueWindPowerCdqResultCoverFD0001Service = jiaYueWindPowerCdqResultCoverFD0001Service;
        this.jiaYueWindPowerCdqResultCoverFD0002Service = jiaYueWindPowerCdqResultCoverFD0002Service;
        this.jiaYueWindPowerCdqResultCoverFD0003Service = jiaYueWindPowerCdqResultCoverFD0003Service;
        this.jiaYueWindPowerCdqResultCoverFD0005Service = jiaYueWindPowerCdqResultCoverFD0005Service;
        this.jiaYueWindPowerCdqResultCoverFD0004Service = jiaYueWindPowerCdqResultCoverFD0004Service;
        this.jiaYueWindPowerCdqResultCoverFD0006Service = jiaYueWindPowerCdqResultCoverFD0006Service;
        this.jiaYueWindPowerCdqResultCoverFD0007Service = jiaYueWindPowerCdqResultCoverFD0007Service;
    }
    /**
     * 生成实际功率json文件
     */
//    @Scheduled(cron = "0 48 1 * * ?")
//    public void genRealPowerDataJsonFile() {
//
//        long time = System.currentTimeMillis() - 86400000l;
//        // 获取startTime和endTime
//        Date startTime = DateTimeUtil.getDayStartTime(time);
//        Date endTime = DateTimeUtil.getDayLastTime(time);
//
//        List list = new ArrayList();
//        list.add("FD0001");
//        list.add("FD0002");
//        list.add("FD0003");
//        list.add("FD0005");
//        list.add("FD0006");
//        list.add("FD0007");
//
//        List<ElectricField> electricFieldList = new ArrayList<>();
//        ElectricField electricField1 = new ElectricField();
//        electricField1.setBelongForecastManufactor("SYJY");
//        electricField1.setCapacity(new BigDecimal(30.0000));
//        electricField1.setElectricFieldTypeEnum("2");
//        electricField1.setForecastManufactor("SYJY");
//        electricField1.setId("138c6aebdf6ddc792495bc35fa3e4adb");
//        electricField1.setName("天津中能融合测试站A");
//        electricField1.setStationCode("J00770");
//        electricField1.setSign("FD0001");
//        electricField1.setNetSubstationName("J00770");
//
//        ElectricField electricField2 = new ElectricField();
//        electricField2.setBelongForecastManufactor("SYJY");
//        electricField2.setCapacity(new BigDecimal(12.0000));
//        electricField2.setElectricFieldTypeEnum("2");
//        electricField2.setForecastManufactor("SYJY");
//        electricField2.setId("30a9f02678beb7101e628d7c7e22c5d6");
//        electricField2.setName("天津中能融合测试站C");
//        electricField2.setStationCode("J00942");
//        electricField2.setSign("FD0003");
//        electricField2.setNetSubstationName("J00942");
//
//        ElectricField electricField3 = new ElectricField();
//        electricField3.setBelongForecastManufactor("SYJY");
//        electricField3.setCapacity(new BigDecimal(20.0000));
//        electricField3.setElectricFieldTypeEnum("2");
//        electricField2.setForecastManufactor("SYJY");
//        electricField3.setId("d712c1ef348714a5afafcf130c256cc9");
//        electricField3.setName("中能融合测试站B");
//        electricField3.setStationCode("J00941");
//        electricField3.setSign("FD0002");
//        electricField3.setNetSubstationName("J00941");
//
//        ElectricField electricField5 = new ElectricField();
//        electricField3.setBelongForecastManufactor("SYJY");
//        electricField3.setCapacity(new BigDecimal(99.0000));
//        electricField3.setElectricFieldTypeEnum("2");
//        electricField2.setForecastManufactor("SYJY");
//        electricField3.setId("d712c1ef348714a5afafcf130c256cc5");
//        electricField3.setName("内蒙古中能融合测试站E");
//        electricField3.setStationCode("J00929");
//        electricField3.setSign("FD0005");
//        electricField3.setNetSubstationName("J00929");
//
//        ElectricField electricField6 = new ElectricField();
//        electricField3.setBelongForecastManufactor("SYJY");
//        electricField3.setCapacity(new BigDecimal(50.0000));
//        electricField3.setElectricFieldTypeEnum("2");
//        electricField2.setForecastManufactor("SYJY");
//        electricField3.setId("d712c1ef348714a5afafcf130c256cc6");
//        electricField3.setName("河南中能融合测试站F");
//        electricField3.setStationCode("J00930");
//        electricField3.setSign("FD0006");
//        electricField3.setNetSubstationName("J00930");
//
//        ElectricField electricField7 = new ElectricField();
//        electricField3.setBelongForecastManufactor("SYJY");
//        electricField3.setCapacity(new BigDecimal(50.0000));
//        electricField3.setElectricFieldTypeEnum("2");
//        electricField2.setForecastManufactor("SYJY");
//        electricField3.setId("d712c1ef348714a5afafcf130c256cc7");
//        electricField3.setName("天津中能融合测试站F");
//        electricField3.setStationCode("J00931");
//        electricField3.setSign("FD0007");
//        electricField3.setNetSubstationName("J00931");
//
//        electricFieldList.add(electricField1);
//        electricFieldList.add(electricField2);
//        electricFieldList.add(electricField3);
//        electricFieldList.add(electricField5);
//        electricFieldList.add(electricField6);
//        electricFieldList.add(electricField7);
//
//        List<WindPowerReal15MinFD0001> windPowerReal15MinFD0001List = windPowerReal15MinFD0001Service.getAll(startTime, endTime);
//        List<WindPowerReal15MinFD0002> windPowerReal15MinFD0002List = windPowerReal15MinFD0002Service.getAll(startTime, endTime);
//        List<WindPowerReal15MinFD0003> windPowerReal15MinFD0003List = windPowerReal15MinFD0003Service.getAll(startTime, endTime);
//        List<WindPowerReal15MinFD0005> windPowerReal15MinFD0005List = windPowerReal15MinFD0005Service.getAll(startTime, endTime);
//        List<WindPowerReal15MinFD0006> windPowerReal15MinFD0006List = windPowerReal15MinFD0006Service.getAll(startTime, endTime);
//        List<WindPowerReal15MinFD0007> windPowerReal15MinFD0007List = windPowerReal15MinFD0007Service.getAll(startTime, endTime);
//        // 根据电站编号查询对应实际功率
//        for (int i = 0; i < list.size(); i++) {
//
//            for (ElectricField electricField : electricFieldList) {
//                // 判断场站标识是否跟数据库中的场站id相同
//                String zxglPath = sysParameterService.getSysParameterAndStationCode("zxgl_config", "", electricField.getStationCode());
//
//                if (!zxglPath.equals("")) {
//                    FileOutputStream fileOutputStream = null;
//                    try {
//                        log.info("开始生成【{}】实际功率json文件", electricField.getStationCode());
//                        String content = electricField.getStationCode() + "|" + startTime.getTime() + "|rp|";
//                        //为了确保无数据缺失，遍历时间
//                        long sTimeL = startTime.getTime();
//                        long eTimeL = endTime.getTime();
//                        for (long m = sTimeL; m < eTimeL; m += 900000l) {
//                            long finalI = m;
//                            List<? extends Serializable> filterList = new ArrayList<>();
//                            if (electricField.getSign().equals(list.get(i)) && list.get(i).equals("FD0001")) {
//                                filterList = windPowerReal15MinFD0001List.stream().filter(p -> Timestamp.valueOf(p.getDateTime()).getTime() == finalI).collect(Collectors.toList());
//                            }
//                            if (electricField.getSign().equals(list.get(i)) && list.get(i).equals("FD0002")) {
//                                filterList = windPowerReal15MinFD0002List.stream().filter(p -> Timestamp.valueOf(p.getDateTime()).getTime() == finalI).collect(Collectors.toList());
//                            }
//                            if (electricField.getSign().equals(list.get(i)) && list.get(i).equals("FD0003")) {
//                                filterList = windPowerReal15MinFD0003List.stream().filter(p -> Timestamp.valueOf(p.getDateTime()).getTime() == finalI).collect(Collectors.toList());
//                            }
//                            if (electricField.getSign().equals(list.get(i)) && list.get(i).equals("FD0005")) {
//                                filterList = windPowerReal15MinFD0005List.stream().filter(p -> Timestamp.valueOf(p.getDateTime()).getTime() == finalI).collect(Collectors.toList());
//                            }
//                            if (electricField.getSign().equals(list.get(i)) && list.get(i).equals("FD0006")) {
//                                filterList = windPowerReal15MinFD0006List.stream().filter(p -> Timestamp.valueOf(p.getDateTime()).getTime() == finalI).collect(Collectors.toList());
//                            }
//                            if (electricField.getSign().equals(list.get(i)) && list.get(i).equals("FD0007")) {
//                                filterList = windPowerReal15MinFD0007List.stream().filter(p -> Timestamp.valueOf(p.getDateTime()).getTime() == finalI).collect(Collectors.toList());
//                            }
//                            if (filterList != null && filterList.size() > 0) {
//                                try {
//                                    Method getValueMethod = filterList.get(0).getClass().getMethod("getValue");
//                                    Object value = getValueMethod.invoke(filterList.get(0));
//                                    content = content + value.toString() + "|";
//                                } catch (NoSuchMethodException e) {
//                                    throw new RuntimeException(e);
//                                } catch (IllegalAccessException e) {
//                                    throw new RuntimeException(e);
//                                } catch (InvocationTargetException e) {
//                                    throw new RuntimeException(e);
//                                }
//
//                            } else {
//                                content = content + "-0.99|";
//                            }
//
//                        }
//                        for (int j = 0; j < 96; j++) {
//                            content = content + "-0.99|";
//                        }
//                        String zipContent = GzipUtil.zip(content).replace("\r\n", "");
//
//                        String taskNo = getTaskNo(electricField);
//
//                        JSONObject jsonObject = new JSONObject();
//                        jsonObject.putOnce("taskNo", taskNo);
//                        jsonObject.putOnce("taskType", "stationData-rp");
//                        jsonObject.putOnce("partNo", 1);
//                        jsonObject.putOnce("partTotal", 1);
//                        jsonObject.putOnce("data", zipContent);
//
//                        String qrCodeContent = jsonObject.toString();
//
//                        String fileName = electricField.getStationCode() + "-" + DateFormatUtils.format(new Date(), "yyyyMMddHHmm") + "-realpower.json";
//
//                        File file = new File(zxglPath + File.separator + fileName);
//
//                        fileOutputStream = new FileOutputStream(file);
//                        fileOutputStream.write(qrCodeContent.getBytes(Charset.forName("utf-8")));
//                        fileOutputStream.flush();
//                        fileOutputStream.close();
//
//                        log.info("实际功率json文件【{}】生成成功", fileName);
//                    } catch (IOException e) {
//                        e.printStackTrace();
//                    }
//
//                }
//
////                if (electricField.getSign().equals(list.get(i)) && list.get(i).equals("FD0003")) {
////                    String zxglPath = sysParameterService.getSysParameterAndStationCode("zxgl_config", "", electricField.getStationCode());
////
////                    if (!zxglPath.equals("")) {
////                        FileOutputStream fileOutputStream = null;
////                        try {
////                            log.info("开始生成【{}】实际功率json文件", electricField.getStationCode());
////                            String content = electricField.getStationCode() + "|" + startTime.getTime() + "|rp|";
////                            //为了确保无数据缺失，遍历时间
////                            long sTimeL = startTime.getTime();
////                            long eTimeL = endTime.getTime();
////                            for (long m = sTimeL; m < eTimeL; m += 900000l) {
////                                long finalI = m;
////                                List<WindPowerReal15MinFD0003> filterList = windPowerReal15MinFD0003List.stream().filter(p -> Timestamp.valueOf(p.getDateTime()).getTime() == finalI).collect(Collectors.toList());
////
////                                if (filterList != null && filterList.size() > 0) {
////                                    content = content + filterList.get(0).getValue().toString() + "|";
////                                } else {
////                                    content = content + "-0.99|";
////                                }
////
////                            }
////                            for (int j = 0; j < 96; j++) {
////                                content = content + "-0.99|";
////                            }
////                            String zipContent = GzipUtil.zip(content).replace("\r\n", "");
////
////                            String taskNo = getTaskNo(electricField);
////
////                            JSONObject jsonObject = new JSONObject();
////                            jsonObject.putOnce("taskNo", taskNo);
////                            jsonObject.putOnce("taskType", "stationData-rp");
////                            jsonObject.putOnce("partNo", 1);
////                            jsonObject.putOnce("partTotal", 1);
////                            jsonObject.putOnce("data", zipContent);
////
////                            String qrCodeContent = jsonObject.toString();
////
////                            String fileName = electricField.getStationCode() + "-" + DateFormatUtils.format(new Date(), "yyyyMMddHHmm") + "-realpower.json";
////
////                            File file = new File(zxglPath + File.separator + fileName);
////
////                            fileOutputStream = new FileOutputStream(file);
////                            fileOutputStream.write(qrCodeContent.getBytes(Charset.forName("utf-8")));
////                            fileOutputStream.flush();
////                            fileOutputStream.close();
////
////                            log.info("实际功率json文件【{}】生成成功", fileName);
////                        } catch (IOException e) {
////                            e.printStackTrace();
////                        }
////
////                    }
////                }
//            }
//        }
//
//
//    }
    @Scheduled(fixedRate = 60000L)
    public void realPowerForQr() {

        String zxglPath = "/home/syjy/huichuan";

        File zxglPathFile = new File(zxglPath + File.separator + "new");

        log.info("开始扫描正向隔离回传目录{}", zxglPathFile.getPath());
        String bakPath = zxglPath + File.separator + "bak";
        if (zxglPathFile.exists()) {

            for (String s : zxglPathFile.list()) {

                List<String> list;
                File file = null;
                try {
                    file = new File(zxglPathFile.getPath() + File.separator + s);
                    list = EfileUtil.getFileContent(file);
                    TaskResultRequestVO taskResultRequestVO = new TaskResultRequestVO();
                    log.info("开始回传二维码数据，文件名：{}", file.getName());
                    taskResultRequestVO.setTaskResult(String.join("", list));
                    String url = "https://api.jiayuepowertech.com:8080/task/result";
                    // 构造请求对象
                    HttpRequest request = HttpRequest.put(url).body(JsonBeanUtil.beanToJson(taskResultRequestVO));
                    // 发送请求并获取响应对象
                    HttpResponse response = request.execute();
                    log.info("回传二维码数据状态=》{}", response.body());
                    FileUtils.moveFile(file, new File(bakPath + File.separator + file.getName()));
                } catch (Exception e) {
                    log.info("回传二维码数据失败，文件名：{}", file.getName());
                    e.printStackTrace();
                }
            }
        }
    }

    @Data
    class TaskResultRequestVO {
        private static final long serialVersionUID = 1L;
        private String taskResult;
    }


    /**
     * @return
     */

    /**
     *  查询回传短期、超短期、实际功率所需数据
     * @param electricField
     * @return
     */
    public Map<String, Object> generateQR(ElectricField electricField) {

        Long time = new Date().getTime() - 3600 * 24 * 1000L;
        // 获取昨日开始时间结束时间
        Date startTime = new Date(TimeUtils.getDayStartTime(time));
        Date endTime = new Date(startTime.getTime() + 3600 * 24 * 1000L * 10 - 1000L);

        Map<String, Object> map = new HashMap<>();

        try {
            //各个二维码显示设置
            Map<String, List<String>> dqMap = new TreeMap<>();
            Map<String, List<String>> cdqMap = new HashMap<>();
            Map<String, List<String>> rpMap = new HashMap<>();

            //超短期 stationData-QR    T00003-ust-点位
            List<String> ust = generateUltraShortTermContent(startTime.getTime(), startTime.getTime() + 3600 * 24 * 1000L - 1000, electricField);
            cdqMap.put("超短期第1点数据", ust);


            //短期
            List<String> st = generateShortTermContent(startTime.getTime(), endTime.getTime(), electricField);
            //二维码名字
            StringBuilder name = new StringBuilder("E1短期");
            dqMap.put(name.toString(), st);


            //实际功率stationData-QR    T00003-rp
            List<String> rp = generateRealPowerCodeContent(startTime.getTime(), endTime.getTime(), electricField);
            rpMap.put("实际功率", rp);


            map.put("ultraShortTerm", cdqMap);
            map.put("shortTerm", dqMap);
            map.put("realPower", rpMap);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }

    /**
     * 实际功率二维码内容生成
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return 二维码生成内容集
     * @throws IOException       io异常
     * @throws BusinessException 业务异常
     */
    public List<String> generateRealPowerCodeContent(Long startTime, Long endTime, ElectricField electricField) throws IOException, BusinessException {

        long timeStep = 900000L;
        if (startTime % timeStep != 0) {
            startTime = startTime - (startTime % timeStep) + timeStep;
        }
        StringBuilder content = new StringBuilder();
        StringBuilder instContent = new StringBuilder();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        StringBuilder stringBuilder = new StringBuilder();

        //T00003-rp|2023-04-14
        stringBuilder.append(electricField.getStationCode()).append("-").append("rp").append("|").append(sdf.format(startTime)).append("|");

        List<WindPowerReal15MinFD0001> windPowerReal15MinFD0001List = windPowerReal15MinFD0001Service.getAll(new Date(startTime), new Date(startTime + 24 * 60 * 60 * 1000L - 1000));
        List<WindPowerReal15MinFD0002> windPowerReal15MinFD0002List = windPowerReal15MinFD0002Service.getAll(new Date(startTime), new Date(startTime + 24 * 60 * 60 * 1000L - 1000));
        List<WindPowerReal15MinFD0003> windPowerReal15MinFD0003List = windPowerReal15MinFD0003Service.getAll(new Date(startTime), new Date(startTime + 24 * 60 * 60 * 1000L - 1000));
        List<WindPowerReal15MinFD0004> windPowerReal15MinFD0004List = windPowerReal15MinFD0004Service.getAll(new Date(startTime), new Date(startTime + 24 * 60 * 60 * 1000L - 1000));
        List<WindPowerReal15MinFD0005> windPowerReal15MinFD0005List = windPowerReal15MinFD0005Service.getAll(new Date(startTime), new Date(startTime + 24 * 60 * 60 * 1000L - 1000));
        List<WindPowerReal15MinFD0006> windPowerReal15MinFD0006List = windPowerReal15MinFD0006Service.getAll(new Date(startTime), new Date(startTime + 24 * 60 * 60 * 1000L - 1000));
        List<WindPowerReal15MinFD0007> windPowerReal15MinFD0007List = windPowerReal15MinFD0007Service.getAll(new Date(startTime), new Date(startTime + 24 * 60 * 60 * 1000L - 1000));


        for (long stepTime = startTime; stepTime <= endTime; stepTime = stepTime + timeStep) {
            long finalTime = stepTime;
            if (electricField.getSign().equals("FD0001")) {
                List<WindPowerReal15MinFD0001> filterList = windPowerReal15MinFD0001List.stream().filter(p -> p.getDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() * 1000L == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getValue()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0002")) {
                List<WindPowerReal15MinFD0002> filterList = windPowerReal15MinFD0002List.stream().filter(p -> p.getDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getValue()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0003")) {
                List<WindPowerReal15MinFD0003> filterList = windPowerReal15MinFD0003List.stream().filter(p -> p.getDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getValue()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0004")) {
                List<WindPowerReal15MinFD0004> filterList = windPowerReal15MinFD0004List.stream().filter(p -> p.getDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getValue()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0005")) {
                List<WindPowerReal15MinFD0005> filterList = windPowerReal15MinFD0005List.stream().filter(p -> p.getDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getValue()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0006")) {
                List<WindPowerReal15MinFD0006> filterList = windPowerReal15MinFD0006List.stream().filter(p -> p.getDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getValue()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0007")) {
                List<WindPowerReal15MinFD0007> filterList = windPowerReal15MinFD0007List.stream().filter(p -> p.getDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getValue()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
        }

        stringBuilder.append(content);
        stringBuilder.append(instContent);
        List<String> qrCodeContents = GzipUtil.pubZipList(stringBuilder.toString(), packSize);
        List<String> result = new ArrayList<>();
        String taskNo = getTaskNo(electricField);
        for (int i = 0; i < qrCodeContents.size(); i++) {
            JSONObject jsonObject = new JSONObject();
            jsonObject.putOnce("taskNo", taskNo);
            jsonObject.putOnce("taskType", "stationData-QR");
            jsonObject.putOnce("partNo", i + 1);
            jsonObject.putOnce("partTotal", qrCodeContents.size());
            jsonObject.putOnce("data", qrCodeContents.get(i));
            result.add(i, jsonObject.toString());
        }
        return result;
    }

    /**
     * 上报短期二维码内容生成
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return 二维码生成内容集
     * @throws IOException       IO异常
     * @throws BusinessException 业务异常
     */
    public List<String> generateShortTermContent(Long startTime, Long endTime, ElectricField electricField) throws IOException, BusinessException {
        long timeStep = 900000L;
        if (startTime % timeStep != 0) {
            startTime = startTime - (startTime % timeStep) + timeStep;
        }
        StringBuilder content = new StringBuilder();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        StringBuilder name = new StringBuilder("E1");

        content.append(electricField.getStationCode()).append("-").append("st").append("-").append(name).append("|");
        List<Long> lDate = DateMomentUtil.getEveryDay(startTime, startTime + 24 * 60 * 60 * 1000 - 1000L);
        for (int i = 0; i < lDate.size(); i++) {
            content.append(sdf.format(lDate.get(i)));
            if (i != lDate.size() - 1) {
                content.append(",");
            } else {
                content.append("|");
            }
        }

        List<JiaYueWindPowerDqResultCoverFD0001> jiaYueWindPowerDqResultCoverFD0001List = jiaYueWindPowerDqResultCoverFD0001Service.findByDataDate(new Date(startTime));
        List<JiaYueWindPowerDqResultCoverFD0002> jiaYueWindPowerDqResultCoverFD0002List = jiaYueWindPowerDqResultCoverFD0002Service.findByDataDate(new Date(startTime));
        List<JiaYueWindPowerDqResultCoverFD0003> jiaYueWindPowerDqResultCoverFD0003List = jiaYueWindPowerDqResultCoverFD0003Service.findByDataDate(new Date(startTime));
        List<JiaYueWindPowerDqResultCoverFD0004> jiaYueWindPowerDqResultCoverFD0004List = jiaYueWindPowerDqResultCoverFD0004Service.findByDataDate(new Date(startTime));
        List<JiaYueWindPowerDqResultCoverFD0005> jiaYueWindPowerDqResultCoverFD0005List = jiaYueWindPowerDqResultCoverFD0005Service.findByDataDate(new Date(startTime));
        List<JiaYueWindPowerDqResultCoverFD0006> jiaYueWindPowerDqResultCoverFD0006List = jiaYueWindPowerDqResultCoverFD0006Service.findByDataDate(new Date(startTime));
        List<JiaYueWindPowerDqResultCoverFD0007> jiaYueWindPowerDqResultCoverFD0007List = jiaYueWindPowerDqResultCoverFD0007Service.findByDataDate(new Date(startTime));


        for (long stepTime = startTime; stepTime <= endTime; stepTime = stepTime + timeStep) {
            long finalTime = stepTime;
            if (electricField.getSign().equals("FD0001")) {
                List<JiaYueWindPowerDqResultCoverFD0001> filterList = jiaYueWindPowerDqResultCoverFD0001List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() * 1000L == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0002")) {
                List<JiaYueWindPowerDqResultCoverFD0002> filterList = jiaYueWindPowerDqResultCoverFD0002List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0003")) {
                List<JiaYueWindPowerDqResultCoverFD0003> filterList = jiaYueWindPowerDqResultCoverFD0003List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0004")) {
                List<JiaYueWindPowerDqResultCoverFD0004> filterList = jiaYueWindPowerDqResultCoverFD0004List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() * 1000L == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0005")) {
                List<JiaYueWindPowerDqResultCoverFD0005> filterList = jiaYueWindPowerDqResultCoverFD0005List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() * 1000L == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0006")) {
                List<JiaYueWindPowerDqResultCoverFD0006> filterList = jiaYueWindPowerDqResultCoverFD0006List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() * 1000L == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0007")) {
                List<JiaYueWindPowerDqResultCoverFD0007> filterList = jiaYueWindPowerDqResultCoverFD0007List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() * 1000L == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
        }


        List<String> qrCodeContents1 = GzipUtil.pubZipList(content.toString(), packSize);
        List<String> result = new ArrayList<>();
        String taskNo = getTaskNo(electricField);
        for (int i = 0; i < qrCodeContents1.size(); i++) {
            JSONObject jsonObject = new JSONObject();
            jsonObject.putOnce("taskNo", taskNo);
            jsonObject.putOnce("taskType", "stationData-QR");
            jsonObject.putOnce("partNo", i + 1);
            jsonObject.putOnce("partTotal", qrCodeContents1.size());
            jsonObject.putOnce("data", qrCodeContents1.get(i));
            result.add(i, jsonObject.toString());
        }
        return result;

    }


    /**
     * 上报超短期二维码内容生成
     *
     * @param startTime 开始时间
     * @param endTime   结束时间
     * @return 二维码生成内容集
     * @throws IOException       IO异常
     * @throws BusinessException 业务异常
     */
    public List<String> generateUltraShortTermContent(Long startTime, Long endTime, ElectricField electricField) throws IOException, BusinessException {

        long timeStep = 900000L;
        if (startTime % timeStep != 0) {
            startTime = startTime - (startTime % timeStep) + timeStep;
        }
        StringBuilder content = new StringBuilder();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        content.append(electricField.getStationCode()).append("-").append("ust").append("-").append(1).append("|");
        List<Long> lDate = DateMomentUtil.getEveryDay(startTime, endTime);
        for (int i = 0; i < lDate.size(); i++) {
            content.append(sdf.format(lDate.get(i)));
            if (i != lDate.size() - 1) {
                content.append(",");
            } else {
                content.append("|");
            }
        }
        List<JiaYueWindPowerCdqResultCoverFD0001> jiaYueWindPowerCdqResultCoverFD0001List = jiaYueWindPowerCdqResultCoverFD0001Service.findByDataDate(new Date(startTime));
        List<JiaYueWindPowerCdqResultCoverFD0002> jiaYueWindPowerCdqResultCoverFD0002List = jiaYueWindPowerCdqResultCoverFD0002Service.findByDataDate(new Date(startTime));
        List<JiaYueWindPowerCdqResultCoverFD0003> jiaYueWindPowerCdqResultCoverFD0003List = jiaYueWindPowerCdqResultCoverFD0003Service.findByDataDate(new Date(startTime));
        List<JiaYueWindPowerCdqResultCoverFD0004> jiaYueWindPowerCdqResultCoverFD0004List = jiaYueWindPowerCdqResultCoverFD0004Service.findByDataDate(new Date(startTime));
        List<JiaYueWindPowerCdqResultCoverFD0005> jiaYueWindPowerCdqResultCoverFD0005List = jiaYueWindPowerCdqResultCoverFD0005Service.findByDataDate(new Date(startTime));
        List<JiaYueWindPowerCdqResultCoverFD0006> jiaYueWindPowerCdqResultCoverFD0006List = jiaYueWindPowerCdqResultCoverFD0006Service.findByDataDate(new Date(startTime));
        List<JiaYueWindPowerCdqResultCoverFD0007> jiaYueWindPowerCdqResultCoverFD0007List = jiaYueWindPowerCdqResultCoverFD0007Service.findByDataDate(new Date(startTime));

        for (long stepTime = startTime; stepTime <= endTime; stepTime = stepTime + timeStep) {
            long finalTime = stepTime;
            if (electricField.getSign().equals("FD0001")) {
                List<JiaYueWindPowerCdqResultCoverFD0001> filterList = jiaYueWindPowerCdqResultCoverFD0001List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() * 1000L == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0002")) {
                List<JiaYueWindPowerCdqResultCoverFD0002> filterList = jiaYueWindPowerCdqResultCoverFD0002List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0003")) {
                List<JiaYueWindPowerCdqResultCoverFD0003> filterList = jiaYueWindPowerCdqResultCoverFD0003List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0004")) {
                List<JiaYueWindPowerCdqResultCoverFD0004> filterList = jiaYueWindPowerCdqResultCoverFD0004List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() * 1000L == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0005")) {
                List<JiaYueWindPowerCdqResultCoverFD0005> filterList = jiaYueWindPowerCdqResultCoverFD0005List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() * 1000L == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0006")) {
                List<JiaYueWindPowerCdqResultCoverFD0006> filterList = jiaYueWindPowerCdqResultCoverFD0006List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() * 1000L == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
            if (electricField.getSign().equals("FD0007")) {
                List<JiaYueWindPowerCdqResultCoverFD0007> filterList = jiaYueWindPowerCdqResultCoverFD0007List.stream().filter(p -> p.getPreDateTime().atZone(ZoneId.systemDefault()).toEpochSecond() * 1000L == finalTime).collect(Collectors.toList());
                if (!filterList.isEmpty()) {
                    content.append(filterList.get(0).getActivePower()).append("|");
                } else {
                    content.append(PLACE);
                }
            }
        }

        List<String> qrCodeContents1 = GzipUtil.pubZipList(content.toString(), packSize);
        List<String> result = new ArrayList<>();
        String taskNo = getTaskNo(electricField);
        for (int i = 0; i < qrCodeContents1.size(); i++) {
            JSONObject jsonObject = new JSONObject();
            jsonObject.putOnce("taskNo", taskNo);
            jsonObject.putOnce("taskType", "stationData-QR");
            jsonObject.putOnce("partNo", i + 1);
            jsonObject.putOnce("partTotal", qrCodeContents1.size());
            jsonObject.putOnce("data", qrCodeContents1.get(i));
            result.add(i, jsonObject.toString());
        }
        return result;
    }


    /**
     * 获取taskNo编号
     *
     * @param electricField 场站对象
     * @return 编号
     */
    private String getTaskNo(ElectricField electricField) {
        Date date = DateUtil.date();
        return electricField.getStationCode() + DateUtil.format(date, "yyMMddHHmmss");
    }

    /**
     *  每天凌晨一点零五分生成回传短期、超短期。实际功率数据
     * @return
     */
    @Scheduled(cron = "0 5 1 * * *")
    public Map<String, Object> generateQRCode() {
        Map<String, Object> map = new HashMap<>();
        try {
            // 定时调用
            Calendar startyesterday = Calendar.getInstance();
            startyesterday.add(Calendar.DAY_OF_MONTH, -1);
            startyesterday.set(Calendar.HOUR_OF_DAY, 0);
            startyesterday.set(Calendar.MINUTE, 0);
            startyesterday.set(Calendar.SECOND, 0);
            startyesterday.set(Calendar.MILLISECOND, 0);

            Calendar endyesterday = Calendar.getInstance();
            endyesterday.add(Calendar.DAY_OF_MONTH, -1);
            endyesterday.set(Calendar.HOUR_OF_DAY, 23);
            endyesterday.set(Calendar.MINUTE, 59);
            endyesterday.set(Calendar.SECOND, 59);
            endyesterday.set(Calendar.MILLISECOND, 999);

            List<ElectricField> electricFieldList = new ArrayList<>();
            ElectricField electricField = new ElectricField();
            electricField.setStationCode("J00770");
            electricField.setSign("FD0001");

            ElectricField electricField2 = new ElectricField();
            electricField2.setStationCode("J00941");
            electricField2.setSign("FD0002");

            ElectricField electricField3 = new ElectricField();
            electricField3.setStationCode("J00942");
            electricField3.setSign("FD0003");


            // 新增宁夏吴忠石窖沟电站
            ElectricField electricField4 = new ElectricField();
            electricField4.setStationCode("J00988");
            electricField4.setSign("FD0004");

            ElectricField electricField5 = new ElectricField();
            electricField5.setStationCode("J00929");
            electricField5.setSign("FD0005");

            ElectricField electricField6 = new ElectricField();
            electricField6.setStationCode("J00930");
            electricField6.setSign("FD0006");


            ElectricField electricField7 = new ElectricField();
            electricField7.setStationCode("J00931");
            electricField7.setSign("FD0007");

            electricFieldList.add(electricField);
            electricFieldList.add(electricField2);
            electricFieldList.add(electricField3);
            electricFieldList.add(electricField4);
            electricFieldList.add(electricField5);
            electricFieldList.add(electricField6);
            electricFieldList.add(electricField7);

            for (int i = 0; i < electricFieldList.size(); i++) {
                map = generateQR(electricFieldList.get(i));
                toJson(map);
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("生成二维码失败");
            // 处理生成二维码失败的情况
        }
        return map;
    }

    /**
     *  生成回传短期、超短期、实际功率json文件
     * @param map
     */
    public void toJson(Map<String, Object> map) {

        map.entrySet().stream().forEach(entry -> {
            Map<String, Object> value = (Map<String, Object>) entry.getValue();
            value.entrySet().stream().forEach(entry1 -> {

                ObjectMapper objectMapper = new ObjectMapper();
                JSONArray jsonArray = new JSONArray(entry1.getValue().toString());// 将entry1.getValue()转换为JSON数组
                JSONObject jsonObject = jsonArray.getJSONObject(0);// 获取数组中的第一个JSONObject对象
                String json = null;
                String prettyPrintJson = null;
                try {
                    json = objectMapper.writeValueAsString(jsonObject);
                    Object formattedJson = objectMapper.readValue(json, Object.class);
                    prettyPrintJson = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(formattedJson);
                } catch (JsonProcessingException e) {
                    e.printStackTrace();
                }
                String fileName = null;
//                    if (entry1.getKey().contains("超短期")) {
//                        if (entry1.getKey().contains("点数")) {
//                            fileName = entry.getKey() + "_Point" + entry1.getKey().substring(4, 6) + "_" + System.currentTimeMillis() + ".json";
//                        } else {
//                            fileName = entry.getKey() + "_Avg_" + System.currentTimeMillis() + ".json";
//                        }
//                    } else if (entry1.getKey().contains("中期")) {
//                        if (entry1.getKey().contains("平均值")) {
//                            fileName = entry.getKey() + "_Avg_" + System.currentTimeMillis() + ".json";
//                        } else {
//                            fileName = entry.getKey() + "_" + System.currentTimeMillis() + ".json";
//                        }
//                    } else {
                fileName = entry.getKey() + "_" + System.currentTimeMillis() + ".json";
//                    }

                String filePath = "/home/syjy/huichuan/new/" + fileName;
                //写入文件
                try (FileWriter fileWriter = new FileWriter(filePath)) {
                    fileWriter.write(prettyPrintJson);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
        });
//        }
    }

    /**
     * 这几个表清除所有数据,在进行数据同步(基础信息表)
     */
//    @Scheduled(cron = "0 30 0 * * ?")
//    @Scheduled(cron = "0 48 2 * * ?")
    public void synchronizeInfoData() {
        log.info("---------------------------开始同步基础信息---------------------------");
//        // 数据类型信息表
//        List<DataTypeInfo> dataTypeInfoList = dataTypeInfoService.get();
//        // 查询本地所有数据
//        List<DataTypeInfo> dataTypeInfos = dataTypeInfoService.getAll();
//        if (dataTypeInfos != null && dataTypeInfos.size() > 0) {
//            // 先删除数据
//            dataTypeInfoService.deleteAll();
//        }
//        // 将远端数据插入到本地
//        dataTypeInfoService.put(dataTypeInfoList);


//        // 风电场基本信息表（厂商专供）
//        List<WindFarmInfoEncryption> windFarmInfoEncryptionList = windFarmInfoEncryptionService.get();
//        // 查询本地所有数据
//        List<WindFarmInfoEncryption> windFarmInfoEncryptions = windFarmInfoEncryptionService.getAll();
//        if (windFarmInfoEncryptions != null && windFarmInfoEncryptions.size() > 0) {
//            // 先删除数据
//            windFarmInfoEncryptionService.deleteAll();
//        }
//        windFarmInfoEncryptionService.put(windFarmInfoEncryptionList);


//        // 测风塔信息
//        List<WindTowerInfo> windTowerInfoList = windTowerInfoService.get();
//        // 查询本地所有数据
//        List<WindTowerInfo> windTowerInfos = windTowerInfoService.getAll();
//        if (windTowerInfos != null && windTowerInfos.size() > 0) {
//            // 先删除数据
//            windTowerInfoService.deleteAll();
//        }
//        windTowerInfoService.put(windTowerInfoList);


//        // 风电机组基本信息表
//        List<WindUnitInfo> windUnitInfoList = windUnitInfoService.get();
//        // 查询本地所有数据
//        List<WindUnitInfo> windUnitInfos = windUnitInfoService.getAll();
//        if (windUnitInfos != null && windUnitInfos.size() > 0) {
//            // 先删除数据
//            windUnitInfoService.deleteAll();
//        }
//        windUnitInfoService.put(windUnitInfoList);


//        // 风电机组型号基本信息表
//        List<WindUnitModelInfo> windUnitModelInfoList = windUnitModelInfoService.get();
//        // 查询本地所有数据
//        List<WindUnitModelInfo> windUnitModelInfos = windUnitModelInfoService.getAll();
//        if (windUnitModelInfos != null && windUnitModelInfos.size() > 0) {
//            // 先删除数据
//            windUnitModelInfoService.deleteAll();
//        }
//        windUnitModelInfoService.put(windUnitModelInfoList);


//        List<WindUnitModelWsAndPower> windUnitModelWsAndPowerList = windUnitModelWsAndPowerService.get();
//        // 查询本地所有数据
//        List<WindUnitModelWsAndPower> windUnitModelWsAndPowers = windUnitModelWsAndPowerService.getAll();
//        if (windUnitModelWsAndPowers != null && windUnitModelWsAndPowers.size() > 0) {
//            // 先删除数据
//            windUnitModelWsAndPowerService.deleteAll();
//        }
//        windUnitModelWsAndPowerService.put(windUnitModelWsAndPowerList);

        log.info("---------------------------同步基础信息结束---------------------------");

    }

    /**
     * 这几个表每天同步昨天的数据
     */
//    @Scheduled(cron = "0 48 2 * * ?")
    public void synchronizeRealData() {
        log.info("---------------------------开始同步昨日数据---------------------------");

        long time = System.currentTimeMillis() - 86400000l;

        // 获取startTime和endTime
        Date startTime = DateTimeUtil.getDayStartTime(time);
        Date endTime = DateTimeUtil.getDayLastTime(time);

//        List<WindTowerCdqResultCover> windTowerCdqResultCoverList = windTowerCdqResultCoverService.get(startTime, endTime);
//        windTowerCdqResultCoverService.put(windTowerCdqResultCoverList);
//
//        List<WindPowerCdqResultCover> windPowerCdqResultCoverList = windPowerCdqResultCoverService.get(startTime, endTime);
//        windPowerCdqResultCoverService.put(windPowerCdqResultCoverList);
//
//        List<WindPowerDqResultCover> windPowerDqResultCoverList = windPowerDqResultCoverService.get(startTime, endTime);
//        windPowerDqResultCoverService.put(windPowerDqResultCoverList);

        List<WindPowerReal15MinFD0001> windPowerReal15MinFD0001List = windPowerReal15MinFD0001Service.get(startTime, endTime);
        windPowerReal15MinFD0001Service.put(windPowerReal15MinFD0001List);

        List<WindPowerReal15MinFD0002> windPowerReal15MinFD0002List = windPowerReal15MinFD0002Service.get(startTime, endTime);
        windPowerReal15MinFD0002Service.put(windPowerReal15MinFD0002List);

        List<WindPowerReal15MinFD0003> windPowerReal15MinFD0003List = windPowerReal15MinFD0003Service.get(startTime, endTime);
        windPowerReal15MinFD0003Service.put(windPowerReal15MinFD0003List);

        List<WindPowerReal15MinFD0005> windPowerReal15MinFD0005List = windPowerReal15MinFD0005Service.get(startTime, endTime);
        windPowerReal15MinFD0005Service.put(windPowerReal15MinFD0005List);

        List<WindPowerReal15MinFD0006> windPowerReal15MinFD0006List = windPowerReal15MinFD0006Service.get(startTime, endTime);
        windPowerReal15MinFD0006Service.put(windPowerReal15MinFD0006List);

        List<WindPowerReal15MinFD0007> windPowerReal15MinFD0007List = windPowerReal15MinFD0007Service.get(startTime, endTime);
        windPowerReal15MinFD0007Service.put(windPowerReal15MinFD0007List);

//        List<WindTower15Min> windTower15MinList = windTower15MinService.get(startTime, endTime);
//        windTower15MinService.put(windTower15MinList);
//
//
//        List<WindTowerDqResultCover> windTowerDqResultCoverList = windTowerDqResultCoverService.get(startTime, endTime);
//        windTowerDqResultCoverService.put(windTowerDqResultCoverList);

        log.info("---------------------------同步昨日数据结束---------------------------");

    }
}