neim/neim-biz/src/main/java/com/jiayue/biz/service/impl/DataRecalculationImpl.java

package com.jiayue.biz.service.impl;


import cn.hutool.core.util.ZipUtil;
import cn.hutool.poi.excel.ExcelReader;
import cn.hutool.poi.excel.ExcelUtil;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.jiayue.biz.domain.*;
import com.jiayue.biz.mapper.ProphaseAnemometryDataMapper;
import com.jiayue.biz.mapper.ProphaseWeatherDataMapper;
import com.jiayue.biz.service.DataRecalculationService;
import com.jiayue.biz.service.EquipmentAttributeService;
import com.jiayue.biz.service.WindTowerDataChildTableService;
import com.jiayue.biz.util.DateTimeUtil;
import com.jiayue.biz.util.FileUtil;
import com.jiayue.common.core.domain.AjaxResult;
import com.jiayue.common.utils.file.FileUtils;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.xssf.streaming.SXSSFRow;
import org.apache.poi.xssf.streaming.SXSSFSheet;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.joda.time.DateTime;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 上传文件or数据过滤
 *
 * @author whc
 * @Date 2022/06/23
 */
@Slf4j
@Service
@AllArgsConstructor
public class DataRecalculationImpl implements DataRecalculationService {

    private final WindTowerDataParentTableServiceImpl windTowerDataParentTableService;

    private final WindTowerDataChildTableService windTowerDataChildTableService;

    private final WindTowerInfoServiceImpl windTowerInfoService;
    private final WindTowerCalculationDataServiceImpl windTowerCalculationDataService;

    private final WindDirectionStatisticsDataServiceImpl windDirectionStatisticsDataService;

    private final EquipmentAttributeService equipmentAttributeService;

    private final StatisticsSituationServiceImpl statisticsSituationService;

    private AnalysisDataImpl analysisData;

    private final ProphaseWeatherDataMapper prophaseWeatherDataMapper;
    private final ProphaseAnemometryDataMapper prophaseAnemometryDataMapper;



    public void teset() {
//    File file1 = MultipartFileToFile(file);
//    //如果是压缩包
//    if(AnalysisDataImpl.isArchiveFile(file1)){
////                String zipPath = file1.getPath();
//        //解压文件
//        ZipUtil.unzip(file1.getPath() + "\\");
//        //删除压缩包
////                FileUtils.deleteFile(zipPath);
//    }
    }

    /**
     * 文件上传解析
     *
     * @param file        上传的文件
     * @param equipmentNo 设备编号
     * @param recorderNo  记录仪编号
     * @return
     */
    @Override
    public AjaxResult uploadFileAnalysis(MultipartFile file, String equipmentNo, String recorderNo) {
        try {
            //D:\\program\\uploadFile\\new
            String path = FileUtil.getFileUploadPath() + File.separator + "new";
            File filePath = new File(path);
            //判断目录是否存在
            if (!filePath.exists()) {
                filePath.mkdirs();
            }
            String originalFilename = file.getOriginalFilename();
            //如果是压缩文件
            if (originalFilename.contains(".zip")) {
                File file1 = MultipartFileToFile(file);
                //如果是压缩包
                if (AnalysisDataImpl.isArchiveFile(file1)) {
                    //解压文件
                    File unzip = ZipUtil.unzip(file1.getPath() + "\\");
                    File[] files = unzip.listFiles();
                    if (files != null) {
                        for (File file2 : files) {
                            if (file2.getName().contains("rld")) {
                                String[] id = file2.getName().split("_");
                                if (id[0].equals(equipmentNo)) {
                                    //文件保存到指定目录下
                                    FileUtil.move(file2.getPath(), path + File.separator);
                                    //如果文件名的后缀为.rld 则转换
                                    //调用系统命令转换
                                    this.systemCommand(equipmentNo, recorderNo);
                                }
                            } else if (file2.getName().contains(".RWD")) {
                                path = "D:\\in\\";
                                FileUtil.move(file2.getPath(), path);
                                this.systemCommandRWD();
                            } else {
                                return AjaxResult.error("请检查数据文件是否正确");
                            }
                        }
                        //删除压缩包
                        FileUtils.deleteFile(file1.getPath());
                    }
                    return AjaxResult.success("上传完成");
                }
            }
            //如果不是压缩文件
            String[] names = file.getOriginalFilename().split("\\.");
            //如果不是rld文件则不解析
            if (names[names.length - 1].equals("rld")) {
                String[] id = file.getOriginalFilename().split("_");
                if (id[0].equals(equipmentNo)) {
                    //文件保存到指定目录下
                    file.transferTo(new File(path + File.separator + originalFilename));
                    //如果文件名的后缀为.rld 则转换
                    //调用系统命令转换
                    this.systemCommand(equipmentNo, recorderNo);
                    return AjaxResult.success("成功");
                } else {
                    return AjaxResult.error("不是该测风塔的文件");
                }
            } else if (originalFilename.contains(".RWD")) {
                path = "D:\\in\\";
                file.transferTo(new File(path + File.separator + file.getOriginalFilename()));
                this.systemCommandRWD();
                return AjaxResult.success("成功");
            } else {
                return AjaxResult.error("请检查数据文件是否正确");
            }
        } catch (Exception ex) {
            log.error("上传失败" + ex);
            return AjaxResult.error(ex.getMessage());
        }

    }

