增加测风塔统计

ipfcst/ipfcst-common/ipfcst-common-data/src/main/java/com/jiayue/ipfcst/common/data/entity/EnvironmentalDataOne.java

@@ -0,0 +1,105 @@
+package com.jiayue.ipfcst.common.data.entity;
+
+import com.jiayue.ipfcst.common.data.constant.enums.EquipmentTypeEnum;
+import lombok.Data;
+import org.hibernate.annotations.GenericGenerator;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+
+/**
+ * 环境数据统计实体
+ *
+ * @author tl
+ * @version 1.0
+ * @since 2020/10/09 15:16
+ */
+@Data
+@Entity
+public class EnvironmentalDataOne implements Serializable {
+
+	/**
+	 * Id
+	 */
+	@Id
+	@GeneratedValue(strategy = GenerationType.AUTO, generator = "myid")
+	@GenericGenerator(name = "myid", strategy = "com.jiayue.ipfcst.common.data.entity.id.CustomIDGenerator")
+	private Integer id;
+
+	/**
+	 * 设备类型
+	 */
+	@Column
+	private EquipmentTypeEnum equipmentTypeEnum;
+
+
+	/**
+	 * 设备id
+	 */
+	@Column
+	private Integer equipmentId;
+
+
+	/**
+	 * 数据类型
+	 */
+	@OneToOne
+	@JoinColumn(name = "equipmentAttributeId", foreignKey = @ForeignKey(value = ConstraintMode.NO_CONSTRAINT), updatable = false)
+	private EquipmentAttribute equipmentAttribute;
+
+	/**
+	 * 极大值（最大值）
+	 */
+	@Column
+	private BigDecimal maxValue;
+
+	/**
+	 * 极小值（最小值）
+	 */
+	@Column
+	private BigDecimal minValue;
+
+	/**
+	 * 平均值
+	 */
+	@Column
+	private BigDecimal avgValue;
+
+    /**
+     * 统计数据的个数
+     */
+	@Column
+	private Integer statisticalDataNum;
+
+	/**
+	 * 极大值时刻（最大值时刻）
+	 */
+	@Column
+	private Date maxValueTime;
+
+	/**
+	 * 极小值时刻（最小值时刻）
+	 */
+	@Column
+	private Date minValueTime;
+
+	/**
+	 * 数据统计时间
+	 */
+	@Column
+	private Date statisticalTime;
+
+	/**
+	 * 最大值（极大值）
+	 */
+	@Column
+	private BigDecimal maxAvgValue;
+
+	/**
+	 * 最小值（极小值）
+	 */
+	@Column
+	private BigDecimal minAvgValue;
+}

ipfcst/ipfcst-common/ipfcst-common-data/src/main/java/com/jiayue/ipfcst/common/data/repository/EnvironmentalDataOneRepository.java

@@ -0,0 +1,22 @@
+package com.jiayue.ipfcst.common.data.repository;
+
+import com.jiayue.ipfcst.common.data.constant.enums.EquipmentTypeEnum;
+import com.jiayue.ipfcst.common.data.entity.EnvironmentalDataOne;
+import com.jiayue.ipfcst.common.data.entity.EquipmentAttribute;
+import org.springframework.data.jpa.repository.Query;
+
+import java.util.Date;
+import java.util.List;
+
+
+public interface EnvironmentalDataOneRepository extends BaseRepository<EnvironmentalDataOne, Integer> {
+
+
+	@Query("select e from EnvironmentalDataOne e  where e.equipmentTypeEnum=?1 and e.equipmentId=?2 and e.equipmentAttribute=?3 and e.statisticalTime=?4")
+	List<EnvironmentalDataOne> queryByTimeAndAttr(EquipmentTypeEnum equipmentType, Integer equipmentId, EquipmentAttribute equipmentAttribute, Date statisticalTime);
+
+	List<EnvironmentalDataOne> findByStatisticalTimeBetweenAndEquipmentTypeEnumInAndEquipmentIdIn(Date startDate,Date endDate,EquipmentTypeEnum[] equipmentTypeEnum,Integer[] eqId);
+
+	List<EnvironmentalDataOne> findByStatisticalTimeBetweenAndEquipmentTypeEnumInAndEquipmentId(Date startDate,Date endDate,EquipmentTypeEnum[] equipmentTypeEnum,Integer eqId);
+
+}

ipfcst/ipfcst-reportquery/src/main/frontend/router/modules/statisticsQuery.js

@@ -23,14 +23,14 @@ const statisticsQueryRouter = {
       path: 'accuracyPassRate',
       component: () => import('@/views/statisticsQuery/accuracyPassRate'),
       name: 'accuracyPassRate',
-      meta: { title: '光伏准确率统计查询', noCache: true },
+      meta: { title: '光伏准确率日统计查询', noCache: true },
       sign: 'currency'
     },
     {
       path: 'accuracyPassRateOne',
       component: () => import('@/views/statisticsQuery/accuracyPassRateOne'),
       name: 'accuracyPassRateOne',
-      meta: { title: '风电准确率统计查询', noCache: true },
+      meta: { title: '风电准确率日统计查询', noCache: true },
       sign: 'currency'
     },
     // {

ipfcst/ipfcst-reportquery/src/main/frontend/views/statisticsQuery/CESQuery/index.vue

@@ -44,17 +44,17 @@
       <div class="timeQuery">
         <el-button :loading="loading" size="small" @click="prValue('click')" v-show="this.show">Pr值</el-button>
       </div>