    /**
     * 将MultipartFile转换为File
     *
     * @param multiFile
     * @return
     */
    public static File MultipartFileToFile(MultipartFile multiFile) {
        // 获取文件名
        String fileName = multiFile.getOriginalFilename();
        // 获取文件后缀
        String prefix = fileName.substring(fileName.lastIndexOf("."));
        // 若须要防止生成的临时文件重复,能够在文件名后添加随机码

        try {
            File file = File.createTempFile(fileName, prefix);
            multiFile.transferTo(file);
            return file;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * rwd文件转换txt
     */
    public void systemCommandRWD() {
        try {
            Runtime runtime = Runtime.getRuntime();
            List<WindTowerInfo> windTowerInfoList = windTowerInfoService.list();
            File file = new File("D:\\in\\");
            //遍历所有文件
            File[] files = file.listFiles();
            for (File f : files) {
                for (WindTowerInfo w : windTowerInfoList) {
                    String id = f.getName().substring(0, 4);
                    String password = w.getPassword();
                    //如果设备编号相等 则调用命令转换该文件
                    if (id.equals(w.getEquipmentNo())) {
                        String cmd = "\"D:\\NRG\\SymDR\\SDR.exe\"" + " /z " + password + " " + f.getPath();
                        Process ipconfig = runtime.exec(cmd);
                        ipconfig.waitFor();
                        InputStream inputStream = ipconfig.getInputStream();
                        byte[] bytes = new byte[1024];
                        int len = 0;
                        while ((len = inputStream.read(bytes)) != -1) {
                            log.info(new String(bytes, 0, len, "GBK"));
                        }
                    }
                }
                //转换成txt的文件在D:\NRG\ScaledData\目录下 移动到 D:\out\下   转换文件后会有两个文件一个txt  一个log  删除log 移动txt
                File file1 = new File("D:\\NRG\\ScaledData\\");
                File[] files1 = file1.listFiles();
                for (File e : files1) {
                    String[] name = e.getName().split("\\.");
                    if (name[1].equals("txt")) {
                        FileUtil.move(e.getPath(), "D:\\out\\new\\");
                    } else {
                        e.delete();
                    }
                }
                //转成txt后把文件移动到系统文件备份目录下
                File file2 = new File("D:\\in\\");
                File[] files2 = file2.listFiles();
                //xls移动系统文件目录下
                for (File e : files2) {
                    String[] str = e.getName().split("\\.");
                    if (str[1].equals("RWD")) {
                        FileUtil.move(e.getPath(), FileUtil.getSystemFilePath() + File.separator + str[0].substring(0, 4));
                    } else {
                        String[] strs = str[0].split("_");
                        FileUtil.move(e.getPath(), FileUtil.getSystemFilePath() + File.separator + strs[0]);
                    }
                }
                //把txt文件转成excel文件并解析
                String type = "RWD";
                analysisData.analysisData(type);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /**
     * 执行命令通过软件解压rld文件到D:\out\new\下
     *
     * @param equipmentNo 设备编号
     * @param recorderNo  记录仪编号
     */
    public void systemCommand(String equipmentNo, String recorderNo) {
        try {
            Runtime runtime = Runtime.getRuntime();
            //D:\\program\\uploadFile\\new rld文件在这个目录下
            File file = new File(FileUtil.getFileUploadPath() + File.separator + "new");
            //D:\\program\\uploadFile\\file rld转换成txt文件在这个目录下
            File uploadFile = new File(FileUtil.getFileUploadPath() + File.separator + "txtFile");
            if (!uploadFile.exists()) {
                uploadFile.mkdirs();
            }
            //遍历所有文件
            File[] files = file.listFiles();
            for (File f : files) {
                //根据编号和记录仪号过滤
                List<WindTowerInfo> windTowerInfoList = windTowerInfoService.list().stream().filter(wind -> wind.getEquipmentNo().equals(equipmentNo)
                        && wind.getRecorderNo().equals(recorderNo)).collect(Collectors.toList());
                //测风塔编号和记录仪编号两个条件 能确保塔的唯一性
                for (WindTowerInfo w : windTowerInfoList) {
                    if ("".equals(w.getPassword())) {
                        log.error(w.getEquipmentNo() + "测风塔没有配置数据密码");
                    } else {
                        String[] s = new String[]{
                                "\"D:\\Program Files (x86)\\Renewable NRG Systems\\SymPRO Desktop\\SymPRODesktop.exe\"",
                                "/cmd", "convert", "/file", f.getPath(),
                                "/pass", w.getPassword(), "/type", "\"meas\"", "/outputdir", "\"D:\\program\\uploadFile\\txtFile\""
                        };
                        Process ipconfig = runtime.exec(s);
                        ipconfig.waitFor();
                        InputStream inputStream = ipconfig.getInputStream();
                        byte[] bytes = new byte[1024];
                        int len = 0;
                        while ((len = inputStream.read(bytes)) != -1) {
                            log.info(new String(bytes, 0, len, "GBK"));
                        }
                    }
                }

            }
            //转成txt后把上传路径 D:\\program\\uploadFile\\new 下的rld文件移动到系统文件里
            File file1 = new File(FileUtil.getFileUploadPath() + File.separator + "new");
            File[] files1 = file1.listFiles();
            //xls移动系统文件目录下
            for (File e : files1) {
                String[] str = e.getName().split("\\.");
                if (str[1].equals("RWD")) {
                    FileUtil.move(e.getPath(), FileUtil.getSystemFilePath() + File.separator + str[0].substring(0, 4));
                } else {
                    String[] strs = str[0].split("_");
                    FileUtil.move(e.getPath(), FileUtil.getSystemFilePath() + File.separator + strs[0]);
                }
            }
            //解析数据
            this.analysisData();
        } catch (Exception e) {
            log.error("执行系统命令失败:" + e);
        }
    }

    /**
     * 解析数据
     */
    public void analysisData() {
        String txtPath = FileUtil.getFileUploadPath() + File.separator + "txtFile" + File.separator;
        String excelDir = FileUtil.getFileUploadPath() + File.separator + "excelFile" + File.separator;
        File file = new File(txtPath);
        if (!file.exists()) {
            file.mkdirs();
        }
        File excelFiles = new File(excelDir);
        if (!excelFiles.exists()) {
            excelFiles.mkdirs();
        }
        File[] files = file.listFiles();
        for (File f : files) {
            String[] xlsName = f.getName().split(".txt");
            String excelFile = excelDir + xlsName[0] + ".xls";
            //txt转xls
            analysisTXT(f.getPath(), excelFile);
            //xls文件解析入库
            analysisExcel(new File(excelFile));
            //转换成xls文件后删除txt文件
            f.delete();
            //解析完成后删除xls文件
            File exeFile = new File(excelFile);
            exeFile.delete();
        }
    }

    /**
     * 解析txt文件 输出成xls文件
     *
     * @param file_in  输入文件
     * @param file_out 输出文件
     */
    public void analysisTXT(String file_in, String file_out) {
        /*实例化输入、输出流*/
        //输入文件
        File f_in = new File(file_in);
        FileInputStream ips = null;
        InputStreamReader ipsr = null;
        //输出文件
        File f_out = new File(file_out);
        FileOutputStream ops = null;
        try {
            ips = new FileInputStream(f_in);
            ipsr = new InputStreamReader(ips);

            ops = new FileOutputStream(f_out);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        /*创建excel表格文件并输出*/
        //创建工作薄
        SXSSFWorkbook wb = new SXSSFWorkbook();
        try {
            //创建新的一页
            SXSSFSheet sheet = wb.createSheet("new sheet");
            BufferedReader br = new BufferedReader(ipsr);
            String valueString = null;
            //表格的有效行计数
            int count_line = 0;
            Boolean flag = false;
            StringBuilder dataName = new StringBuilder();
            //循环处理每一行
            while ((valueString = br.readLine()) != null) {
                if (flag) {//忽略开头代码
                    //分解每一行有效行
                    String[] strs_cell = valueString.split("\t");//用“|”切割每一行作为一个单元格数据
                    SXSSFRow row = sheet.createRow((short) count_line);
                    for (int i = 0; i < strs_cell.length; ++i) {//循环每个切割得到的数据，除了最后一个（,,,）和第一个（空）
                        //创建要显示的内容,创建一个单元格，第一个参数为列坐标，第二个参数为行坐标，第三个参数为内容
                        row.createCell((short) i).setCellValue(strs_cell[i]);
                        //所有表头
                        if (!dataName.toString().equals("")) {
                            dataName.append(",");
                            dataName.append(strs_cell[i]);
                        } else {
                            dataName.append(strs_cell[i]);
                        }
                    }
                    count_line++;
                }
                if (valueString.equals("Data")) {
                    flag = true;
                }
            }
            //根据数据表头分解出层高
            String[] names = dataName.toString().split(",");
            StringBuffer height = new StringBuffer();
            StringBuffer wdHeight = new StringBuffer();
            for (String name : names) {
                if (name.contains("Anem") || name.contains("Vane")) {
                    String[] keys = name.split("_");
                    String b = getWsOrWd(keys[1], keys[5]);
                    String c = keys[2].substring(0, keys[2].length() - 4);
                    if (b.equals("ws")) {
                        if (!height.toString().equals("")) {
                            if (!height.toString().contains(c)) {
                                height.append(",");
                                height.append(c);
                            }
                        } else {
                            height.append(c);
                        }
                    } else if (b.equals("wd")) {
                        if (!wdHeight.toString().equals("")) {
                            if (!wdHeight.toString().contains(c)) {
                                wdHeight.append(",");
                                wdHeight.append(c);
                            }
                        } else {
                            wdHeight.append(c);
                        }
                    }
                }

            }
            //把创建的表格写入到输出流中，并关闭输出流
            wb.write(ops);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (wb != null) {
                try {
                    wb.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (ips != null) {
                try {
                    ips.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if (ops != null) {
                try {
                    ops.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }

    /**
     * 解析excel文件
     *
     * @param file 文件
     */
    public void analysisExcel(File file) {
        String type = "rld";
        ExcelReader reader = ExcelUtil.getReader(file, 0);
        List<List<Object>> read = reader.read(0);
        List<Object> objects = read.get(0);
        Map<String, String> map = new HashMap<>();
        String[] fileNames = file.getName().split("_");
        CheckDataRecode.map.clear();
        //把表格里的数据转换成属性+层高方便解析入库
        for (Object object : objects) {
            //时间
            if (object.equals("Timestamp")) {
                reader.addHeaderAlias(object.toString(), "time");
                continue;
            }
            String[] keys = object.toString().split("_");
            //TODO改成传进去Ch1_Anem_140.00m_WNW_Avg_m/s 出来的是140风速的属性
            //a = 最大 最小 平均值 标差
            String a = getKeyStr(keys[4]);
            //b = 风速 风向 温 湿 压
            String b = getWsOrWd(keys[1], keys[5]);
            //c = 层高
            String c = keys[2].substring(0, keys[2].length() - 4);
            String value = b + a;
            if (null != map.get(value + "_" + c)) {
                value = value + "_" + Integer.parseInt(c) + "A";
            } else {
                if (!(b.equals("t") || b.equals("rh") || b.equals("pa"))) {
                    value = value + "_" + Integer.parseInt(c);
                }
            }
            //判断该数据是否解析过
            map.put(value, "1");
            CheckDataRecode.map.put(value + "DeadDataStartTime", new DateTime(fileNames[1]));
            reader.addHeaderAlias(object.toString(), value);
        }
        List<Map<String, Object>> allData = reader.readAll();
        //数据筛选
        List<Map<String, Object>> filterData = new CheckDataRecode().checkValue(allData, type);
        String eqId = file.getName().split("_")[0];
        String eTime = file.getName().split("_")[1];
        windTowerDataParentTableService.packageData(filterData, eqId, eTime, type, "");
        reader.close();
    }

    //拼装实体
    private String getKeyStr(String key) {
        if (("Avg").equals(key)) {
            return "Ave";
        }
        if (("SD").equals(key)) {
            return "Sta";
        }
        return key;
    }

    //拼装实体
    private String getWsOrWd(String key, String key2) {
        if (("Anem").equals(key)) {
            return "ws";
        }
        if (("Vane").equals(key)) {
            return "wd";
        }
        if (("Analog").equals(key)) {
            if (key2.equals("C")) {
                return "t";
            }
            if (key2.equals("mb") || key2.equals("hPa") || key2.equals("kpa") || key2.equals("KPa")) {
                return "pa";
            }
            if (key2.equals("%RH")) {
                return "rh";
            }
        }
        return key;
    }


    /**
     * 数据筛选
     *
     * @param startTime   开始时间
     * @param endTime     结束时间
     * @param equipmentNo 设备编号
     * @return 成功/失败
     */
    public AjaxResult dataCheck(Date startTime, Date endTime, String equipmentNo) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //所有数据
        List<Map<String, Object>> maps = windTowerDataParentTableService.selectDataByBetweenTimeAndEquipmetId(startTime, endTime, equipmentNo);
        CheckDataRecode checkDataRecode = new CheckDataRecode();
        checkDataRecode.map.clear();
        List<String> parentIdList = new ArrayList<>();
        try {
            if (!maps.isEmpty()) {
                long startDate = Long.parseLong(maps.get(0).get("time").toString());
                long endDate = Long.parseLong(maps.get(0).get("time").toString());
                //设置属性死值开始时间
                maps.get(0).forEach((k, v) -> {
                    checkDataRecode.map.put(k + "DeadDataStartTime", new DateTime(Long.parseLong(maps.get(0).get("time").toString())));
                });
                for (Map<String, Object> map : maps) {
                    //获取时间
                    if (startDate > Long.parseLong(map.get("time").toString())) {
                        startDate = Long.parseLong(map.get("time").toString());
                    }
                    if (endDate < Long.parseLong(map.get("time").toString())) {
                        endDate = Long.parseLong(map.get("time").toString());
                    }
                }
                //如果存在数据先删除
                if (!maps.isEmpty()) {
                    for (Map<String, Object> map : maps) {
                        if (!map.get("id").toString().isEmpty()) {
                            parentIdList.add(map.get("id").toString());
                        }
                    }
                    windTowerDataChildTableService.deleteBetweenTimeAndEquipmentIdAndChild(parentIdList, equipmentNo);
                    windTowerDataParentTableService.deleteBetweenTimeAndEquipmentIdAndParent(DateTimeUtil.getDayStartTime(startDate), DateTimeUtil.getDayLastTime(endDate), equipmentNo);
                }
                log.info("正在进行数据过滤");
                //重新走一遍数据过滤 然后存库
                List<Map<String, Object>> mapList = new CheckDataRecode().checkValue(maps, "rld");
                windTowerDataParentTableService.packageData(mapList, equipmentNo, sdf.format(new Date(startDate)), "rld", "DataRecalculation");
                return AjaxResult.success("数据筛选完成");
            } else {
                return AjaxResult.success("该时间范围内没有数据");
            }
        } catch (Exception e) {
            return AjaxResult.error("数据筛选失败");
        }

    }

    public AjaxResult statisticsCheck(Date startTime, Date endTime, String equipmentNo) {
        try {
            //获取到结束时间的当天最后时间
            endTime = DateTimeUtil.getDayLastTime(endTime.getTime());
            List<StatisticsSituation> statisticsSituations = statisticsSituationService.list();
            List<EquipmentAttribute> equipmentAttributeList = equipmentAttributeService.list();
            List<WindTowerCalculationData> windTowerCalculationDataList = windTowerCalculationDataService.getByBetweenTimeAndEquipmentId(startTime, endTime, equipmentNo);
            List<WindTowerInfo> windTowerInfoList = windTowerInfoService.getByEquipmentNo(equipmentNo);
            //风数据查询
            List<ProphaseAnemometryData> prophaseAnemometryDataList = prophaseAnemometryDataMapper.selectList(Wrappers.<ProphaseAnemometryData>lambdaQuery()
                    .eq(ProphaseAnemometryData::getEquipmentId, equipmentNo)
                    .le(ProphaseAnemometryData::getTs, new Timestamp(endTime.getTime()))
                    .ge(ProphaseAnemometryData::getTs, new Timestamp(startTime.getTime())));
            //环境数据查询
            List<ProphaseWeatherData> prophaseWeatherDataList = prophaseWeatherDataMapper.selectPublicData(equipmentNo, new Timestamp(startTime.getTime()), new Timestamp(endTime.getTime()));
            //把传入的时间按照日或月分割
            log.info("开始重新计算统计数据");
            ArrayList<WindTowerCalculationData> allDataList = new ArrayList<>();
            //小时风功率密度和平均风速
            ArrayList<WindTowerCalculationData> dataList = windTowerCalculationDataService.calculateWindPowerDensity(startTime.getTime(), endTime.getTime(), equipmentNo, prophaseAnemometryDataList, prophaseWeatherDataList, equipmentAttributeList, windTowerCalculationDataList);
            allDataList.addAll(dataList);
            //小时风切变
            ArrayList<WindTowerCalculationData> calculationData = windTowerCalculationDataService.calculateWindPowerShear(startTime, endTime, equipmentNo, prophaseAnemometryDataList, windTowerCalculationDataList);
            allDataList.addAll(calculationData);
            //日平均温度
            ArrayList<WindTowerCalculationData> tDay = windTowerCalculationDataService.tDay(startTime, endTime, equipmentNo, prophaseWeatherDataList, equipmentAttributeList);
            allDataList.addAll(tDay);
            //日平均气压
            ArrayList<WindTowerCalculationData> paDay = windTowerCalculationDataService.paDay(startTime, endTime, equipmentNo, prophaseWeatherDataList, equipmentAttributeList);
            allDataList.addAll(paDay);
            //日平均风速
            ArrayList<WindTowerCalculationData> wsDay = windTowerCalculationDataService.wsDay(startTime, endTime, equipmentNo, windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
            allDataList.addAll(wsDay);
            //日平均风速标差
            ArrayList<WindTowerCalculationData> calculationData1 = windTowerCalculationDataService.calculateStaDay(startTime, endTime, equipmentNo, prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList, windTowerCalculationDataList);
            allDataList.addAll(calculationData1);
            //日平均湍流
            ArrayList<WindTowerCalculationData> turbulenceDay = windTowerCalculationDataService.turbulenceDay(startTime, endTime, equipmentNo, equipmentAttributeList, windTowerInfoList, windTowerCalculationDataList);
            allDataList.addAll(turbulenceDay);
            //日平均空气密度
            ArrayList<WindTowerCalculationData> airDensityDay = windTowerCalculationDataService.airDensityDay(startTime, endTime, equipmentNo, prophaseWeatherDataList, equipmentAttributeList, windTowerCalculationDataList);
            allDataList.addAll(airDensityDay);
            //日平均风功率密度
            ArrayList<WindTowerCalculationData> wpdDay = windTowerCalculationDataService.wpdDay(startTime, endTime, equipmentNo, windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
            allDataList.addAll(wpdDay);
            //日平均风切变
            ArrayList<WindTowerCalculationData> shearDay = windTowerCalculationDataService.shearDay(startTime, endTime, equipmentNo, windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
            allDataList.addAll(shearDay);


            List<Long> dateTime = DateTimeUtil.getIntervalTimeByMonth(DateTimeUtil.beginOfMonth(startTime), DateTimeUtil.beginOfMonth(endTime));
            for (Long l : dateTime) {
                //月平均风速
                ArrayList<WindTowerCalculationData> wsMonth = windTowerCalculationDataService.wsMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
                allDataList.addAll(wsMonth);
                //月平均风功率密度
                ArrayList<WindTowerCalculationData> wpdMonth = windTowerCalculationDataService.wpdMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
                allDataList.addAll(wpdMonth);
                //月平均湍流
                ArrayList<WindTowerCalculationData> turbulenceMonth = windTowerCalculationDataService.turbulenceMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
                allDataList.addAll(turbulenceMonth);
                //月平均空气密度
                ArrayList<WindTowerCalculationData> airDensityMonth = windTowerCalculationDataService.airDensityMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, windTowerCalculationDataList, equipmentAttributeList);
                allDataList.addAll(airDensityMonth);
                //月最大风速
                ArrayList<WindTowerCalculationData> wsMaxMonth = windTowerCalculationDataService.wsMaxMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
                allDataList.addAll(wsMaxMonth);
                //月平均风切变
                ArrayList<WindTowerCalculationData> shearMonth = windTowerCalculationDataService.shearMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, windTowerCalculationDataList, equipmentAttributeList, windTowerInfoList);
                allDataList.addAll(shearMonth);
                //月平均风速标差
                ArrayList<WindTowerCalculationData> staMonth = windTowerCalculationDataService.staMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
                allDataList.addAll(staMonth);
                //月玫瑰图
                windDirectionStatisticsDataService.roseMonth(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, prophaseAnemometryDataList,prophaseWeatherDataList, equipmentAttributeList);
                //月平均环境数据
                ArrayList<WindTowerCalculationData> environmentData = windTowerCalculationDataService.environmentData(DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), equipmentNo, prophaseWeatherDataList, equipmentAttributeList);
                allDataList.addAll(environmentData);
                //空气密度月逐时
                ArrayList<WindTowerCalculationData> airDensityMonth1 = windTowerCalculationDataService.airDensityMonth(equipmentNo, DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), prophaseWeatherDataList);
                allDataList.addAll(airDensityMonth1);
                //湍流月逐时
                ArrayList<WindTowerCalculationData> turbulenceHourForMonth = windTowerCalculationDataService.turbulenceHourForMonth(equipmentNo, DateTimeUtil.beginOfMonth(new Date(l)), DateTimeUtil.endOfMonth(new Date(l)), prophaseAnemometryDataList, equipmentAttributeList, windTowerInfoList);
                allDataList.addAll(turbulenceHourForMonth);
            }
            // 统计概述
            statisticsSituationService.statisticsSituation(windTowerInfoList.get(0), statisticsSituations, equipmentAttributeList);
            windTowerCalculationDataService.saveBatchByEquipmentId(allDataList,equipmentNo);
            log.info("计算统计数据执行完毕");
            return AjaxResult.success("数据已经重新统计");
        } catch (Exception e) {
            log.info("数据统计计算时异常");
            return AjaxResult.error("数据统计计算时异常");
        }
    }
}