-      <div class="timeQuery" v-show="bShow" style="margin-left: 20%">
-        日内总辐射平均：
-        <el-switch
-        v-model="switchValue"
-        @change="showavg"
-        active-color="#13ce66"
-        inactive-color="#ff4949"
-        active-text = "开启"
-        >
-      </el-switch>
-      </div>
+<!--      <div class="timeQuery" v-show="bShow" style="margin-left: 20%">-->
+<!--        日内总辐射平均：-->
+<!--        <el-switch-->
+<!--        v-model="switchValue"-->
+<!--        @change="showavg"-->
+<!--        active-color="#13ce66"-->
+<!--        inactive-color="#ff4949"-->
+<!--        active-text = "开启"-->
+<!--        >-->
+<!--      </el-switch>-->
+<!--      </div>-->
     </div>
     <div class="content">
 

ipfcst/ipfcst-reportquery/src/main/java/com/jiayue/ipfcst/controller/EnvironmentalDataOneController.java

@@ -5,6 +5,7 @@ import cn.hutool.core.io.IoUtil;
 import cn.hutool.poi.excel.ExcelUtil;
 import cn.hutool.poi.excel.ExcelWriter;
 import com.jiayue.ipfcst.common.core.web.vo.ResponseVO;
+import com.jiayue.ipfcst.service.EnvironmentalDataOneService;
 import com.jiayue.ipfcst.service.EnvironmentalDataService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -27,28 +28,28 @@ import java.util.Map;
 @RestController
 @RequestMapping("environmentalDataOne")
 public class EnvironmentalDataOneController {
-  private final EnvironmentalDataService environmentalDataService;
+  private final EnvironmentalDataOneService environmentalDataOneService;
 
   @Autowired
-  public EnvironmentalDataOneController(EnvironmentalDataService environmentalDataService) {
-    this.environmentalDataService = environmentalDataService;
+  public EnvironmentalDataOneController(EnvironmentalDataService environmentalDataService, EnvironmentalDataOneService environmentalDataOneService) {
+    this.environmentalDataOneService = environmentalDataOneService;
   }
 
   @GetMapping("/findEnvironmentalData/{startTime}/{endTime}/{eqId}")
   public ResponseVO findEnvironmentalData(@PathVariable Long startTime, @PathVariable Long endTime, @PathVariable Integer eqId) {
-    Map<String, Object> byRealTime = environmentalDataService.getData(startTime, endTime, eqId,2);
+    Map<String, Object> byRealTime = environmentalDataOneService.getData(startTime, endTime, eqId,2);
     return ResponseVO.success(byRealTime);
   }
 
 
   @GetMapping("/findEnvironmentalData")
   public ResponseVO getEqAttribute() {
-    return ResponseVO.success(environmentalDataService.eqAttribute());
+    return ResponseVO.success(environmentalDataOneService.eqAttribute());
   }
 
   @GetMapping("/findEnvironmentalData/{eqId}")
   public ResponseVO getEqAttributeById(@PathVariable Integer eqId) {
-    return ResponseVO.success(environmentalDataService.getEqAttributeById(eqId));
+    return ResponseVO.success(environmentalDataOneService.getEqAttributeById(eqId));
   }
 
   /**
@@ -59,7 +60,7 @@ public class EnvironmentalDataOneController {
   @RequestMapping(value = "/export")
   public void export(HttpServletResponse response, Long startTime, Long endTime, Integer eqId) {
     try {
-      Map<String, Object> maps = environmentalDataService.getData(startTime, endTime, eqId,2);
+      Map<String, Object> maps = environmentalDataOneService.getData(startTime, endTime, eqId,2);
 
       List<Map<String, String>> tableColumns = (List<Map<String, String>>) maps.get("tableColumn");
 

ipfcst/ipfcst-reportquery/src/main/java/com/jiayue/ipfcst/service/EnvironmentalDataOneService.java

@@ -0,0 +1,551 @@
+package com.jiayue.ipfcst.service;
+
+import com.jiayue.ipfcst.common.data.constant.enums.EquipmentTypeEnum;
+import com.jiayue.ipfcst.common.data.entity.*;
+import com.jiayue.ipfcst.common.data.repository.DisplayConfigRepository;
+import com.jiayue.ipfcst.common.data.repository.ElectricFieldRepository;
+import com.jiayue.ipfcst.common.data.repository.EnvironmentalDataOneRepository;
+import com.jiayue.ipfcst.common.data.repository.EnvironmentalDataRepository;
+import com.jiayue.ipfcst.common.data.service.BaseService;
+import com.jiayue.ipfcst.repository.EquipmentAttributeRepository;
+import com.jiayue.ipfcst.repository.ProtocolGatherDataPointRepository;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.lang.time.DateFormatUtils;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.text.SimpleDateFormat;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+public class EnvironmentalDataOneService extends BaseService {
+
+  private final EnvironmentalDataOneRepository environmentalDataOneRepository;
+
+  private final ProtocolGatherDataPointRepository protocolGatherDataPointRepository;
+
+  private final ElectricFieldRepository electricFieldRepository;
+
+  private final EquipmentAttributeRepository equipmentAttributeRepository;
+
+  private final DisplayConfigRepository displayConfigRepository;
+
+
+  public Map<String, Object> getData(Long startTime, Long endTime, Integer eqId,Integer code) {
+
+    Map<String, Object> map = new HashMap<>();
+
+    ElectricField electricField = electricFieldRepository.findAll().get(0);
+
+    Map<String, Object> footMap = new HashMap<>();
+
+    EquipmentTypeEnum equipmentTypeEnum;
+
+    String displayCode = "weatherStationEnvironmental";
+    if (code == 1) {
+      //获取气象站的数据类型集合
+      equipmentTypeEnum = EquipmentTypeEnum.WEATHERSTATION;
+    } else {
+      //获取测风塔的数据类型集合
+      equipmentTypeEnum = EquipmentTypeEnum.WINDTOWER;
+      displayCode = "windTowerEnvironmental";
+    }
+    //根据常查的类型选择要查询的显示配置
+    DisplayConfig displayConfig = displayConfigRepository.findByDisplayCode(displayCode);
+    //因为实际功率属于场站的数据类型，所以要单独添加 EquipmentTypeEnum.POWERSTATION
+    List<EquipmentAttribute> equipmentAttributes = equipmentAttributeRepository.findByEquipmentTypeOrEquipmentType(equipmentTypeEnum, EquipmentTypeEnum.POWERSTATION);
+
+    //如果没有对应的显示配置，初始化一份
+    if (displayConfig != null) {
+      Integer[] allEqId = new Integer[equipmentAttributes.size()];
+      int n = 0;
+      for (EquipmentAttribute equipmentAttribute : equipmentAttributes) {
+        allEqId[n] = equipmentAttribute.getId();
+        n++;
+      }
+      List<ProtocolGatherDataPoint> byEquipmentAttribute = protocolGatherDataPointRepository.findByEquipmentAttributeIdIn(allEqId);
+      String allCode = displayConfig.getShowCode() + displayConfig.getHiddenCode();
+      StringBuilder showCode = new StringBuilder(displayConfig.getShowCode());
+      String[] allCodes = allCode.split(",");
+      for (ProtocolGatherDataPoint protocolGatherDataPoint : byEquipmentAttribute) {
+        String nFieldName = protocolGatherDataPoint.getEquipmentAttribute().getEquipmentType().toString() + protocolGatherDataPoint.getEquipmentAttribute().getFieldName();
+        if (!Arrays.asList(allCodes).contains(nFieldName)) {
+          showCode.append(nFieldName).append(",");
+        }
+      }
+
+      displayConfig.setShowCode(showCode.toString());
+      displayConfigRepository.save(displayConfig);
+    }
+
+    //筛选设备对应的采集点表数据
+    List<ProtocolGatherDataPoint> protocolGatherDataPoints = protocolGatherDataPointRepository.findByEquipmentIdOrEquipmentId(eqId, 0);
+    //根据采集点表取出对应的数据类型
+    List<EquipmentAttribute> equipmentAttributess = new ArrayList<>();
+    for (EquipmentAttribute equipmentAttribute : equipmentAttributes) {
+      if (protocolGatherDataPoints.stream().anyMatch(m -> m.getEquipmentAttribute().getId().equals(equipmentAttribute.getId()))) {
+        equipmentAttributess.add(equipmentAttribute);
+      }
+    }
+
+    List<EquipmentAttribute> resultEquipmentAttributes = new ArrayList<>();
+
+    if (displayConfig == null) {
+      resultEquipmentAttributes = equipmentAttributess;
+    } else {
+      String showCode = displayConfig.getShowCode();
+      String[] split = showCode.split(",");
+
+      for (EquipmentAttribute equipmentAttribute : equipmentAttributess) {
+        String nFieldName = equipmentAttribute.getEquipmentType().toString() + equipmentAttribute.getFieldName();
+        for (String s : split) {
+          if (s.equals(nFieldName)) {
+            resultEquipmentAttributes.add(equipmentAttribute);
+          }
+        }
+      }
+    }
+
+    List<Map<String, Object>> tableColumn = getTableColumn(resultEquipmentAttributes);
+
+    EquipmentTypeEnum[] equipmentTypeEnums = {equipmentTypeEnum, EquipmentTypeEnum.POWERSTATION};
+    Integer[] eqIds = {eqId, 0};
+    List<EnvironmentalDataOne> environmentalDatas = environmentalDataOneRepository.findByStatisticalTimeBetweenAndEquipmentTypeEnumInAndEquipmentIdIn(new Date(startTime), new Date(endTime), equipmentTypeEnums, eqIds);
+
+    List<EnvironmentalDataOne> environmentalDataList = environmentalDatas.stream().filter(c -> c.getAvgValue() != null).collect(Collectors.toList());
+
+    List<Map<String, Object>> dayList = new ArrayList<>();
+    List<Map<String, Object>> monthList = new ArrayList<>();
+    List<Map<String, Object>> yearList = new ArrayList<>();
+
+    if (!environmentalDataList.isEmpty()) {
+      dayList = getDayData(environmentalDataList, resultEquipmentAttributes, dayList);
+
+      monthList = getMonthData(environmentalDataList, resultEquipmentAttributes, monthList);
+
+      yearList = getYearData(environmentalDataList, resultEquipmentAttributes, yearList);
+
+      footMap = getFootData(footMap, resultEquipmentAttributes, environmentalDataList);
+    }
+
+    map.put("footerData", footMap);
+    map.put("tableColumn", tableColumn);
+    map.put("dayList", dayList);
+    map.put("monthList", monthList);
+    map.put("yearList", yearList);
+
+    return map;
+  }
+
+
+  public List<Map<String, String>> eqAttribute() {
+    List<Map<String, String>> list = new ArrayList<>();
+    List<EquipmentAttribute> equipmentAttributes;
+      //获取测风塔的数据类型集合
+    equipmentAttributes = equipmentAttributeRepository.findByEquipmentTypeOrEquipmentType(EquipmentTypeEnum.WINDTOWER, EquipmentTypeEnum.POWERSTATION);
+    for (EquipmentAttribute equipmentAttribute : equipmentAttributes) {
+      Map<String, String> map = new HashMap<>();
+      String nFieldName = equipmentAttribute.getEquipmentType().toString() + equipmentAttribute.getFieldName();
+      map.put("key", equipmentAttribute.getExplanation());
+      map.put("value", nFieldName);
+      list.add(map);
+    }
+    return list;
+  }
+
+  public List<EquipmentAttribute> getEqAttributeById(Integer eqId) {
+
+    List<EquipmentAttribute> equipmentAttributes;
+    EquipmentTypeEnum equipmentTypeEnum;
+    //获取测风塔的数据类型集合
+    equipmentTypeEnum = EquipmentTypeEnum.WINDTOWER;
+    equipmentAttributes = equipmentAttributeRepository.findByEquipmentTypeOrEquipmentType(equipmentTypeEnum, EquipmentTypeEnum.POWERSTATION);
+    //筛选设备对应的采集点表数据
+    List<ProtocolGatherDataPoint> protocolGatherDataPointList = protocolGatherDataPointRepository.findByEquipmentIdOrEquipmentId(eqId, 0);
+    List<ProtocolGatherDataPoint> protocolGatherDataPoints = new ArrayList<>();
+    for (ProtocolGatherDataPoint protocolGatherDataPoint : protocolGatherDataPointList) {
+      EquipmentAttribute equipmentAttribute = equipmentAttributeRepository.findById(protocolGatherDataPoint.getEquipmentAttribute().getId()).get();
+      if (equipmentAttribute.getEquipmentType().equals(equipmentTypeEnum) || equipmentAttribute.getEquipmentType().equals(EquipmentTypeEnum.POWERSTATION)) {
+        protocolGatherDataPoints.add(protocolGatherDataPoint);
+      }
+    }
+
+    //根据采集点表取出对应的数据类型
+    List<EquipmentAttribute> equipmentAttributess = new ArrayList<>();
+    for (EquipmentAttribute equipmentAttribute : equipmentAttributes) {
+      if (protocolGatherDataPoints.stream().anyMatch(m -> m.getEquipmentAttribute().getId().equals(equipmentAttribute.getId()))) {
+        equipmentAttributess.add(equipmentAttribute);
+      }
+    }
+    return equipmentAttributess;
+  }
+
+  //用于获取集合最大值
+  public EnvironmentalDataOne getEnvMax(List<EnvironmentalDataOne> environmentalDatass) {
+    EnvironmentalDataOne maxData;
+    try {
+      maxData = environmentalDatass.stream().filter(environmentalData -> environmentalData.getMaxValue() != null).collect(Collectors.toList()).stream().max(Comparator.comparing(EnvironmentalDataOne::getMaxValue)).get();
+    } catch (NoSuchElementException e) {
+      e.printStackTrace();
+      maxData = new EnvironmentalDataOne();
+    }
+
+    return maxData;
+  }
+
+  //用于获取集合最小值
+  public EnvironmentalDataOne getEnvMin(List<EnvironmentalDataOne> environmentalDatass) {
+    EnvironmentalDataOne minData;
+    try {
+      minData = environmentalDatass.stream().filter(environmentalData -> environmentalData.getMinValue() != null).collect(Collectors.toList()).stream().min(Comparator.comparing(EnvironmentalDataOne::getMinValue)).get();
+    } catch (NoSuchElementException e) {
+      e.printStackTrace();
+      minData = new EnvironmentalDataOne();
+    }
+
+    return minData;
+  }
+
+  //用于获取集合平均值
+  public double getEnvAvg(List<EnvironmentalDataOne> environmentalDatass) {
+    double avgData = -99;
+    try {
+      avgData = environmentalDatass.stream().filter(environmentalData -> environmentalData.getAvgValue() != null).collect(Collectors.toList()).stream().mapToDouble(environmentalData -> environmentalData.getAvgValue().doubleValue()).average().getAsDouble();
+    } catch (NoSuchElementException e) {
+      e.printStackTrace();
+    }
+    return avgData;
+  }
+
+  //未获取到值时为集合添加占位内容
+  public Map<String, Object> putNoThing(Map<String, Object> tempMap, EquipmentAttribute equipmentAttribute) {
+    String nFieldName = equipmentAttribute.getEquipmentType().toString() + equipmentAttribute.getFieldName();
+    tempMap.put("maxAvgValue" + nFieldName, "");
+    tempMap.put("max" + nFieldName, "");
+    tempMap.put("maxTime" + nFieldName, "");
+    tempMap.put("min" + nFieldName, "");
+    tempMap.put("minTime" + nFieldName, "");
+    tempMap.put("avg" + nFieldName, "");
+    return tempMap;
+  }
+
+
+  //为成功获取到的数据对象进行数据封装
+  public Map<String, Object> putVal(Map<String, Object> tempMap, EquipmentAttribute equipmentAttribute, EnvironmentalDataOne maxEData, EnvironmentalDataOne minEData, double asDouble) {
+    String nFieldName = equipmentAttribute.getEquipmentType().toString() + equipmentAttribute.getFieldName();
+    tempMap.put("maxAvgValue" + nFieldName, maxEData.getMaxAvgValue() == null ? "" : maxEData.getMaxAvgValue());
+    tempMap.put("max" + nFieldName, maxEData.getMaxValue() == null ? "" : maxEData.getMaxValue());
+    tempMap.put("maxTime" + nFieldName, maxEData.getMaxValueTime() == null ? "" : maxEData.getMaxValueTime());
+    tempMap.put("min" + nFieldName, minEData.getMinValue() == null ? "" : minEData.getMinValue());
+    tempMap.put("minTime" + nFieldName, minEData.getMinValueTime() == null ? "" : minEData.getMinValueTime());
+    tempMap.put("avg" + nFieldName, asDouble == -99 ? "" : new BigDecimal(asDouble).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue());
+    return tempMap;
+  }
+
+
+  public List<Map<String, Object>> getDayData(List<EnvironmentalDataOne> environmentalDataList, List<EquipmentAttribute> equipmentAttributes, List<Map<String, Object>> dayList) {
+    Map<String, List<EnvironmentalDataOne>> afterFormatting = null;
+
+    List<Map<String, EnvironmentalDataOne>> beforeFormatting = new ArrayList<>();
+    //提取日统计数据
+    for (EnvironmentalDataOne n : environmentalDataList) {
+      HashMap<String, EnvironmentalDataOne> map1 = new HashMap<>();
+      map1.put(DateFormatUtils.format(n.getStatisticalTime(), "yyyyMMdd"), n);
+      beforeFormatting.add(map1);
+      afterFormatting = beforeFormatting.stream().flatMap(m -> m.entrySet().stream()).collect(Collectors.groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, Collectors.toList())));
+    }
+    Map<String, List<EnvironmentalDataOne>> resultMap = new LinkedHashMap<>();
+    afterFormatting.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEachOrdered(e -> resultMap.put(e.getKey(), e.getValue()));
+    for (String key : resultMap.keySet()) {
+      Map<String, Object> tempMap = new HashMap<>();
+      List<EnvironmentalDataOne> n = resultMap.get(key);
+
+      for (EquipmentAttribute equipmentAttribute : equipmentAttributes) {
+        String nFieldName = equipmentAttribute.getEquipmentType().toString() + equipmentAttribute.getFieldName();
+        String explanation = equipmentAttribute.getExplanation();
+        List<EnvironmentalDataOne> environmentalDatass = new ArrayList<>();
+        for (EnvironmentalDataOne environmentalData : n) {
+          if (environmentalData.getEquipmentAttribute().equals(equipmentAttribute)) {
+            environmentalDatass.add(environmentalData);
+          }
+        }
+        if (!environmentalDatass.isEmpty()) {
+          EnvironmentalDataOne environmentalData = environmentalDatass.get(0);
+
+          if (nFieldName.equals("WEATHERSTATIONglobalRDA") || nFieldName.equals("WEATHERSTATIONdirectRDA") || nFieldName.equals("WEATHERSTATIONdiffuseRDA") || nFieldName.equals("WEATHERSTATIONobliqueRDA") || nFieldName.equals("WEATHERSTATIONhourDA") || explanation.equals("日站外受阻电量") || explanation.equals("日站内受阻电量") || explanation.equals("日受阻电量")) {
+            tempMap.put("sum" + nFieldName, environmentalData.getMaxValue());
+          } else {
+            tempMap.put("maxAvgValue" + nFieldName, environmentalData.getMaxAvgValue());
+            tempMap.put("max" + nFieldName, environmentalData.getMaxValue());
+            tempMap.put("maxTime" + nFieldName, environmentalData.getMaxValueTime());
+            tempMap.put("min" + nFieldName, environmentalData.getMinValue());
+            tempMap.put("minTime" + nFieldName, environmentalData.getMinValueTime());
+            tempMap.put("avg" + nFieldName, environmentalData.getAvgValue());
+          }
+        } else {
+          if (nFieldName.equals("WEATHERSTATIONglobalRDA") || nFieldName.equals("WEATHERSTATIONdirectRDA") || nFieldName.equals("WEATHERSTATIONdiffuseRDA") || nFieldName.equals("WEATHERSTATIONobliqueRDA") || nFieldName.equals("WEATHERSTATIONhourDA") || explanation.equals("日站外受阻电量") || explanation.equals("日站内受阻电量") || explanation.equals("日受阻电量")) {
+            tempMap.put("sum" + nFieldName, "");
+          } else {
+            tempMap = putNoThing(tempMap, equipmentAttribute);
+          }
+        }
+      }
+      tempMap.put("times", key);
+      dayList.add(tempMap);
+    }
+
+    return dayList;
+  }
+
+
+  public List<Map<String, Object>> getMonthData(List<EnvironmentalDataOne> environmentalDataList, List<EquipmentAttribute> equipmentAttributes, List<Map<String, Object>> monthList) {
+    Map<String, List<EnvironmentalDataOne>> monthAfterFormatting = null;
+
+    List<Map<String, EnvironmentalDataOne>> monthBeforeFormatting = new ArrayList<>();
+    //提取月统计数据
+    for (EnvironmentalDataOne n : environmentalDataList) {
+      Map<String, EnvironmentalDataOne> map1 = new HashMap<>();
+      map1.put(DateFormatUtils.format(n.getStatisticalTime(), "yyyyMM"), n);
+      monthBeforeFormatting.add(map1);
+      monthAfterFormatting = monthBeforeFormatting.stream().flatMap(m -> m.entrySet().stream()).collect(Collectors.groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, Collectors.toList())));
+    }
+    Map<String, List<EnvironmentalDataOne>> monthResultMap = new LinkedHashMap<>();
+    monthAfterFormatting.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEachOrdered(e -> monthResultMap.put(e.getKey(), e.getValue()));
+    for (String key : monthResultMap.keySet()) {
+      Map<String, Object> tempMap = new HashMap<>();
+      List<EnvironmentalDataOne> n = monthResultMap.get(key);
+
+      for (EquipmentAttribute equipmentAttribute : equipmentAttributes) {
+        String nFieldName = equipmentAttribute.getEquipmentType().toString() + equipmentAttribute.getFieldName();
+        String explanation = equipmentAttribute.getExplanation();
+        List<EnvironmentalDataOne> environmentalDatass = new ArrayList<>();
+        for (EnvironmentalDataOne environmentalData : n) {
+          if (environmentalData.getEquipmentAttribute().equals(equipmentAttribute)) {
+            environmentalDatass.add(environmentalData);
+          }
+        }
+        if (!environmentalDatass.isEmpty()) {
+          if (nFieldName.equals("WEATHERSTATIONglobalRDA") || nFieldName.equals("WEATHERSTATIONdirectRDA") || nFieldName.equals("WEATHERSTATIONdiffuseRDA") || nFieldName.equals("WEATHERSTATIONobliqueRDA") || nFieldName.equals("WEATHERSTATIONhourDA") || explanation.equals("日站外受阻电量") || explanation.equals("日站内受阻电量") || explanation.equals("日受阻电量")) {
+            //
+            Map<String, List<EnvironmentalDataOne>> afterFormattingDay = null;
+
+            List<Map<String, EnvironmentalDataOne>> beforeFormattingDay = new ArrayList<>();
+            //提取日统计数据
+            for (EnvironmentalDataOne nDay : environmentalDatass) {
+              Map<String, EnvironmentalDataOne> map1 = new HashMap<>();
+              map1.put(DateFormatUtils.format(nDay.getStatisticalTime(), "yyyyMMdd"), nDay);
+              beforeFormattingDay.add(map1);
+              afterFormattingDay = beforeFormattingDay.stream().flatMap(m -> m.entrySet().stream()).collect(Collectors.groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, Collectors.toList())));
+            }
+            Map<String, List<EnvironmentalDataOne>> resultMapDay = new LinkedHashMap<>();
+            afterFormattingDay.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEachOrdered(e -> resultMapDay.put(e.getKey(), e.getValue()));
+            List<EnvironmentalDataOne> listDay = new ArrayList<>();
+            for (String keyDay : resultMapDay.keySet()) {
+              List<EnvironmentalDataOne> nDay = resultMapDay.get(keyDay);
+              EnvironmentalDataOne maxEData = getEnvMax(nDay);
+              listDay.add(maxEData);
+            }
+            //
+            double sumValue = environmentalDatass.stream().filter(environmentalData -> environmentalData.getMaxValue() != null).collect(Collectors.toList()).stream().mapToDouble(environmentalData -> environmentalData.getMaxValue().doubleValue()).sum();
+            BigDecimal bSumValue = new BigDecimal(sumValue);
+            tempMap.put("sum" + nFieldName, bSumValue.setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue());
+            double asDouble = getEnvAvg(listDay);
+
+            EnvironmentalDataOne maxEData = getEnvMax(listDay);
+            EnvironmentalDataOne minEData = getEnvMin(listDay);
+            tempMap = putVal(tempMap, equipmentAttribute, maxEData, minEData, asDouble);
+
+
+          } else {
+            EnvironmentalDataOne maxEData = getEnvMax(environmentalDatass);
+            EnvironmentalDataOne minEData = getEnvMin(environmentalDatass);
+            double asDouble = getEnvAvg(environmentalDatass);
+            tempMap = putVal(tempMap, equipmentAttribute, maxEData, minEData, asDouble);
+          }
+        } else {
+          tempMap = putNoThing(tempMap, equipmentAttribute);
+          if (nFieldName.equals("WEATHERSTATIONglobalRDA") || nFieldName.equals("WEATHERSTATIONdirectRDA") || nFieldName.equals("WEATHERSTATIONdiffuseRDA") || nFieldName.equals("WEATHERSTATIONobliqueRDA") || nFieldName.equals("WEATHERSTATIONhourDA") || explanation.equals("日站外受阻电量") || explanation.equals("日站内受阻电量") || explanation.equals("日受阻电量")) {
+            tempMap.put("sum" + nFieldName, "");
+          }
+        }
+      }
+      tempMap.put("times", key);
+      monthList.add(tempMap);
+    }
+
+    return monthList;
+  }
+
+
+  public List<Map<String, Object>> getYearData(List<EnvironmentalDataOne> environmentalDataList, List<EquipmentAttribute> equipmentAttributes, List<Map<String, Object>> yearList) {
+    Map<String, List<EnvironmentalDataOne>> yearAfterFormatting = null;
+    //提取年统计数据
+    List<Map<String, EnvironmentalDataOne>> yearBeforeFormatting = new ArrayList<>();
+    for (EnvironmentalDataOne n : environmentalDataList) {
+      Map<String, EnvironmentalDataOne> map1 = new HashMap<>();
+      map1.put(DateFormatUtils.format(n.getStatisticalTime(), "yyyy"), n);
+      yearBeforeFormatting.add(map1);
+      yearAfterFormatting = yearBeforeFormatting.stream().flatMap(m -> m.entrySet().stream()).collect(Collectors.groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, Collectors.toList())));
+    }
+    Map<String, List<EnvironmentalDataOne>> yearResultMap = new LinkedHashMap<>();
+    yearAfterFormatting.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEachOrdered(e -> yearResultMap.put(e.getKey(), e.getValue()));
+    for (String key : yearResultMap.keySet()) {
+      Map<String, Object> tempMap = new HashMap<>();
+      List<EnvironmentalDataOne> n = yearResultMap.get(key);
+
+      for (EquipmentAttribute equipmentAttribute : equipmentAttributes) {
+        String nFieldName = equipmentAttribute.getEquipmentType().toString() + equipmentAttribute.getFieldName();
+        String explanation = equipmentAttribute.getExplanation();
+        List<EnvironmentalDataOne> environmentalDatass = new ArrayList<>();
+        for (EnvironmentalDataOne environmentalData : n) {
+          if (environmentalData.getEquipmentAttribute().equals(equipmentAttribute)) {
+            environmentalDatass.add(environmentalData);
+          }
+        }
+        if (!environmentalDatass.isEmpty()) {
+          if (nFieldName.equals("WEATHERSTATIONglobalRDA") || nFieldName.equals("WEATHERSTATIONdirectRDA") || nFieldName.equals("WEATHERSTATIONdiffuseRDA") || nFieldName.equals("WEATHERSTATIONobliqueRDA") || nFieldName.equals("WEATHERSTATIONhourDA") || explanation.equals("日站外受阻电量") || explanation.equals("日站内受阻电量") || explanation.equals("日受阻电量")) {
+            //
+            Map<String, List<EnvironmentalDataOne>> afterFormattingDay = null;
+
+            List<Map<String, EnvironmentalDataOne>> beforeFormattingDay = new ArrayList<>();
+            //提取日统计数据
+            for (EnvironmentalDataOne nDay : environmentalDatass) {
+              Map<String, EnvironmentalDataOne> map1 = new HashMap<>();
+              map1.put(DateFormatUtils.format(nDay.getStatisticalTime(), "yyyyMMdd"), nDay);
+              beforeFormattingDay.add(map1);
+              afterFormattingDay = beforeFormattingDay.stream().flatMap(m -> m.entrySet().stream()).collect(Collectors.groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, Collectors.toList())));
+            }
+            Map<String, List<EnvironmentalDataOne>> resultMapDay = new LinkedHashMap<>();
+            afterFormattingDay.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEachOrdered(e -> resultMapDay.put(e.getKey(), e.getValue()));
+            List<EnvironmentalDataOne> listDay = new ArrayList<>();
+            for (String keyDay : resultMapDay.keySet()) {
+              List<EnvironmentalDataOne> nDay = resultMapDay.get(keyDay);
+              EnvironmentalDataOne maxEData = getEnvMax(nDay);
+              listDay.add(maxEData);
+            }
+            //
+            double sumValue = environmentalDatass.stream().filter(environmentalData -> environmentalData.getMaxValue() != null).collect(Collectors.toList()).stream().mapToDouble(environmentalData -> environmentalData.getMaxValue().doubleValue()).sum();
+            BigDecimal bSumValue = new BigDecimal(sumValue);
+            tempMap.put("sum" + nFieldName, bSumValue.setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue());
+            double asDouble = getEnvAvg(listDay);
+
+            EnvironmentalDataOne maxEData = getEnvMax(listDay);
+            EnvironmentalDataOne minEData = getEnvMin(listDay);
+            tempMap = putVal(tempMap, equipmentAttribute, maxEData, minEData, asDouble);
+          } else {
+            EnvironmentalDataOne maxEData = getEnvMax(environmentalDatass);
+            EnvironmentalDataOne minEData = getEnvMin(environmentalDatass);
+            double asDouble = getEnvAvg(environmentalDatass);
+            tempMap = putVal(tempMap, equipmentAttribute, maxEData, minEData, asDouble);
+          }
+        } else {
+          tempMap = putNoThing(tempMap, equipmentAttribute);
+          if (nFieldName.equals("WEATHERSTATIONglobalRDA") || nFieldName.equals("WEATHERSTATIONdirectRDA") || nFieldName.equals("WEATHERSTATIONdiffuseRDA") || nFieldName.equals("WEATHERSTATIONobliqueRDA") || nFieldName.equals("WEATHERSTATIONhourDA") || explanation.equals("日站外受阻电量") || explanation.equals("日站内受阻电量") || explanation.equals("日受阻电量")) {
+            tempMap.put("sum" + nFieldName, "");
+          }
+        }
+      }
+      tempMap.put("times", key);
+      yearList.add(tempMap);
+    }
+
+    return yearList;
+  }
+
+
+  public Map<String, Object> getFootData(Map<String, Object> footMap, List<EquipmentAttribute> equipmentAttributes, List<EnvironmentalDataOne> environmentalDataList) {
+    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+    //提取表格底部统计数据
+    for (EquipmentAttribute equipmentAttribute : equipmentAttributes) {
+      String nFieldName = equipmentAttribute.getEquipmentType().toString() + equipmentAttribute.getFieldName();
+      String explanation = equipmentAttribute.getExplanation();
+      List<EnvironmentalDataOne> environmentalDatass = new ArrayList<>();
+      for (EnvironmentalDataOne environmentalData : environmentalDataList) {
+        if (environmentalData.getEquipmentAttribute().equals(equipmentAttribute)) {
+          environmentalDatass.add(environmentalData);
+        }
+      }
+      if (!environmentalDatass.isEmpty()) {
+        if (nFieldName.equals("WEATHERSTATIONglobalRDA") || nFieldName.equals("WEATHERSTATIONdirectRDA") || nFieldName.equals("WEATHERSTATIONdiffuseRDA") || nFieldName.equals("WEATHERSTATIONobliqueRDA") || nFieldName.equals("WEATHERSTATIONhourDA") || explanation.equals("日站外受阻电量") || explanation.equals("日站内受阻电量") || explanation.equals("日受阻电量")) {
+          Map<String, List<EnvironmentalDataOne>> afterFormattingDay = null;
+
+          List<Map<String, EnvironmentalDataOne>> beforeFormattingDay = new ArrayList<>();
+          //提取日统计数据
+          for (EnvironmentalDataOne nDay : environmentalDatass) {
+            Map<String, EnvironmentalDataOne> map1 = new HashMap<>();
+            map1.put(DateFormatUtils.format(nDay.getStatisticalTime(), "yyyyMMdd"), nDay);
+            beforeFormattingDay.add(map1);
+            afterFormattingDay = beforeFormattingDay.stream().flatMap(m -> m.entrySet().stream()).collect(Collectors.groupingBy(Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, Collectors.toList())));
+          }
+          Map<String, List<EnvironmentalDataOne>> resultMapDay = new LinkedHashMap<>();
+          afterFormattingDay.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEachOrdered(e -> resultMapDay.put(e.getKey(), e.getValue()));
+          List<EnvironmentalDataOne> listDay = new ArrayList<>();
+          for (String keyDay : resultMapDay.keySet()) {
+            List<EnvironmentalDataOne> nDay = resultMapDay.get(keyDay);
+            EnvironmentalDataOne maxEData = getEnvMax(nDay);
+            listDay.add(maxEData);
+          }
+          //
+          double sumValue = environmentalDatass.stream().filter(environmentalData -> environmentalData.getMaxValue() != null).collect(Collectors.toList()).stream().mapToDouble(environmentalData -> environmentalData.getMaxValue().doubleValue()).sum();
+          BigDecimal bSumValue = new BigDecimal(sumValue);
+          footMap.put("sum" + nFieldName, bSumValue.setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue());
+          double asDouble = getEnvAvg(listDay);
+          footMap.put("avg" + nFieldName, asDouble == -99 ? "" : new BigDecimal(asDouble).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue());
+          EnvironmentalDataOne maxEData = getEnvMax(listDay);
+          EnvironmentalDataOne minEData = getEnvMin(listDay);
+          footMap.put("maxAvgValue" + nFieldName, maxEData.getMaxAvgValue() == null ? "" : maxEData.getMaxAvgValue());
+          footMap.put("max" + nFieldName, maxEData.getMaxValue() == null ? "" : maxEData.getMaxValue());
+          footMap.put("maxTime" + nFieldName, maxEData.getMaxValueTime() == null ? "" : sdf.format(maxEData.getMaxValueTime()));
+          footMap.put("min" + nFieldName, minEData.getMinValue() == null ? "" : minEData.getMinValue());
+          footMap.put("minTime" + nFieldName, maxEData.getMinValueTime() == null ? "" : sdf.format(minEData.getMinValueTime()));
+        } else {
+          EnvironmentalDataOne maxEData = getEnvMax(environmentalDatass);
+          EnvironmentalDataOne minEData = getEnvMin(environmentalDatass);
+          double asDouble = getEnvAvg(environmentalDatass);
+
+          footMap.put("maxAvgValue" + nFieldName, maxEData.getMaxAvgValue() == null ? "" : maxEData.getMaxAvgValue());
+          footMap.put("max" + nFieldName, maxEData.getMaxValue() == null ? "" : maxEData.getMaxValue());
+          footMap.put("maxTime" + nFieldName, maxEData.getMaxValueTime() == null ? "" : sdf.format(maxEData.getMaxValueTime()));
+          footMap.put("min" + nFieldName, minEData.getMinValue() == null ? "" : minEData.getMinValue());
+          footMap.put("minTime" + nFieldName, minEData.getMinValueTime() == null ? "" : sdf.format(minEData.getMinValueTime()));
+          footMap.put("avg" + nFieldName, asDouble == -99 ? "" : new BigDecimal(asDouble).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue());
+        }
+      } else {
+        footMap = putNoThing(footMap, equipmentAttribute);
+        if (nFieldName.equals("WEATHERSTATIONglobalRDA") || nFieldName.equals("WEATHERSTATIONdirectRDA") || nFieldName.equals("WEATHERSTATIONdiffuseRDA") || nFieldName.equals("WEATHERSTATIONobliqueRDA") || nFieldName.equals("WEATHERSTATIONhourDA") || explanation.equals("日站外受阻电量") || explanation.equals("日站内受阻电量") || explanation.equals("日受阻电量")) {
+          footMap.put("sum" + nFieldName, "");
+        }
+      }
+    }
+    return footMap;
+  }
+
+
+  public List<Map<String, Object>> getTableColumn(List<EquipmentAttribute> equipmentAttributes) {
+    //按照数据类型分配表头名以及查询数据
+    List<Map<String, Object>> tableColumn = new ArrayList<>();
+    //提取表格数据项名称
+    for (EquipmentAttribute equipmentAttribute : equipmentAttributes) {
+      String nFieldName = equipmentAttribute.getEquipmentType().toString() + equipmentAttribute.getFieldName();
+      String explanation = equipmentAttribute.getExplanation();
+      Map<String, Object> fieldMap = new HashMap<>();
+      fieldMap.put("title", equipmentAttribute.getExplanation());
+      fieldMap.put("unit", equipmentAttribute.getMeasurementUnits());
+      fieldMap.put("max", "max" + nFieldName);
+      fieldMap.put("min", "min" + nFieldName);
+      fieldMap.put("avg", "avg" + nFieldName);
+      fieldMap.put("maxTime", "maxTime" + nFieldName);
+      fieldMap.put("minTime", "minTime" + nFieldName);
+      fieldMap.put("maxAvgValue", "maxAvgValue" + nFieldName);
+      //因为总辐射日累计，直辐射日累计，散射辐射日累计，斜面辐射日累计，日照小时数需要计算统计值，所以加if判断处理
+      if (nFieldName.equals("WEATHERSTATIONglobalRDA") || nFieldName.equals("WEATHERSTATIONdirectRDA") || nFieldName.equals("WEATHERSTATIONdiffuseRDA") || nFieldName.equals("WEATHERSTATIONobliqueRDA") || nFieldName.equals("WEATHERSTATIONhourDA") || explanation.equals("日站外受阻电量") || explanation.equals("日站内受阻电量") || explanation.equals("日受阻电量")) {
+        fieldMap.put("sum", "sum" + nFieldName);
+      }
+      tableColumn.add(fieldMap);
+    }
+    return tableColumn;
+  }
+}

ipfcst/ipfcst-reportquery/src/main/java/com/jiayue/ipfcst/service/EnvironmentalDataService.java

@@ -163,17 +163,10 @@ public class EnvironmentalDataService extends BaseService {
   }
 
   public List<EquipmentAttribute> getEqAttributeById(Integer eqId) {
-    ElectricField electricField = electricFieldRepository.findAll().get(0);
     List<EquipmentAttribute> equipmentAttributes;
     EquipmentTypeEnum equipmentTypeEnum;
-    Integer code = electricField.getElectricFieldTypeEnum().getCode();
-    if (code == 1) {
-      //获取气象站的数据类型集合
-      equipmentTypeEnum = EquipmentTypeEnum.WEATHERSTATION;
-    } else {
-      //获取测风塔的数据类型集合
-      equipmentTypeEnum = EquipmentTypeEnum.WINDTOWER;
-    }
+    //获取气象站的数据类型集合
+    equipmentTypeEnum = EquipmentTypeEnum.WEATHERSTATION;
     equipmentAttributes = equipmentAttributeRepository.findByEquipmentTypeOrEquipmentType(equipmentTypeEnum, EquipmentTypeEnum.POWERSTATION);
     //筛选设备对应的采集点表数据
     List<ProtocolGatherDataPoint> protocolGatherDataPointList = protocolGatherDataPointRepository.findByEquipmentIdOrEquipmentId(eqId, 0);