有功功率趋势BUG迭代

pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/constant/Param.java

@@ -1,9 +1,6 @@
 package com.njcn.device.pq.constant;
 
-
-import java.util.Arrays;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 /**
@@ -41,24 +38,19 @@ public interface Param {
      * put(name:表ele_epd_pqd中的名称,value:页面展示的指标名称)
      */
     Map<String,String> DATABSEMAP = new HashMap(){{
-        put("频率偏差","频率偏差");
         put("线电压偏差","电压偏差");
+        put("电压负序不平衡度","三相电压不平衡度");
+        put("相电压电压变动幅度","电压波动");
         put("相电压长时闪变","长时闪变");
-        //put("线电压总有效值","谐波电压");
+        put("电流负序不平衡度","电流不平衡度");
-        //put("电流总有效值","谐波电流");
-        //put("相电压总有效值","间谐波电压");
-        put("电压负序不平衡度","负序电压不平衡度");
-        put("电流负序不平衡度","负序电流");
-        put("总稳态指标","三相总有功功率");
-        put("相电压谐波总畸变率","电压总谐波畸变率");
     }};
 
     Map<String,String> UHARMMAP = new HashMap(){{
-        put("相电压谐波含有率序列","电压");
+        put("相电压谐波含有率序列","谐波电压");
     }};
 
     Map<String,String> IHARMMAP = new HashMap(){{
-        put("谐波电流有效值","电流");
+        put("谐波电流有效值","谐波电流");
     }};
 
     Map<String,String> INTERHARMONICMAP = new HashMap(){{

pqs-event/event-api/src/main/java/com/njcn/event/pojo/constant/Param.java

@@ -28,4 +28,21 @@ public interface Param {
     String END =" 23:59:59";
     String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
 
+
+    String voltageOffset = "电压偏差";
+
+    String vTimes = "谐波电压";
+
+    String iTimes = "谐波电流";
+
+    String ubalance = "三相电压不平衡度";
+
+    String voltageFluctuation = "电压波动";
+
+    String flicker = "闪变";
+
+    String interHarmonic = "间谐波电压含有率";
+
+    String sequenceCurrentUnbalance = "电流不平衡度";
+
 }

pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/constant/Param.java

@@ -71,19 +71,4 @@ public interface Param {
 
     String DECIMAL_FORMATTWOSTR = "#.##";
 
-    String voltageOffset = "电压偏差";
-
-    String vTimes = "谐波电压";
-
-    String iTimes = "谐波电流";
-
-    String ubalance = "三相电压不平衡度";
-
-    String voltageFluctuation = "电压波动";
-
-    String flicker = "闪变";
-
-    String interHarmonic = "间谐波电压含有率";
-
-    String sequenceCurrentUnbalance = "电流不平衡度";
 }

pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/PowerStatisticsTargetVO.java

@@ -1,7 +1,5 @@
 package com.njcn.harmonic.pojo.vo;
 
-import com.alibaba.excel.annotation.ExcelProperty;
-import com.fasterxml.jackson.annotation.JsonFormat;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
 import java.util.ArrayList;
@@ -16,19 +14,15 @@ import java.util.List;
 public class PowerStatisticsTargetVO {
 
     @ApiModelProperty("时间")
-    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
     private String time;
 
     @ApiModelProperty("电压偏差")
-    @ExcelProperty(index =2,value = {"电压","B"})
     private Integer voltageOffset = 0;
 
     @ApiModelProperty("谐波电压")
-    @ExcelProperty(index =3,value = {"电压","C"})
     private Integer vTimes = 0;
 
     @ApiModelProperty("谐波电流")
-    @ExcelProperty(index =4,value = {"电流","A"})
     private Integer iTimes = 0;
 
     @ApiModelProperty("三相电压不平衡度")
@@ -46,9 +40,6 @@ public class PowerStatisticsTargetVO {
     @ApiModelProperty("电流不平衡度")
     private Integer sequenceCurrentUnbalance = 0;
 
-    @ApiModelProperty("区间字段(标识是哪个区间:10%~20%、20%~30%....)用于后端辅助计算")
-    private String field;
-
     @ApiModelProperty("电压偏差详情")
     private List<ThdDataVO> voltageOffsetList = new ArrayList<>();
 
@@ -73,58 +64,4 @@ public class PowerStatisticsTargetVO {
     @ApiModelProperty("电流不平衡度详情")
     private List<ThdDataVO> sequenceCurrentUnbalanceList = new ArrayList<>();
 
-    @ApiModelProperty("相别(用于后端辅助计算)")
-    private String phasicType;
-
-    @ApiModelProperty("统计方式(用于后端辅助计算)")
-    private String valueType;;
-
-    @ApiModelProperty("电压偏差国标限值(用于后端辅助计算)")
-    private Float voltageOffsetLimit;
-
-    @ApiModelProperty("谐波电压国标限值(用于后端辅助计算)")
-    private List<Float> vTimesLimit = new ArrayList<>();;
-
-    @ApiModelProperty("谐波电流国标限值(用于后端辅助计算)")
-    private List<Float> iTimesLimit = new ArrayList<>();;
-
-    @ApiModelProperty("三相电压不平衡度国标限值(用于后端辅助计算)")
-    private Float ubalanceLimit;
-
-    @ApiModelProperty("电压波动国标限值(用于后端辅助计算)")
-    private Float voltageFluctuationLimit;
-
-    @ApiModelProperty("闪变国标限值(用于后端辅助计算)")
-    private Float flickerLimit;
-
-    @ApiModelProperty("间谐波电压含有率国标限值(用于后端辅助计算)")
-    private List<Float> interHarmonicLimit = new ArrayList<>();;
-
-    @ApiModelProperty("电流不平衡度国标限值(用于后端辅助计算)")
-    private Float sequenceCurrentUnbalanceLimit;
-
-    @ApiModelProperty("电压偏差具体值(用于后端辅助计算)")
-    private Double voltageOffsetData;
-
-    @ApiModelProperty("谐波电压具体值(用于后端辅助计算)")
-    private List<Double> vTimesData = new ArrayList<>();;
-
-    @ApiModelProperty("谐波电流具体值(用于后端辅助计算)")
-    private List<Double> iTimesData = new ArrayList<>();;
-
-    @ApiModelProperty("三相电压不平衡度具体值(用于后端辅助计算)")
-    private Double ubalanceData;
-
-    @ApiModelProperty("电压波动具体值(用于后端辅助计算)")
-    private Double voltageFluctuationData;
-
-    @ApiModelProperty("闪变具体值(用于后端辅助计算)")
-    private Double flickerData;
-
-    @ApiModelProperty("间谐波电压含有率具体值(用于后端辅助计算)")
-    private List<Double> interHarmonicData = new ArrayList<>();
-
-    @ApiModelProperty("电流不平衡度具体值(用于后端辅助计算)")
-    private Double sequenceCurrentUnbalanceData;
-
 }

pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/ThdDataVO.java

@@ -1,5 +1,6 @@
 package com.njcn.harmonic.pojo.vo;
 
+import com.alibaba.excel.annotation.ExcelProperty;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
 
@@ -56,6 +57,9 @@ public class ThdDataVO {
     @ApiModelProperty("国标限值")
     private Float limit;
 
+    @ApiModelProperty("谐波次数")
+    private Integer frequency;
+
     @ApiModelProperty("时间")
     private String time;
 

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/PowerStatisticsServiceImpl.java

@@ -29,6 +29,7 @@ import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
+import java.lang.reflect.Field;
 import java.text.DecimalFormat;
 import java.util.*;
 import java.util.stream.Collectors;
@@ -71,6 +72,7 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService {
         //执行完就可以获取到区间数据了
         RActivePowerRangePO rActivePowerRangePO = rActivePowerRangeFeignClient.getDataByLineId(powerStatisticsParam.getLineId(),
                 powerStatisticsParam.getSearchBeginTime(),powerStatisticsParam.getSearchEndTime()).getData();
+        //如果的确没有统计到数据则默认
         if(rActivePowerRangePO == null){
             rActivePowerRangePO = new RActivePowerRangePO();
         }
@@ -98,253 +100,40 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService {
 
     @Override
     public List<PowerStatisticsTargetVO> getTargetLimitById(PowerStatisticsParam powerStatisticsParam) {
-        List<PowerStatisticsTargetVO> data = new ArrayList<>();
+        List<PowerStatisticsTargetVO> record = new ArrayList<>();
         RActivePowerRangeParam rActivePowerRangeParam = new RActivePowerRangeParam();
         BeanUtil.copyProperties(powerStatisticsParam, rActivePowerRangeParam);
         rActivePowerRangeParam.setSearch(true);
-        //重点说明:powerStatisticsTargetVO结构(维度)为:time可能多组相同,取决于功率表data_harmpower_p中的相别及统计方式,标识每个指标是否越限,总之一句话:每条数据当前时间中八个指标是否越限及他们的相别和统计方式是什么
+        RActivePowerRangePO rActivePowerRangePO = rActivePowerRangeFeignClient.getDataByLineId(powerStatisticsParam.getLineId(),
-        //基于record结构需要做维度的转换
+                powerStatisticsParam.getSearchBeginTime(),powerStatisticsParam.getSearchEndTime()).getData();
-        List<PowerStatisticsTargetVO> record = rActivePowerRangeFeignClient.record(rActivePowerRangeParam).getData();
+        if(rActivePowerRangePO != null){
-        //根据时间分组:
+            String times = reflexObjValue(rActivePowerRangePO,"minsTime"+powerStatisticsParam.getField()).toString().replace("null","");
-        Map<String,List<PowerStatisticsTargetVO>> map = record.stream().collect(Collectors.groupingBy(PowerStatisticsTargetVO::getTime));
+            rActivePowerRangeParam.setSearchTimeFort(false);
-        map.forEach((key, value) ->{
+            for(String se : times.split("&")){
-            PowerStatisticsTargetVO powerStatisticsTargetVO = new PowerStatisticsTargetVO();
+                String startTime = se.split(",")[0];
-            powerStatisticsTargetVO.setTime(key);
+                String endTime = se.split(",")[1];
-            powerStatisticsTargetVO.setField(powerStatisticsParam.getField());
+                rActivePowerRangeParam.setSearchBeginTime(startTime);
-            //各指标越限的相别及统计方式集合
+                rActivePowerRangeParam.setSearchEndTime(endTime);
-            List<Map<String,String>> pvs = new ArrayList<>();
+                record.addAll(rActivePowerRangeFeignClient.record(rActivePowerRangeParam).getData());
-            //遍历当前时间下的区间指标(注意:可能多组只是说统计方式和相别不同)
-            for(PowerStatisticsTargetVO vo : value){
-                //以下这些判断只要有一个指标越限了(不管是什么统计方式和相别)直接标识该指标越限(这些字段用于前端展示)
-                if(vo.getVoltageOffset().intValue() == 1) powerStatisticsTargetVO.setVoltageOffset(1);
-                if(vo.getVTimes().intValue() == 1) powerStatisticsTargetVO.setVTimes(1);
-                if(vo.getITimes().intValue() == 1) powerStatisticsTargetVO.setITimes(1);
-                if(vo.getUbalance().intValue() == 1) powerStatisticsTargetVO.setUbalance(1);
-                if(vo.getVoltageFluctuation().intValue() == 1) powerStatisticsTargetVO.setVoltageFluctuation(1);
-                if(vo.getFlicker().intValue() == 1) powerStatisticsTargetVO.setFlicker(1);
-                if(vo.getInterHarmonic().intValue() == 1) powerStatisticsTargetVO.setInterHarmonic(1);
-                if(vo.getSequenceCurrentUnbalance().intValue() == 1) powerStatisticsTargetVO.setSequenceCurrentUnbalance(1);
-                //以下逻辑用于前端点击指标时能看到指标具体的越限情况(比方说A相AVG越限了)
-                Map<String,String> pv = new HashMap<>();
-                pv.put(vo.getPhasicType(),vo.getValueType());
-                //除了带有谐波次数的指标需要特殊处理其他正常添加到pvs中
-                if(vo.getVoltageOffsetData()!=null) pv.put(Param.voltageOffset,df.format(vo.getVoltageOffsetData()));
-                if(vo.getUbalanceData()!=null) pv.put(Param.ubalance,df.format(vo.getUbalanceData()));
-                if(vo.getVoltageFluctuationData()!=null) pv.put(Param.voltageFluctuation,df.format(vo.getVoltageFluctuationData()));
-                if(vo.getFlickerData()!=null) pv.put(Param.flicker,df.format(vo.getFlickerData()));
-                if(vo.getSequenceCurrentUnbalanceData()!=null) pv.put(Param.sequenceCurrentUnbalance,df.format(vo.getSequenceCurrentUnbalanceData()));
-                pvs.add(pv);
-            }
-            powerStatisticsTargetVO.setVoltageOffsetList(initPV(pvs,Param.voltageOffset,value.get(0).getVoltageOffsetLimit()));
-            //谐波电压带有谐波次数需要特殊处理
-            powerStatisticsTargetVO.setVTimesList(initFrequencyPV(value,Param.vTimes,value.get(0).getVTimesLimit()));
-            //谐波电流带有谐波次数需要特殊处理
-            powerStatisticsTargetVO.setITimestList(initFrequencyPV(value,Param.iTimes,value.get(0).getITimesLimit()));
-            powerStatisticsTargetVO.setUbalanceList(initPV(pvs,Param.ubalance,value.get(0).getUbalanceLimit()));
-            powerStatisticsTargetVO.setVoltageFluctuationList(initPV(pvs,Param.voltageFluctuation,value.get(0).getVoltageFluctuationLimit()));
-            powerStatisticsTargetVO.setFlickerList(initPV(pvs,Param.flicker,value.get(0).getFlickerLimit()));
-            //间谐波电压含有率带有谐波次数需要特殊处理
-            powerStatisticsTargetVO.setInterHarmonicList(initFrequencyPV(value,Param.interHarmonic,value.get(0).getInterHarmonicLimit()));
-            powerStatisticsTargetVO.setSequenceCurrentUnbalanceList(initPV(pvs,Param.sequenceCurrentUnbalance,value.get(0).getSequenceCurrentUnbalanceLimit()));
-            powerStatisticsTargetVO.setVTimesList(formatFrequency(powerStatisticsTargetVO.getVTimesList()));
-            powerStatisticsTargetVO.setITimestList(formatFrequency(powerStatisticsTargetVO.getITimestList()));
-            powerStatisticsTargetVO.setInterHarmonicList(formatFrequency(powerStatisticsTargetVO.getInterHarmonicList()));
-            data.add(powerStatisticsTargetVO);
-        });
-
-        return data.stream().sorted(Comparator.comparing(PowerStatisticsTargetVO::getTime)).collect(Collectors.toList());
-    }
-
-    private List<ThdDataVO> formatFrequency(List<ThdDataVO> thdDataVOS){
-        List<ThdDataVO> data = new ArrayList<>();
-        for(ThdDataVO thdDataVO : thdDataVOS){
-            boolean isOk = false;
-            if(thdDataVO.getMINPhaseA()!= null && Float.parseFloat(thdDataVO.getMINPhaseA())>thdDataVO.getLimit()) isOk = true;
-            if(thdDataVO.getMINPhaseB()!= null && Float.parseFloat(thdDataVO.getMINPhaseB())>thdDataVO.getLimit()) isOk = true;
-            if(thdDataVO.getMINPhaseC()!= null && Float.parseFloat(thdDataVO.getMINPhaseC())>thdDataVO.getLimit()) isOk = true;
-            if(thdDataVO.getMAXPhaseA()!= null && Float.parseFloat(thdDataVO.getMAXPhaseA())>thdDataVO.getLimit()) isOk = true;
-            if(thdDataVO.getMAXPhaseB()!= null && Float.parseFloat(thdDataVO.getMAXPhaseB())>thdDataVO.getLimit()) isOk = true;
-            if(thdDataVO.getMAXPhaseC()!= null && Float.parseFloat(thdDataVO.getMAXPhaseC())>thdDataVO.getLimit()) isOk = true;
-            if(thdDataVO.getAVGPhaseA()!= null && Float.parseFloat(thdDataVO.getAVGPhaseA())>thdDataVO.getLimit()) isOk = true;
-            if(thdDataVO.getAVGPhaseB()!= null && Float.parseFloat(thdDataVO.getAVGPhaseB())>thdDataVO.getLimit()) isOk = true;
-            if(thdDataVO.getAVGPhaseC()!= null && Float.parseFloat(thdDataVO.getAVGPhaseC())>thdDataVO.getLimit()) isOk = true;
-            if(thdDataVO.getCP95PhaseA()!= null && Float.parseFloat(thdDataVO.getCP95PhaseA())>thdDataVO.getLimit()) isOk = true;
-            if(thdDataVO.getCP95PhaseB()!= null && Float.parseFloat(thdDataVO.getCP95PhaseB())>thdDataVO.getLimit()) isOk = true;
-            if(thdDataVO.getCP95PhaseC()!= null && Float.parseFloat(thdDataVO.getCP95PhaseC())>thdDataVO.getLimit()) isOk = true;
-            if(isOk){
-                data.add(thdDataVO);
             }
         }
-        return data;
+        return record.stream().sorted(Comparator.comparing(PowerStatisticsTargetVO::getTime)).collect(Collectors.toList());
+
     }
 
-    private List<ThdDataVO> initPV(List<Map<String,String>> pv, String name, Float limit){
+    //反射获取值
-        List<ThdDataVO> thdDataVOS = new ArrayList<>();
+    private Object reflexObjValue(Object obj, String fieldName) {
-        ThdDataVO tdv = new ThdDataVO();
+        try {
-        tdv.setAnotherName(name);
+            Class clazz = obj.getClass();
-        tdv.setLimit(limit);
+            Field field = clazz.getDeclaredField(fieldName);
-        //便利统计方式和相别集合渲染对应字段
+            field.setAccessible(true);
-        for(Map<String,String> arr :pv){
+            return field.get(obj);
-            arr.forEach((phasicType, valueType) ->{
+        } catch (Exception e) {
-                switch (valueType){
+            e.printStackTrace();
-                    case InfluxDBTableConstant.AVG:
-                        switch (phasicType){
-                            case InfluxDBTableConstant.PHASE_TYPE_A:
-                                tdv.setAVGPhaseA(arr.get(name));
-                                break;
-                            case InfluxDBTableConstant.PHASE_TYPE_B:
-                                tdv.setAVGPhaseB(arr.get(name));
-                                break;
-                            case InfluxDBTableConstant.PHASE_TYPE_C:
-                                tdv.setAVGPhaseC(arr.get(name));
-                                break;
-                        }
-                        break;
-                    case InfluxDBTableConstant.CP95:
-                        switch (phasicType){
-                            case InfluxDBTableConstant.PHASE_TYPE_A:
-                                tdv.setCP95PhaseA(arr.get(name));
-                                break;
-                            case InfluxDBTableConstant.PHASE_TYPE_B:
-                                tdv.setCP95PhaseB(arr.get(name));
-                                break;
-                            case InfluxDBTableConstant.PHASE_TYPE_C:
-                                tdv.setCP95PhaseC(arr.get(name));
-                                break;
-                        }
-                        break;
-                    case InfluxDBTableConstant.MIN:
-                        switch (phasicType){
-                            case InfluxDBTableConstant.PHASE_TYPE_A:
-                                tdv.setMINPhaseA(arr.get(name));
-                                break;
-                            case InfluxDBTableConstant.PHASE_TYPE_B:
-                                tdv.setMINPhaseB(arr.get(name));
-                                break;
-                            case InfluxDBTableConstant.PHASE_TYPE_C:
-                                tdv.setMINPhaseC(arr.get(name));
-                                break;
-                        }
-                        break;
-                    case InfluxDBTableConstant.MAX:
-                        switch (phasicType){
-                            case InfluxDBTableConstant.PHASE_TYPE_A:
-                                tdv.setMAXPhaseA(arr.get(name));
-                                break;
-                            case InfluxDBTableConstant.PHASE_TYPE_B:
-                                tdv.setMAXPhaseB(arr.get(name));
-                                break;
-                            case InfluxDBTableConstant.PHASE_TYPE_C:
-                                tdv.setMAXPhaseC(arr.get(name));
-                                break;
-                        }
-                        break;
-                }
-            });
-        }
-        //如果所有的相别和统计方式都没有值则可直接忽略该条数据
-        if(tdv.getAVGPhaseA() != null || tdv.getAVGPhaseB() != null
-                || tdv.getAVGPhaseC() != null || tdv.getCP95PhaseA() != null
-                || tdv.getCP95PhaseB() != null || tdv.getCP95PhaseC() != null
-                || tdv.getMINPhaseA() != null || tdv.getMINPhaseB() != null
-                || tdv.getMINPhaseC() != null || tdv.getMAXPhaseA() != null
-                || tdv.getMAXPhaseB() != null || tdv.getMAXPhaseC() != null){
-            thdDataVOS.add(tdv);
-        }
-        return thdDataVOS;
-    }
-
-    private List<Double> getFrequencyData(List<PowerStatisticsTargetVO> pv,String valueType,String phasicType,String name){
-        //根据不同的相别及统计方式分别获取该时间组下区间指标集合的具体值
-        List<PowerStatisticsTargetVO> data = pv.stream().filter(param->phasicType.equals(param.getPhasicType()) && valueType.equals(param.getValueType())).collect(Collectors.toList());
-        if(!data.isEmpty()){
-            switch (name){
-                case Param.vTimes:
-                    return data.get(0).getVTimesData();
-                case Param.iTimes:
-                    return data.get(0).getITimesData();
-                case Param.interHarmonic:
-                    return data.get(0).getInterHarmonicData();
-            }
         }
         return null;
     }
 
-    private String frequencyPVList(List<Double> data,int index){
-        try {
-            return df.format(data.get(index));
-        } catch (Exception e) {
-            return null;
-        }
-    }
-
-    private List<ThdDataVO> initFrequencyPV(List<PowerStatisticsTargetVO> pv, String name, List<Float> limit){
-        List<ThdDataVO> thdDataVOS = new ArrayList<>();
-        if(!limit.isEmpty()){
-            //根据不同的相别及统计方式分别获取该时间组下区间指标集合的具体值
-            List<Double> avgA = getFrequencyData(pv,InfluxDBTableConstant.AVG,InfluxDBTableConstant.PHASE_TYPE_A,name);
-            List<Double> avgB = getFrequencyData(pv,InfluxDBTableConstant.AVG,InfluxDBTableConstant.PHASE_TYPE_B,name);
-            List<Double> avgC = getFrequencyData(pv,InfluxDBTableConstant.AVG,InfluxDBTableConstant.PHASE_TYPE_C,name);
-            List<Double> cp94A = getFrequencyData(pv,InfluxDBTableConstant.CP95,InfluxDBTableConstant.PHASE_TYPE_A,name);
-            List<Double> cp94B = getFrequencyData(pv,InfluxDBTableConstant.CP95,InfluxDBTableConstant.PHASE_TYPE_B,name);
-            List<Double> cp94C = getFrequencyData(pv,InfluxDBTableConstant.CP95,InfluxDBTableConstant.PHASE_TYPE_C,name);
-            List<Double> minA = getFrequencyData(pv,InfluxDBTableConstant.MIN,InfluxDBTableConstant.PHASE_TYPE_A,name);
-            List<Double> minB = getFrequencyData(pv,InfluxDBTableConstant.MIN,InfluxDBTableConstant.PHASE_TYPE_B,name);
-            List<Double> minC = getFrequencyData(pv,InfluxDBTableConstant.MIN,InfluxDBTableConstant.PHASE_TYPE_C,name);
-            List<Double> maxA = getFrequencyData(pv,InfluxDBTableConstant.MAX,InfluxDBTableConstant.PHASE_TYPE_A,name);
-            List<Double> maxB = getFrequencyData(pv,InfluxDBTableConstant.MAX,InfluxDBTableConstant.PHASE_TYPE_B,name);
-            List<Double> maxC = getFrequencyData(pv,InfluxDBTableConstant.MAX,InfluxDBTableConstant.PHASE_TYPE_C,name);
-            int k = 0,j = 0;
-            double c = 0;
-            switch (name){
-                //谐波电压和电流默认谐波次数2-25
-                case Param.vTimes:
-                case Param.iTimes:
-                    k = 2;
-                    j = 25;
-                    break;
-                    //间谐波电压含有率默认谐波次数1-16
-                case Param.interHarmonic:
-                    k = 1;
-                    j = 16;
-                    c = 0.5;
-                    break;
-            }
-            for (int i = k; i <= j; i++) {
-                ThdDataVO tdv = new ThdDataVO();
-                tdv.setAnotherName(name +(((i-c)+"").replace(".0",""))+"次");
-                try {
-                    tdv.setLimit(limit.get(i-k));
-                    //frequencyPVList次方法提提高容灾,如果真的出现数组越界只有一种情况:有些有功功率查不到对应的某些指标数据
-                    tdv.setAVGPhaseA(frequencyPVList(avgA,i-k));
-                    tdv.setAVGPhaseB(frequencyPVList(avgB,i-k));
-                    tdv.setAVGPhaseC(frequencyPVList(avgC,i-k));
-                    tdv.setCP95PhaseA(frequencyPVList(cp94A,i-k));
-                    tdv.setCP95PhaseB(frequencyPVList(cp94B,i-k));
-                    tdv.setCP95PhaseC(frequencyPVList(cp94C,i-k));
-                    tdv.setMINPhaseA(frequencyPVList(minA,i-k));
-                    tdv.setMINPhaseB(frequencyPVList(minB,i-k));
-                    tdv.setMINPhaseC(frequencyPVList(minC,i-k));
-                    tdv.setMAXPhaseA(frequencyPVList(maxA,i-k));
-                    tdv.setMAXPhaseB(frequencyPVList(maxB,i-k));
-                    tdv.setMAXPhaseC(frequencyPVList(maxC,i-k));
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-                //如果所有的相别和统计方式都没有值则可直接忽略该条数据
-                if(tdv.getAVGPhaseA() != null || tdv.getAVGPhaseB() != null
-                        || tdv.getAVGPhaseC() != null || tdv.getCP95PhaseA() != null
-                        || tdv.getCP95PhaseB() != null || tdv.getCP95PhaseC() != null
-                        || tdv.getMINPhaseA() != null || tdv.getMINPhaseB() != null
-                        || tdv.getMINPhaseC() != null || tdv.getMAXPhaseA() != null
-                        || tdv.getMAXPhaseB() != null || tdv.getMAXPhaseC() != null){
-                    thdDataVOS.add(tdv);
-                }
-            }
-        }
-        return thdDataVOS;
-    }
-
     @Override
     public List<ThdDataVO> getTargetByTime(PowerStatisticsParam powerStatisticsParam) {
         List<ThdDataVO> result = new ArrayList();

pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/param/RActivePowerRangeParam.java

@@ -53,4 +53,11 @@ public class RActivePowerRangeParam extends BaseParam {
     @ApiModelProperty("查询时是否统计数据(默认不统计)")
     private boolean searchForAdd = false;
 
+    /**
+     * search = true 该参数才有效
+     * 查询时是否格式化时间
+     */
+    @ApiModelProperty("查询时是否格式化时间(默认需要格式化)")
+    private boolean searchTimeFort = true;
+
 }

pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/po/RActivePowerRangePO.java

@@ -34,7 +34,7 @@ public class RActivePowerRangePO extends BaseEntity {
     /**
      * 0%~10%区间时间Json
      */
-    private String minsTime0 = "{}";
+    private String minsTime0;
 
     /**
      * 0%~10%区间个数
@@ -49,7 +49,7 @@ public class RActivePowerRangePO extends BaseEntity {
     /**
      * 10%~20%区间时间Json
      */
-    private String minsTime1 = "{}";;
+    private String minsTime1;
 
     /**
      * 10%~20%区间个数
@@ -64,7 +64,7 @@ public class RActivePowerRangePO extends BaseEntity {
     /**
      * 20%~30%区间时间Json
      */
-    private String minsTime2 = "{}";;
+    private String minsTime2;
 
     /**
      * 20%~30%区间个数
@@ -79,7 +79,7 @@ public class RActivePowerRangePO extends BaseEntity {
     /**
      * 30%~40%区间时间Json
      */
-    private String minsTime3 = "{}";;
+    private String minsTime3;
 
     /**
      * 30%~40%区间个数
@@ -94,7 +94,7 @@ public class RActivePowerRangePO extends BaseEntity {
     /**
      * 40%~50%区间时间Json
      */
-    private String minsTime4 = "{}";;
+    private String minsTime4;
 
     /**
      * 40%~50%区间个数
@@ -109,7 +109,7 @@ public class RActivePowerRangePO extends BaseEntity {
     /**
      * 50%~60%区间时间Json
      */
-    private String minsTime5 = "{}";;
+    private String minsTime5;
 
     /**
      * 50%~60%区间个数
@@ -124,7 +124,7 @@ public class RActivePowerRangePO extends BaseEntity {
     /**
      * 60%~70%区间时间Json
      */
-    private String minsTime6 = "{}";;
+    private String minsTime6;
 
     /**
      * 60%~70%区间个数
@@ -139,7 +139,7 @@ public class RActivePowerRangePO extends BaseEntity {
     /**
      * 70%~80%区间时间Json
      */
-    private String minsTime7 = "{}";;
+    private String minsTime7;
 
     /**
      * 70%~80%区间个数
@@ -154,7 +154,7 @@ public class RActivePowerRangePO extends BaseEntity {
     /**
      * 80%~90%区间时间Json
      */
-    private String minsTime8 = "{}";;
+    private String minsTime8;
 
     /**
      * 80%~90%区间个数
@@ -169,7 +169,7 @@ public class RActivePowerRangePO extends BaseEntity {
     /**
      * 90%~100%区间时间Json
      */
-    private String minsTime9 = "{}";;
+    private String minsTime9;
 
     /**
      * 90%~100%区间个数

pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/event/RActivePowerRangeServiceImpl.java

@@ -12,6 +12,7 @@ import com.njcn.device.pq.api.OverLimitClient;
 import com.njcn.device.pq.pojo.po.NewStation;
 import com.njcn.event.pojo.constant.Param;
 import com.njcn.harmonic.pojo.vo.PowerStatisticsTargetVO;
+import com.njcn.harmonic.pojo.vo.ThdDataVO;
 import com.njcn.influx.pojo.bo.CommonQueryParam;
 import com.njcn.influx.pojo.constant.InfluxDBTableConstant;
 import com.njcn.influx.pojo.dto.StatisticalDataDTO;
@@ -25,15 +26,19 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import java.lang.reflect.Field;
+import java.text.DecimalFormat;
 import java.text.SimpleDateFormat;
+import java.time.Instant;
 import java.time.LocalDate;
 import java.time.ZoneId;
 import java.time.format.DateTimeFormatter;
 import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.stream.Collectors;
 
 /**
  * 有功功率趋势 服务实现类
+ *
  * @author guofeihu
  * @since 2024-08-22
  */
@@ -44,6 +49,18 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl<RActivePowerRan
 
     private final CommonService commonService;
 
+    private final IDataVService iDataVService;
+
+    private final IDataIService iDataIService;
+
+    private final DataPltService dataPltService;
+
+    private final DataInHarmVService dataInHarmVService;
+
+    private final DataHarmRateVService dataHarmRateVService;
+
+    private final DataFlucService dataFlucService;
+
     private final CommLineClient commLineClient;
 
     private final NewStationClient newStationClient;
@@ -52,9 +69,11 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl<RActivePowerRan
 
     private DateTimeFormatter formatter = DateTimeFormatter.ofPattern(Param.DATE_FORMAT);
 
+    private final DecimalFormat df = new DecimalFormat(com.njcn.harmonic.constant.Param.DECIMAL_FORMATSTR);
+
     private SimpleDateFormat sdf = new SimpleDateFormat(Param.DATE_FORMAT);
 
-    private List<String> PHASE = Arrays.asList(InfluxDBTableConstant.PHASE_TYPE_A,InfluxDBTableConstant.PHASE_TYPE_B,InfluxDBTableConstant.PHASE_TYPE_C);
+    private List<String> PHASE = Arrays.asList(InfluxDBTableConstant.PHASE_TYPE_A, InfluxDBTableConstant.PHASE_TYPE_B, InfluxDBTableConstant.PHASE_TYPE_C);
 
     /**
      * 整个算法的业务逻辑:
@@ -64,398 +83,560 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl<RActivePowerRan
      * --------------------------------指标---------------------------------
      * 电压偏差	data_v	vu_dev	电压偏差	如果vu_dev>0,使用上偏差限值对比；如果vu_dev<0,使用下偏差限值对比
      * 谐波电压	data_v	v_thd	电压总谐波总谐波畸变率	有一个指标超标，则谐波电压超标
-     * 	data_harmrate_v	v2-v25	2-25次谐波电压含有率
+     * data_harmrate_v	v2-v25	2-25次谐波电压含有率
      * 谐波电流	data_i	i2-i25	2-25次谐波电流幅值	有一个指标超标，则谐波电压超标
      * 三相电压不平衡度	data_v	v_unbalance
      * 电压波动	data_fluc	fluc
      * 长时闪变	data_plt	plt
      * 间谐波电压含有率	data_inharm_v	v1-v16	0.5-15.5次间谐波电压含有率	有一个指标超标，则谐波电压超标
      * 电流不平衡度	data_i	i_unbalance	这个不确定，找宝哥确认下
+     *
      * @param rActivePowerRangeParam
      * @return
      */
     @Override
     @Transactional(rollbackFor = Exception.class)
     public List<PowerStatisticsTargetVO> record(RActivePowerRangeParam rActivePowerRangeParam) {
-        if(rActivePowerRangeParam == null){
+        if (rActivePowerRangeParam == null) {
             rActivePowerRangeParam = new RActivePowerRangeParam();
         }
         //返回的最终结果
         List<PowerStatisticsTargetVO> powerStatisticsTargetVOS = new ArrayList<>();
         //默认初始化开始和结束时间
-        String startTime = getTime(rActivePowerRangeParam.getInterval(),0);
+        String startTime = getTime(rActivePowerRangeParam.getInterval(), 0);
-        String endTime = getTime(rActivePowerRangeParam.getInterval(),1);
+        String endTime = getTime(rActivePowerRangeParam.getInterval(), 1);
         //获取时间段内的有功功率集合
         List<CommonQueryParam> commonQueryParams = new ArrayList<>();
         CommonQueryParam commonQueryParam = new CommonQueryParam();
         //控制参数中如果search为true,则获取有功功率集合的时间段内为BaseParam中的searchBeginTime和searchEndTime(用于前端有功功率查询页面相关接口)
-        if(rActivePowerRangeParam.isSearch()){
+        if (rActivePowerRangeParam.isSearch()) {
-            startTime = rActivePowerRangeParam.getSearchBeginTime()+Param.BEGIN;
+            if(rActivePowerRangeParam.isSearchTimeFort()){
-            endTime = rActivePowerRangeParam.getSearchEndTime()+Param.END;
+                startTime = rActivePowerRangeParam.getSearchBeginTime() + Param.BEGIN;
+                endTime = rActivePowerRangeParam.getSearchEndTime() + Param.END;
+            }else{
+                startTime = rActivePowerRangeParam.getSearchBeginTime();
+                endTime = rActivePowerRangeParam.getSearchEndTime();
+            }
             commonQueryParam.setLineId(rActivePowerRangeParam.getLineId());
         }
         //时间段
         commonQueryParam.setStartTime(startTime);
         commonQueryParam.setEndTime(endTime);
-        //临时模拟增加的条件(用于调试主要是数据量太大非常消耗时间) 2024-09-01 00:00:00
-//        commonQueryParam.setDataType("AVG");
-//        commonQueryParam.setPhasic("A");
-        commonQueryParam.setStartTime("2024-08-10 00:00:00");
-        commonQueryParam.setEndTime("2024-08-10 00:00:00");
-        //模拟增加的条件结束
         //功率表data_harmpower_p及字段p
         commonQueryParam.setTableName(InfluxDBTableConstant.DATA_HARM_POWER_P);
         commonQueryParam.setColumnName("p");
         commonQueryParams.add(commonQueryParam);
-        //这边没有设置他的统计方式和相别是因为根据有功功率查询各个指标的时候要把所有的指标和统计方式都查出来一一比较
+        //查询功率表(多个统计方式及相别)
         List<StatisticalDataDTO> dataHarmPowerPS = commonService.getNewDeviceRtDataByTime(commonQueryParams);
         //由于前端写死了各个指标的相别(只有A、B、C所以这边直接限制死了)
-        dataHarmPowerPS = dataHarmPowerPS.stream().filter(param->PHASE.contains(param.getPhaseType())).collect(Collectors.toList());
+        dataHarmPowerPS = dataHarmPowerPS.stream().filter(param -> PHASE.contains(param.getPhaseType())).collect(Collectors.toList());
         //有功功率趋势表是按照监测点来划分的 所以这边需要根据监测点来分组
-        Map<String,List<StatisticalDataDTO>> map = dataHarmPowerPS.stream().collect(Collectors.groupingBy(StatisticalDataDTO::getLineId));
+        Map<String, List<StatisticalDataDTO>> lineMap = dataHarmPowerPS.stream().collect(Collectors.groupingBy(StatisticalDataDTO::getLineId));
         RActivePowerRangeParam finalRActivePowerRangeParam = rActivePowerRangeParam;
         //以下这段逻辑较耗时(主要是for循环),主要是要遍历所有的有功功率,在根据有功功率查询各个指标进行比较(最耗时的是有功功率查询各个指标,所以一但有功功率很多则遍历较慢)
-        log.info("当前遍历的功率根据监测点分组后长度为:{},集合总长为:{},现在开始遍历,{}",map.size(),dataHarmPowerPS.size(),sdf.format(new Date()));
+        log.info("当前遍历的功率根据监测点分组后长度为:{},集合总长为:{},现在开始遍历,{}", lineMap.size(), dataHarmPowerPS.size(), sdf.format(new Date()));
-        map.forEach((key, value) ->{
+        lineMap.forEach((lineId, lineGroupList) -> {
+            log.info("当前遍历的监测点ID为:{},监测点集合长为:{},现在开始遍历,{}", lineId, lineGroupList.size(), sdf.format(new Date()));
             //获取监测点的国标限值
-            List<Overlimit> overlimits = overLimitClient.getOverLimitByLineIds(Arrays.asList(key)).getData();
+            List<Overlimit> overlimits = overLimitClient.getOverLimitByLineIds(Arrays.asList(lineId)).getData();
             //该监测点必须要有国标限值
-            if(overlimits != null && !overlimits.isEmpty()){
+            if (overlimits != null && !overlimits.isEmpty()) {
                 Overlimit overlimit = overlimits.get(0);
                 //获取监测点
-                LineDTO lineDTO = commLineClient.getLineDetail(key).getData();
+                LineDTO lineDTO = commLineClient.getLineDetail(lineId).getData();
                 //监测点必须绑定新能源站
-                if(lineDTO != null && lineDTO.getNewStationId() != null){
+                if (lineDTO != null && lineDTO.getNewStationId() != null) {
                     //获取监测点的新能源站
                     NewStation newStation = newStationClient.selectById(lineDTO.getNewStationId()).getData();
                     //新能源站有些切必须是风电场
-                    if(newStation != null && com.njcn.device.pq.constant.Param.WINDFARM.equals(newStation.getStationType())){
+                    if (newStation != null && com.njcn.device.pq.constant.Param.WINDFARM.equals(newStation.getStationType())) {
                         RActivePowerRangePO rActivePowerRangePO = new RActivePowerRangePO();
-                        rActivePowerRangePO.setLineId(key);
+                        rActivePowerRangePO.setLineId(lineId);
                         rActivePowerRangePO.setTimeId(LocalDate.now());
                         rActivePowerRangePO.setId(IdUtil.simpleUUID());
                         LambdaQueryWrapper<RActivePowerRangePO> lambdaQueryWrapper = new LambdaQueryWrapper<>();
-                        lambdaQueryWrapper.eq(RActivePowerRangePO::getLineId,key).eq(RActivePowerRangePO::getTimeId,LocalDate.now());
+                        lambdaQueryWrapper.eq(RActivePowerRangePO::getLineId, lineId).eq(RActivePowerRangePO::getTimeId, LocalDate.now());
                         //控制参数-强制刷新
-                        if(finalRActivePowerRangeParam.isRefresh()){
+                        if (finalRActivePowerRangeParam.isRefresh()) {
                             this.baseMapper.delete(lambdaQueryWrapper);
                         }
-                        //控制参数-是否查询及查询新增(主要用于harmonic-boot-getDataByLineId方法,避免每次执行都会执行for循环,也即当日执行完一次即可)
+                        //控制参数-是否查询及查询新增(主要用于harmonic-boot-getDataByLineId方法,避免每次执行都会执行循环,也即当日执行完一次即可)
-                        if(!this.baseMapper.selectList(lambdaQueryWrapper).isEmpty() && (finalRActivePowerRangeParam.isSearch() && finalRActivePowerRangeParam.isSearchForAdd())){
+                        if (!this.baseMapper.selectList(lambdaQueryWrapper).isEmpty() && (finalRActivePowerRangeParam.isSearch() && finalRActivePowerRangeParam.isSearchForAdd())) {
                             return;
                         }
-                        int index = 1;
+                        //当前监测点的功率数据在根据时间分组然后取出一个时间分组内最大的值
-                        //耗时开始-计算各个区间个数及是否越限
+                        Map<Instant, List<StatisticalDataDTO>> timeMap = lineGroupList.stream().collect(Collectors.groupingBy(StatisticalDataDTO::getTime));
-                        for(StatisticalDataDTO statisticalDataDTO : value){
+                        timeMap.forEach((time, timeGroupList) -> {
-                            log.info("前监测点为:{},遍历第{}条...,现在开始遍历,{}",key,index,sdf.format(new Date()));
+                            //取出当前时间分组内最大的一个值来判断是否越界
+                            Optional<StatisticalDataDTO> optional = timeGroupList.stream().max(Comparator.comparingDouble(StatisticalDataDTO::getValue));
+                            StatisticalDataDTO statisticalDataDTO = optional.get();
                             PowerStatisticsTargetVO powerStatisticsTargetVO = new PowerStatisticsTargetVO();
                             //设置时间为当前功率的时间
                             powerStatisticsTargetVO.setTime(statisticalDataDTO.getTime().atZone(ZoneId.systemDefault()).format(formatter));
-                            powerStatisticsTargetVO.setTime("2024-08-10 00:00:00");
                             //当前功率的p字段 / 风电场额定功率
                             double temp = statisticalDataDTO.getValue() / Double.parseDouble(newStation.getRatedPower());
-                            //区间过滤下(用于前端查询)
+                            //区间过滤下(如果进去此判断 那么只能是查询某个区间下的指标越限列表)
-                            if(finalRActivePowerRangeParam.isSearch() && finalRActivePowerRangeParam.getField() != null){
+                            if (finalRActivePowerRangeParam.isSearch() && finalRActivePowerRangeParam.getField() != null) {
-                                if(Double.parseDouble(finalRActivePowerRangeParam.getField()) < temp * 10 &&  temp * 10 <= Double.parseDouble(finalRActivePowerRangeParam.getField())+1){
+                                if (Double.parseDouble(finalRActivePowerRangeParam.getField()) < temp * 10 && temp * 10 <= Double.parseDouble(finalRActivePowerRangeParam.getField()) + 1) {
-                                    //指标越限列表区间区分字段(用于前端查询)
+                                    //判断当前区间每个指标是否越限(根据type来区分设置到哪个区间对应的是否越限字段)
-                                    powerStatisticsTargetVO.setField(finalRActivePowerRangeParam.getField());
+                                    installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, Integer.parseInt(finalRActivePowerRangeParam.getField()), powerStatisticsTargetVO);
-                                    //判断每个指标是否越限(根据type来区分设置到哪个区间对应的是否越限字段)
-                                    installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,Integer.parseInt(finalRActivePowerRangeParam.getField()),powerStatisticsTargetVO);
                                     powerStatisticsTargetVOS.add(powerStatisticsTargetVO);
                                 }
-                                continue;
+                            } else {
+                                //否则是正常的定时任务插入,或者前端搜索插入
+                                //设置每个区间的统计时间
+                                rActivePowerRangePO.setMinsTime0(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime());
+                                rActivePowerRangePO.setMinsTime1(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime());
+                                rActivePowerRangePO.setMinsTime2(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime());
+                                rActivePowerRangePO.setMinsTime3(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime());
+                                rActivePowerRangePO.setMinsTime4(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime());
+                                rActivePowerRangePO.setMinsTime5(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime());
+                                rActivePowerRangePO.setMinsTime6(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime());
+                                rActivePowerRangePO.setMinsTime7(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime());
+                                rActivePowerRangePO.setMinsTime8(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime());
+                                rActivePowerRangePO.setMinsTime9(commonQueryParam.getStartTime()+","+commonQueryParam.getEndTime());
+                                if (temp <= 0.1) {
+                                    //占有率区间个数+1
+                                    rActivePowerRangePO.setMinsNum0(rActivePowerRangePO.getMinsNum0() + 1);
+                                    //判断当前区间每个指标是否越限
+                                    installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 0, powerStatisticsTargetVO);
+                                } else if (0.1 < temp && temp <= 0.2) {
+                                    rActivePowerRangePO.setMinsNum1(rActivePowerRangePO.getMinsNum1() + 1);
+                                    installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 1, powerStatisticsTargetVO);
+                                } else if (0.2 < temp && temp <= 0.3) {
+                                    rActivePowerRangePO.setMinsNum2(rActivePowerRangePO.getMinsNum2() + 1);
+                                    installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 2, powerStatisticsTargetVO);
+                                } else if (0.3 < temp && temp <= 0.4) {
+                                    rActivePowerRangePO.setMinsNum3(rActivePowerRangePO.getMinsNum3() + 1);
+                                    installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 3, powerStatisticsTargetVO);
+                                } else if (0.4 < temp && temp <= 0.5) {
+                                    rActivePowerRangePO.setMinsNum4(rActivePowerRangePO.getMinsNum4() + 1);
+                                    installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 4, powerStatisticsTargetVO);
+                                } else if (0.5 < temp && temp <= 0.6) {
+                                    rActivePowerRangePO.setMinsNum5(rActivePowerRangePO.getMinsNum5() + 1);
+                                    installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 5, powerStatisticsTargetVO);
+                                } else if (0.6 < temp && temp <= 0.7) {
+                                    rActivePowerRangePO.setMinsNum6(rActivePowerRangePO.getMinsNum6() + 1);
+                                    installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 6, powerStatisticsTargetVO);
+                                } else if (0.7 < temp && temp <= 0.8) {
+                                    rActivePowerRangePO.setMinsNum7(rActivePowerRangePO.getMinsNum7() + 1);
+                                    installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 7, powerStatisticsTargetVO);
+                                } else if (0.8 < temp && temp <= 0.9) {
+                                    rActivePowerRangePO.setMinsNum8(rActivePowerRangePO.getMinsNum8() + 1);
+                                    installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 8, powerStatisticsTargetVO);
+                                } else if (temp > 0.9) {
+                                    rActivePowerRangePO.setMinsNum9(rActivePowerRangePO.getMinsNum9() + 1);
+                                    installLimit(rActivePowerRangePO, statisticalDataDTO, overlimit, 9, powerStatisticsTargetVO);
+                                }
+                                powerStatisticsTargetVOS.add(powerStatisticsTargetVO);
                             }
-                            if(temp <= 0.1){
+                        });
-                                //占有率区间个数+1
-                                rActivePowerRangePO.setMinsNum0(rActivePowerRangePO.getMinsNum0() + 1);
-                                //指标越限列表区间区分字段(用于前端查询)
-                                powerStatisticsTargetVO.setField("0");
-                                //判断每个指标是否越限(根据type来区分设置到哪个区间对应的是否越限字段)
-                                installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,0,powerStatisticsTargetVO);
-                            }else if(0.1 < temp && temp <= 0.2){
-                                rActivePowerRangePO.setMinsNum1(rActivePowerRangePO.getMinsNum1() + 1);
-                                powerStatisticsTargetVO.setField("1");
-                                installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,1,powerStatisticsTargetVO);
-                            }else if(0.2 < temp && temp <= 0.3){
-                                rActivePowerRangePO.setMinsNum2(rActivePowerRangePO.getMinsNum2() + 1);
-                                powerStatisticsTargetVO.setField("2");
-                                installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,2,powerStatisticsTargetVO);
-                            }else if(0.3 < temp && temp <= 0.4){
-                                rActivePowerRangePO.setMinsNum3(rActivePowerRangePO.getMinsNum3() + 1);
-                                powerStatisticsTargetVO.setField("3");
-                                installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,3,powerStatisticsTargetVO);
-                            }else if(0.4 < temp && temp <= 0.5){
-                                rActivePowerRangePO.setMinsNum4(rActivePowerRangePO.getMinsNum4() + 1);
-                                powerStatisticsTargetVO.setField("4");
-                                installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,4,powerStatisticsTargetVO);
-                            }else if(0.5 < temp && temp <= 0.6){
-                                rActivePowerRangePO.setMinsNum5(rActivePowerRangePO.getMinsNum5() + 1);
-                                powerStatisticsTargetVO.setField("5");
-                                installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,5,powerStatisticsTargetVO);
-                            }else if(0.6 < temp && temp <= 0.7){
-                                rActivePowerRangePO.setMinsNum6(rActivePowerRangePO.getMinsNum6() + 1);
-                                powerStatisticsTargetVO.setField("6");
-                                installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,6,powerStatisticsTargetVO);
-                            }else if(0.7 < temp && temp <= 0.8){
-                                rActivePowerRangePO.setMinsNum7(rActivePowerRangePO.getMinsNum7() + 1);
-                                powerStatisticsTargetVO.setField("7");
-                                installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,7,powerStatisticsTargetVO);
-                            }else if(0.8 < temp && temp <= 0.9){
-                                rActivePowerRangePO.setMinsNum8(rActivePowerRangePO.getMinsNum8() + 1);
-                                powerStatisticsTargetVO.setField("8");
-                                installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,8,powerStatisticsTargetVO);
-                            }else if(temp > 0.9){
-                                rActivePowerRangePO.setMinsNum9(rActivePowerRangePO.getMinsNum9() + 1);
-                                powerStatisticsTargetVO.setField("9");
-                                installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,9,powerStatisticsTargetVO);
-                            }
-                            powerStatisticsTargetVOS.add(powerStatisticsTargetVO);
-                            log.info("前监测点为:{},遍历第{}条...,遍历结束,{}",key,index,sdf.format(new Date()));
-                            index++;
-                        }
                         //根据日期及lineId当天不能重复执行
-                        if(this.baseMapper.selectList(lambdaQueryWrapper).isEmpty() && (finalRActivePowerRangeParam.isSearch() && finalRActivePowerRangeParam.isSearchForAdd() || !finalRActivePowerRangeParam.isSearch())){
+                        if (this.baseMapper.selectList(lambdaQueryWrapper).isEmpty() && (finalRActivePowerRangeParam.isSearch() && finalRActivePowerRangeParam.isSearchForAdd() || !finalRActivePowerRangeParam.isSearch())) {
                             this.baseMapper.insert(rActivePowerRangePO);
                         }
                     }
                 }
             }
         });
-        log.info("当前遍历的功率根据监测点分组后长度为:{},集合总长为:{},遍历结束,{}",map.size(),dataHarmPowerPS.size(),sdf.format(new Date()));
+        log.info("当前遍历的功率根据监测点分组后长度为:{},集合总长为:{},遍历结束,{}", lineMap.size(), dataHarmPowerPS.size(), sdf.format(new Date()));
-        if(rActivePowerRangeParam.isSearch()){
+        if (rActivePowerRangeParam.isSearch()) {
-            //重点说明:powerStatisticsTargetVO结构(维度)为:time可能多组相同,取决于功率表data_harmpower_p中的相别及统计方式,标识每个指标是否越限,总之一句话:每条数据当前时间中八个指标是否越限及他们的相别和统计方式是什么
             return powerStatisticsTargetVOS;
         }
         return null;
     }
 
-    private void installLimit(RActivePowerRangePO rActivePowerRangePO,StatisticalDataDTO statisticalDataDTO,Overlimit overlimit,int type,PowerStatisticsTargetVO powerStatisticsTargetVO){
+    private void installLimit(RActivePowerRangePO rActivePowerRangePO, StatisticalDataDTO statisticalDataDTO, Overlimit overlimit, int type, PowerStatisticsTargetVO powerStatisticsTargetVO) {
-        //记录统计方式
+        //根据当前最大值的功率查询各个指标信息
-        powerStatisticsTargetVO.setValueType(statisticalDataDTO.getValueType());
-        //记录相别
-        powerStatisticsTargetVO.setPhasicType(statisticalDataDTO.getPhaseType());
-        //以下的结果集按道理最多只有一条(因为确定的相别统计方式及开始和结束时间都一致,除了有谐波次数的指标)
         //电压偏差
-        List<StatisticalDataDTO> vu_dev = commonQuery(InfluxDBTableConstant.DATA_V,"vu_dev",statisticalDataDTO,null,null);
+        List<StatisticalDataDTO> vu_dev = commonQuery(InfluxDBTableConstant.DATA_V, "vuDev", statisticalDataDTO, null, null);
         //谐波电压
-        List<StatisticalDataDTO> v_thd = commonQuery(InfluxDBTableConstant.DATA_V,"v_thd",statisticalDataDTO,null,null);
+        List<StatisticalDataDTO> v_thd = commonQuery(InfluxDBTableConstant.DATA_V, "vThd", statisticalDataDTO, null, null);
-        List<StatisticalDataDTO> v = commonQuery(InfluxDBTableConstant.DATA_HARM_RATE_V,"v",statisticalDataDTO,2,25);
+        List<StatisticalDataDTO> v = commonQuery(InfluxDBTableConstant.DATA_HARM_RATE_V, "v", statisticalDataDTO, 2, 25);
         //谐波电流
-        List<StatisticalDataDTO> i = commonQuery(InfluxDBTableConstant.DATA_I,"i",statisticalDataDTO,2,25);
+        List<StatisticalDataDTO> i = commonQuery(InfluxDBTableConstant.DATA_I, "i", statisticalDataDTO, 2, 25);
         //三相电压不平衡度
-        List<StatisticalDataDTO> v_unbalance = commonQuery(InfluxDBTableConstant.DATA_V,"v_unbalance",statisticalDataDTO,null,null);
+        List<StatisticalDataDTO> v_unbalance = commonQuery(InfluxDBTableConstant.DATA_V, "vUnbalance", statisticalDataDTO, null, null);
         //电压波动
-        List<StatisticalDataDTO> fluc = commonQuery(InfluxDBTableConstant.DATA_FLUC,"fluc",statisticalDataDTO,null,null);
+        List<StatisticalDataDTO> fluc = commonQuery(InfluxDBTableConstant.DATA_FLUC, "fluc", statisticalDataDTO, null, null);
         //长时闪变
-        List<StatisticalDataDTO> plt = commonQuery(InfluxDBTableConstant.DATA_PLT,"plt",statisticalDataDTO,null,null);
+        List<StatisticalDataDTO> plt = commonQuery(InfluxDBTableConstant.DATA_PLT, "plt", statisticalDataDTO, null, null);
         //间谐波电压含有率
-        List<StatisticalDataDTO> v1 = commonQuery(InfluxDBTableConstant.DATA_IN_HARM_V,"v",statisticalDataDTO,1,16);
+        List<StatisticalDataDTO> v1 = commonQuery(InfluxDBTableConstant.DATA_IN_HARM_V, "v", statisticalDataDTO, 1, 16);
         //电流不平衡度
-        List<StatisticalDataDTO> i_unbalance = commonQuery(InfluxDBTableConstant.DATA_I,"i_unbalance",statisticalDataDTO,null,null);
+        List<StatisticalDataDTO> i_unbalance = commonQuery(InfluxDBTableConstant.DATA_I, "iUnbalance", statisticalDataDTO, null, null);
-        //此标识用来记录当前区间下指标是否越限(0%~10%是否越限,10%~20%是否越限.....)
+        //此标识用来记录当前区间下指标是否越限
         boolean isLimit = false;
-        //电压偏差国标限值
+
-        powerStatisticsTargetVO.setVoltageOffsetLimit(overlimit.getVoltageDev());
+        //电压偏差是否越限比较(此指标比较较为特殊所以单独一个重载的判断方法)
-        //电压偏差是否越限比较
+        Float isVoltageOffsetLimit = isLimit(vu_dev, overlimit);
-        for(StatisticalDataDTO dto : vu_dev){
+        //电压偏差指标详细数据
-            //电压偏差具体值
+        powerStatisticsTargetVO.setVoltageOffsetList(toThdDataVO(vu_dev, Param.voltageOffset, null, isVoltageOffsetLimit));
-            powerStatisticsTargetVO.setVoltageOffsetData(dto.getValue());
+        if (isVoltageOffsetLimit != null) {
-            //电压偏差国标限值有额外的判断
+            isLimit = true;
-            if(dto.getValue()>0){
+            //电压偏差越限
-                powerStatisticsTargetVO.setVoltageOffsetLimit(overlimit.getVoltageDev());
+            powerStatisticsTargetVO.setVoltageOffset(1);
-            }else{
-                powerStatisticsTargetVO.setVoltageOffsetLimit(overlimit.getUvoltageDev());
-            }
-            //如果vu_dev>0,使用上偏差限值对比；如果vu_dev<0,使用下偏差限值对比
-            if((dto.getValue()>0 && Double.compare(dto.getValue(),overlimit.getVoltageDev())>0)
-                || (dto.getValue()<0 && Double.compare(dto.getValue(),overlimit.getUvoltageDev())>0)){
-                isLimit = true;
-                //标志电压偏差越限
-                powerStatisticsTargetVO.setVoltageOffset(1);
-            }
         }
-        //谐波电压比较较为特殊需要比较两个点(以v为主)
+
-        //谐波电压是否越限比较
+        //谐波电压比较较为特殊需要比较两个点
-        for(StatisticalDataDTO dto : v_thd){
+        //谐波电压指标详细数据
-            if(Double.compare(dto.getValue(),overlimit.getUaberrance())>0){
+        powerStatisticsTargetVO.setVTimesList(toThdDataVO(v, Param.vTimes, overlimit, null));
-                isLimit = true;
+        //谐波电压是否越限比较(不过指标详细数据还是取data_harmrate_v表里的数据)
-                powerStatisticsTargetVO.setVTimes(1);
+        if (isLimit(v, Param.vTimes, InfluxDBTableConstant.CP95, overlimit, null)) {
-            }
+            isLimit = true;
+            //谐波电流越限
+            powerStatisticsTargetVO.setVTimes(1);
         }
-        int num = 2;
+        if (isLimit(v_thd, Param.vTimes, InfluxDBTableConstant.CP95, null, overlimit.getUaberrance())) {
-        for(StatisticalDataDTO dto : v){
+            isLimit = true;
-            Float value = frequencyValue(overlimit,num,"uharm");
+            //谐波电流越限
-            if(value != null){
+            powerStatisticsTargetVO.setVTimes(1);
-                //记录谐波电压2到25次国标限值(当然这里还是要以influxDb里为主,虽然当前遍历的集合明确查询2-25次但是为了防止influxDb可能缺失一些次数的数据,所以国标限值次数跟着influxDb走)
-                powerStatisticsTargetVO.getVTimesLimit().add(value);
-                //谐波电压具体值
-                powerStatisticsTargetVO.getVTimesData().add(dto.getValue());
-                if(Double.compare(dto.getValue(),value)>0){
-                    isLimit = true;
-                    //标志谐波电压越限
-                    powerStatisticsTargetVO.setVTimes(1);
-                }
-            }
-            num++;
         }
-        num = 2;
+
+        //谐波电流指标详细数据
+        powerStatisticsTargetVO.setITimestList(toThdDataVO(i, Param.iTimes, overlimit, null));
         //谐波电流是否越限比较
-        for(StatisticalDataDTO dto : i){
+        if (isLimit(i, Param.vTimes, InfluxDBTableConstant.CP95, overlimit, null)) {
-            Float value = frequencyValue(overlimit,num,"iharm");
+            isLimit = true;
-            if(value != null){
+            //谐波电流越限
-                //记录谐波电流2到25次国标限值(当然这里还是要以influxDb里为主,虽然当前遍历的集合明确查询2-25次但是为了防止influxDb可能缺失一些次数的数据,所以国标限值次数跟着influxDb走)
+            powerStatisticsTargetVO.setITimes(1);
-                powerStatisticsTargetVO.getITimesLimit().add(value);
-                //谐波电流具体值
-                powerStatisticsTargetVO.getITimesData().add(dto.getValue());
-                if(Double.compare(dto.getValue(),value)>0){
-                    isLimit = true;
-                    //标志谐波电流越限
-                    powerStatisticsTargetVO.setITimes(1);
-                }
-            }
-            num++;
         }
-        //三相电压不平衡度国标限值
+
-        powerStatisticsTargetVO.setUbalanceLimit(overlimit.getUbalance());
+        //三相电压不平衡度指标详细数据
+        powerStatisticsTargetVO.setUbalanceList(toThdDataVO(v_unbalance, Param.ubalance, null, overlimit.getUbalance()));
         //三相电压不平衡度是否越限比较
-        for(StatisticalDataDTO dto : v_unbalance){
+        if (isLimit(v_unbalance, Param.ubalance, InfluxDBTableConstant.CP95, null, overlimit.getUbalance())) {
-            //三相电压不平衡度具体值
+            isLimit = true;
-            powerStatisticsTargetVO.setUbalanceData(dto.getValue());
+            //三相电压不平衡度越限
-            if(Double.compare(dto.getValue(),overlimit.getUbalance())>0){
+            powerStatisticsTargetVO.setUbalance(1);
-                isLimit = true;
-                //标志三相电压不平衡度越限
-                powerStatisticsTargetVO.setUbalance(1);
-            }
         }
-        //电压波动国标限值
+
-        powerStatisticsTargetVO.setVoltageFluctuationLimit(overlimit.getVoltageFluctuation());
+        //电压波动指标详细数据
+        powerStatisticsTargetVO.setVoltageFluctuationList(toThdDataVO(fluc, Param.voltageFluctuation, null, overlimit.getVoltageFluctuation()));
         //电压波动是否越限比较
-        for(StatisticalDataDTO dto : fluc){
+        if (isLimit(fluc, Param.voltageFluctuation, InfluxDBTableConstant.MAX, null, overlimit.getVoltageFluctuation())) {
-            //电压波动具体值
+            isLimit = true;
-            powerStatisticsTargetVO.setVoltageFluctuationData(dto.getValue());
+            //电压波动变越限
-            if(Double.compare(dto.getValue(),overlimit.getVoltageFluctuation())>0){
+            powerStatisticsTargetVO.setVoltageFluctuation(1);
-                isLimit = true;
-                //标志电压波动越限
-                powerStatisticsTargetVO.setVoltageFluctuation(1);
-            }
         }
-        //长时闪变国标限值
+
-        powerStatisticsTargetVO.setFlickerLimit(overlimit.getFlicker());
+        //长时闪变指标详细数据
+        powerStatisticsTargetVO.setFlickerList(toThdDataVO(plt, Param.flicker, null, overlimit.getFlicker()));
         //长时闪变是否越限比较
-        for(StatisticalDataDTO dto : plt){
+        if (isLimit(plt, Param.flicker, InfluxDBTableConstant.MAX, null, overlimit.getFlicker())) {
-            //长时闪变具体值
+            isLimit = true;
-            powerStatisticsTargetVO.setFlickerData(dto.getValue());
+            //长时闪变越限
-            if(Double.compare(dto.getValue(),overlimit.getFlicker())>0){
+            powerStatisticsTargetVO.setFlicker(1);
-                isLimit = true;
-                //标志长时闪变越限
-                powerStatisticsTargetVO.setFlicker(1);
-            }
         }
-        num = 1;
+
+        //间谐波电压含有率指标详细数据
+        powerStatisticsTargetVO.setInterHarmonicList(toThdDataVO(v1, Param.interHarmonic, overlimit, null));
         //间谐波电压含有率是否越限比较
-        for(StatisticalDataDTO dto : v1){
+        if (isLimit(v1, Param.interHarmonic, InfluxDBTableConstant.CP95, overlimit, null)) {
-            Float value = frequencyValue(overlimit,num,"inuharm");
+            isLimit = true;
-            if(value != null){
+            //间谐波电压含有率越限
-                //记录间谐波电压含有率1到16次国标限值(当然这里还是要以influxDb里为主,虽然当前遍历的集合明确查询1-16次但是为了防止influxDb可能缺失一些次数的数据,所以国标限值次数跟着influxDb走)
+            powerStatisticsTargetVO.setInterHarmonic(1);
-                powerStatisticsTargetVO.getInterHarmonicLimit().add(value);
-                //间谐波电压含有率具体值
-                powerStatisticsTargetVO.getInterHarmonicData().add(dto.getValue());
-                if(Double.compare(dto.getValue(),value)>0){
-                    isLimit = true;
-                    //标志间谐波电压含有率越限
-                    powerStatisticsTargetVO.setInterHarmonic(1);
-                }
-            }
-            num++;
         }
-        //电流不平衡度国标限值
+
-        powerStatisticsTargetVO.setSequenceCurrentUnbalanceLimit(overlimit.getINeg());
+        //电流不平衡度指标详细数据
+        powerStatisticsTargetVO.setSequenceCurrentUnbalanceList(toThdDataVO(i_unbalance, Param.sequenceCurrentUnbalance, null, overlimit.getINeg()));
         //电流不平衡度是否越限比较
-        for(StatisticalDataDTO dto : i_unbalance){
+        if (isLimit(i_unbalance, Param.sequenceCurrentUnbalance, null, null, overlimit.getINeg())) {
-            //电流不平衡度具体值
+            isLimit = true;
-            powerStatisticsTargetVO.setSequenceCurrentUnbalanceData(dto.getValue());
+            //电流不平衡度越限
-            if(Double.compare(dto.getValue(),overlimit.getINeg())>0){
+            powerStatisticsTargetVO.setSequenceCurrentUnbalance(1);
-                isLimit = true;
-                //标志电流不平衡度越限
-                powerStatisticsTargetVO.setSequenceCurrentUnbalance(1);
-            }
         }
+
         //区间是否越限标识
-        switch (type){
+        switch (type) {
             case 0:
-                if(isLimit) rActivePowerRangePO.setIsOrNot0(1);
+                if (isLimit) rActivePowerRangePO.setIsOrNot0(1);
                 break;
             case 1:
-                if(isLimit) rActivePowerRangePO.setIsOrNot1(1);
+                if (isLimit) rActivePowerRangePO.setIsOrNot1(1);
                 break;
             case 2:
-                if(isLimit) rActivePowerRangePO.setIsOrNot2(1);
+                if (isLimit) rActivePowerRangePO.setIsOrNot2(1);
                 break;
             case 3:
-                if(isLimit) rActivePowerRangePO.setIsOrNot3(1);
+                if (isLimit) rActivePowerRangePO.setIsOrNot3(1);
                 break;
             case 4:
-                if(isLimit) rActivePowerRangePO.setIsOrNot4(1);
+                if (isLimit) rActivePowerRangePO.setIsOrNot4(1);
                 break;
             case 5:
-                if(isLimit) rActivePowerRangePO.setIsOrNot5(1);
+                if (isLimit) rActivePowerRangePO.setIsOrNot5(1);
                 break;
             case 6:
-                if(isLimit) rActivePowerRangePO.setIsOrNot6(1);
+                if (isLimit) rActivePowerRangePO.setIsOrNot6(1);
                 break;
             case 7:
-                if(isLimit) rActivePowerRangePO.setIsOrNot7(1);
+                if (isLimit) rActivePowerRangePO.setIsOrNot7(1);
                 break;
             case 8:
-                if(isLimit) rActivePowerRangePO.setIsOrNot8(1);
+                if (isLimit) rActivePowerRangePO.setIsOrNot8(1);
                 break;
             case 9:
-                if(isLimit) rActivePowerRangePO.setIsOrNot9(1);
+                if (isLimit) rActivePowerRangePO.setIsOrNot9(1);
                 break;
         }
     }
 
+    private Float isLimit(List<StatisticalDataDTO> list, Overlimit overlimit) {
+        List<StatisticalDataDTO> maxList = list.stream().filter(dto -> dto.equals(InfluxDBTableConstant.MAX)).collect(Collectors.toList());
+        List<StatisticalDataDTO> minList = list.stream().filter(dto -> dto.equals(InfluxDBTableConstant.MIN)).collect(Collectors.toList());
+        StatisticalDataDTO maxDto = maxList.stream().max(Comparator.comparingDouble(StatisticalDataDTO::getValue)).orElse(null);
+        StatisticalDataDTO minDto = minList.stream().min(Comparator.comparingDouble(StatisticalDataDTO::getValue)).orElse(null);
+        if (!maxList.isEmpty()) {
+            if (Double.compare(maxDto.getValue(), 0) > 0 && Double.compare(maxDto.getValue(), overlimit.getVoltageDev()) > 0) {
+                return overlimit.getVoltageDev();
+            }
+        }
+        if (!minList.isEmpty()) {
+            if (Double.compare(minDto.getValue(), 0) < 0 && Double.compare(maxDto.getValue(), overlimit.getUvoltageDev()) > 0) {
+                return overlimit.getUvoltageDev();
+            }
+        }
+        return null;
+    }
+
+    private boolean isLimit(List<StatisticalDataDTO> list, String name, String valueType, Overlimit overlimit, Float limit) {
+        AtomicBoolean ist = new AtomicBoolean(false);
+        if (valueType != null) {
+            list = list.stream().filter(dto -> dto.getValueType().equals(valueType)).collect(Collectors.toList());
+        }
+        if (overlimit != null) {
+            String field = "";
+            switch (name) {
+                case Param.vTimes:
+                    field = "uharm";
+                    break;
+                case Param.iTimes:
+                    field = "iharm";
+                    break;
+                case Param.interHarmonic:
+                    field = "inuharm";
+                    break;
+            }
+            Map<String, List<StatisticalDataDTO>> frequencyMap = list.stream().collect(Collectors.groupingBy(StatisticalDataDTO::getFrequency));
+            String finalField = field;
+            frequencyMap.forEach((frequency, frequencyGroupList) -> {
+                StatisticalDataDTO statisticalDataDTO = frequencyGroupList.stream().max(Comparator.comparingDouble(StatisticalDataDTO::getValue)).orElse(null);
+                Float value = (Float) reflexObjValue(overlimit, finalField + Integer.parseInt(frequency));
+                if (value != null) {
+                    if (statisticalDataDTO.getValue() != null && Double.compare(statisticalDataDTO.getValue(), value) > 0) {
+                        ist.set(true);
+                        return;
+                    }
+                }
+            });
+        } else {
+            StatisticalDataDTO statisticalDataDTO = list.stream().max(Comparator.comparingDouble(StatisticalDataDTO::getValue)).orElse(null);
+            if (statisticalDataDTO != null && statisticalDataDTO.getValue() != null && Double.compare(statisticalDataDTO.getValue(), limit) > 0) {
+                return true;
+            }
+        }
+        return ist.get();
+    }
+
+    //根据各个指标数组信息组装成前端需要的格式
+    private List<ThdDataVO> toThdDataVO(List<StatisticalDataDTO> list, String name, Overlimit overlimit, Float limit) {
+        List<ThdDataVO> thdDataVOS = new ArrayList<>();
+        //带有谐波次数的指标
+        if (overlimit != null) {
+            String field = "";
+            double c = 0;
+            switch (name) {
+                //谐波电压和电流默认谐波次数2-25
+                case Param.vTimes:
+                    field = "uharm";
+                    break;
+                case Param.iTimes:
+                    field = "iharm";
+                    break;
+                //间谐波电压含有率默认谐波次数1-16
+                case Param.interHarmonic:
+                    field = "inuharm";
+                    c = 0.5;
+                    break;
+            }
+            //根据谐波次数分组,分组完则frequencyMap数据维度:当前谐波次数下的各个统计方式和相别他们的值是多少
+            Map<String, List<StatisticalDataDTO>> frequencyMap = list.stream().collect(Collectors.groupingBy(StatisticalDataDTO::getFrequency));
+            double finalC = c;
+            String finalField = field;
+            frequencyMap.forEach((frequency, frequencyGroupList) -> {
+                Integer frequencyNum = Integer.parseInt(frequency);
+                //反射获取当前谐波次数对应的国标限值
+                Float frequencyLimit = (Float) reflexObjValue(overlimit, finalField + frequencyNum);
+                //相别和统计方式的值和ThdDataVO字段相对于
+                ThdDataVO tdv = initThdDataVO(frequencyGroupList,frequencyLimit);
+                if (tdv != null) {
+                    tdv.setAnotherName(name + (((frequencyNum - finalC) + "").replace(".0", "")) + "次");
+                    tdv.setLimit((Float) reflexObjValue(overlimit, finalField + frequencyNum));
+                    tdv.setFrequency(frequencyNum);
+                    thdDataVOS.add(tdv);
+                }
+            });
+        } else {
+            //无谐波次数
+            ThdDataVO tdv = initThdDataVO(list,limit);
+            if (tdv != null) {
+                tdv.setAnotherName(name);
+                tdv.setLimit(limit);
+                thdDataVOS.add(tdv);
+            }
+        }
+        return thdDataVOS.stream().sorted(Comparator.comparing(ThdDataVO::getFrequency)).collect(Collectors.toList());
+    }
+
+    private ThdDataVO initThdDataVO(List<StatisticalDataDTO> list,Float limit) {
+        ThdDataVO tdv = new ThdDataVO();
+        boolean isF = false;
+        //list包含了一组不同相别不同统计方式的数据(最多12条,因为统计方式和相别自由组合最多12条)
+        for (StatisticalDataDTO statisticalDataDTO : list) {
+            String valueType = statisticalDataDTO.getValueType();
+            String phasicType = statisticalDataDTO.getPhaseType();
+            String value = null;
+            if (statisticalDataDTO.getValue() != null) {
+                value = df.format(statisticalDataDTO.getValue());
+                //判断是否有指标越界(不管哪一个相别及统计方式的指标,)
+                if(Double.compare(statisticalDataDTO.getValue(), limit) > 0){
+                    isF = true;
+                }
+            }
+            //统计方式和相别渲染ThdDataVO
+            switch (valueType) {
+                case InfluxDBTableConstant.AVG:
+                    switch (phasicType) {
+                        case InfluxDBTableConstant.PHASE_TYPE_A:
+                            tdv.setAVGPhaseA(value);
+                            break;
+                        case InfluxDBTableConstant.PHASE_TYPE_B:
+                            tdv.setAVGPhaseB(value);
+                            break;
+                        case InfluxDBTableConstant.PHASE_TYPE_C:
+                            tdv.setAVGPhaseC(value);
+                            break;
+                    }
+                    break;
+                case InfluxDBTableConstant.CP95:
+                    switch (phasicType) {
+                        case InfluxDBTableConstant.PHASE_TYPE_A:
+                            tdv.setCP95PhaseA(value);
+                            break;
+                        case InfluxDBTableConstant.PHASE_TYPE_B:
+                            tdv.setCP95PhaseB(value);
+                            break;
+                        case InfluxDBTableConstant.PHASE_TYPE_C:
+                            tdv.setCP95PhaseC(value);
+                            break;
+                    }
+                    break;
+                case InfluxDBTableConstant.MIN:
+                    switch (phasicType) {
+                        case InfluxDBTableConstant.PHASE_TYPE_A:
+                            tdv.setMINPhaseA(value);
+                            break;
+                        case InfluxDBTableConstant.PHASE_TYPE_B:
+                            tdv.setMINPhaseB(value);
+                            break;
+                        case InfluxDBTableConstant.PHASE_TYPE_C:
+                            tdv.setMINPhaseC(value);
+                            break;
+                    }
+                    break;
+                case InfluxDBTableConstant.MAX:
+                    switch (phasicType) {
+                        case InfluxDBTableConstant.PHASE_TYPE_A:
+                            tdv.setMAXPhaseA(value);
+                            break;
+                        case InfluxDBTableConstant.PHASE_TYPE_B:
+                            tdv.setMAXPhaseB(value);
+                            break;
+                        case InfluxDBTableConstant.PHASE_TYPE_C:
+                            tdv.setMAXPhaseC(value);
+                            break;
+                    }
+                    break;
+            }
+        }
+        //如果所有的相别和统计方式都没有值则可直接忽略该条数据或者没有一个相别及统计方式的指标越界也可以忽略
+        if (tdv.getAVGPhaseA() != null || tdv.getAVGPhaseB() != null
+                || tdv.getAVGPhaseC() != null || tdv.getCP95PhaseA() != null
+                || tdv.getCP95PhaseB() != null || tdv.getCP95PhaseC() != null
+                || tdv.getMINPhaseA() != null || tdv.getMINPhaseB() != null
+                || tdv.getMINPhaseC() != null || tdv.getMAXPhaseA() != null
+                || tdv.getMAXPhaseB() != null || tdv.getMAXPhaseC() != null) {
+            if(isF){
+                return tdv;
+            }
+        }
+        return null;
+    }
+
     //组装公共查询(有谐波次数指标查询和没有谐波次数指标查询)
-    private List<StatisticalDataDTO> commonQuery(String tableName,String columnName,StatisticalDataDTO statisticalDataDTO,Integer start,Integer end){
+    private List<StatisticalDataDTO> commonQuery(String tableName, String columnName, StatisticalDataDTO statisticalDataDTO, Integer start, Integer end) {
-        List<CommonQueryParam> commonQueryParams = new ArrayList<>();
-        //不管哪种时间是固定的
         String time = statisticalDataDTO.getTime().atZone(ZoneId.systemDefault()).format(formatter);
-        time = "2024-08-10 00:00:00";
+        List<Object> data = null;
-        CommonQueryParam commonQueryParam = new CommonQueryParam();
+        switch (tableName) {
-        //无谐波次数指标查询
+            case InfluxDBTableConstant.DATA_V:
-        if(start == null){
+                data = Collections.singletonList(iDataVService.getNewDataV(statisticalDataDTO.getLineId(), time, time));
-            commonQueryParam.setStartTime(time);
+                break;
-            commonQueryParam.setEndTime(time);
+            case InfluxDBTableConstant.DATA_HARM_RATE_V:
-            commonQueryParam.setLineId(statisticalDataDTO.getLineId());
+                data = Collections.singletonList(dataHarmRateVService.getNewDataHarmRateV(statisticalDataDTO.getLineId(), time, time));
-            commonQueryParam.setPhasic(statisticalDataDTO.getPhaseType());
+                break;
-            commonQueryParam.setDataType(statisticalDataDTO.getValueType());
+            case InfluxDBTableConstant.DATA_I:
-            commonQueryParam.setTableName(tableName);
+                data = Collections.singletonList(iDataIService.getNewDataI(statisticalDataDTO.getLineId(), time, time));
-            commonQueryParam.setColumnName(columnName);
+                break;
-            commonQueryParams.add(commonQueryParam);
+            case InfluxDBTableConstant.DATA_FLUC:
-        }else{
+                data = Collections.singletonList(dataFlucService.getNewDataFluc(statisticalDataDTO.getLineId(), time, time));
-            //有谐波次数指标查询
+                break;
-            for (int i = start; i <= end; i++) {
+            case InfluxDBTableConstant.DATA_PLT:
-                commonQueryParam = new CommonQueryParam();
+                data = Collections.singletonList(dataPltService.getNewDataPlt(statisticalDataDTO.getLineId(), time, time));
-                commonQueryParam.setStartTime(time);
+                break;
-                commonQueryParam.setEndTime(time);
+            case InfluxDBTableConstant.DATA_IN_HARM_V:
-                commonQueryParam.setLineId(statisticalDataDTO.getLineId());
+                data = Collections.singletonList(dataInHarmVService.getNewDataInHarmV(statisticalDataDTO.getLineId(), time, time));
-                commonQueryParam.setPhasic(statisticalDataDTO.getPhaseType());
+                break;
-                commonQueryParam.setDataType(statisticalDataDTO.getValueType());
+        }
-                commonQueryParam.setTableName(tableName);
+        List<StatisticalDataDTO> list = new ArrayList<>();
-                commonQueryParam.setColumnName(columnName+"_"+i);
+        if (!data.isEmpty()) {
-                commonQueryParams.add(commonQueryParam);
+            data = (List<Object>) data.get(0);
+            for (Object item : data) {
+                String phaseType = (reflexObjValue(item, "phaseType").toString());
+                if (PHASE.contains(phaseType)) {
+                    if (start != null) {
+                        for (int i = start; i <= end; i++) {
+                            StatisticalDataDTO dto = new StatisticalDataDTO();
+                            dto.setPhaseType(phaseType);
+                            dto.setValueType((reflexObjValue(item, "valueType").toString()));
+                            dto.setTime((Instant) reflexObjValue(item, "time"));
+                            dto.setLineId(reflexObjValue(item, "lineId").toString());
+                            dto.setValue((Double) reflexObjValue(item, columnName + i));
+                            dto.setFrequency(i + "");
+                            list.add(dto);
+                        }
+                    } else {
+                        StatisticalDataDTO dto = new StatisticalDataDTO();
+                        dto.setPhaseType(phaseType);
+                        dto.setValueType((reflexObjValue(item, "valueType").toString()));
+                        dto.setTime((Instant) reflexObjValue(item, "time"));
+                        dto.setLineId(reflexObjValue(item, "lineId").toString());
+                        dto.setValue((Double) reflexObjValue(item, columnName));
+                        list.add(dto);
+                    }
+                }
             }
         }
-        return commonService.getNewDeviceRtDataByTime(commonQueryParams);
+        return list;
     }
 
-    //反射获取国标限值对应的字段值
+    //反射获取值
-    private Float frequencyValue(Overlimit overlimit,int num,String flag){
+    private Object reflexObjValue(Object obj, String fieldName) {
         try {
-            Class clazz = overlimit.getClass();
+            Class clazz = obj.getClass();
-            Field field = clazz.getDeclaredField(flag+num);
+            Field field = clazz.getDeclaredField(fieldName);
             field.setAccessible(true);
-            return Float.parseFloat(field.get(overlimit).toString());
+            return field.get(obj);
         } catch (Exception e) {
             e.printStackTrace();
         }
@@ -463,49 +644,59 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl<RActivePowerRan
     }
 
     //根据时间间隔获取间隔前时间或获取昨晚最晚时间
-    private String getTime(long interval,int type){
+    private String getTime(long interval, int type) {
         DateTimeFormatter sdf = DateTimeFormatter.ofPattern(DateUtils.DATE_FORMAT_10);
         LocalDate yesterday;
-        if(type == 0){
+        if (type == 0) {
             yesterday = LocalDate.now().minusDays(interval);
-            return yesterday.format(sdf)+Param.BEGIN;
+            return yesterday.format(sdf) + Param.BEGIN;
-        }else{
+        } else {
             yesterday = LocalDate.now().minusDays(1);
-            return yesterday.format(sdf)+Param.END;
+            return yesterday.format(sdf) + Param.END;
         }
     }
 
     @Override
-    public RActivePowerRangePO getDataByLineId(String lineId,String startTime,String endTime) {
+    public RActivePowerRangePO getDataByLineId(String lineId, String startTime, String endTime) {
         LambdaQueryWrapper<RActivePowerRangePO> lambdaQueryWrapper = new LambdaQueryWrapper();
-        lambdaQueryWrapper.eq(RActivePowerRangePO::getLineId,lineId).eq(RActivePowerRangePO::getState,"1")
+        lambdaQueryWrapper.eq(RActivePowerRangePO::getLineId, lineId).eq(RActivePowerRangePO::getState, "1")
-                .between(RActivePowerRangePO::getTimeId,startTime,endTime);
+                .between(RActivePowerRangePO::getTimeId, startTime, endTime);
         List<RActivePowerRangePO> rActivePowerRangePOS = this.baseMapper.selectList(lambdaQueryWrapper);
-        if(!rActivePowerRangePOS.isEmpty()){
+        if (!rActivePowerRangePOS.isEmpty()) {
             RActivePowerRangePO rActivePowerRangePO = new RActivePowerRangePO();
             rActivePowerRangePO.setLineId(lineId);
             //多条记录则次数累加,是否越限只要有一个区间越限则统一视为该区间越限
-            for(RActivePowerRangePO rangePO : rActivePowerRangePOS){
+            for (RActivePowerRangePO rangePO : rActivePowerRangePOS) {
-                rActivePowerRangePO.setMinsNum0(rangePO.getMinsNum0()+rActivePowerRangePO.getMinsNum0());
+                rActivePowerRangePO.setMinsNum0(rangePO.getMinsNum0() + rActivePowerRangePO.getMinsNum0());
-                rActivePowerRangePO.setMinsNum1(rangePO.getMinsNum1()+rActivePowerRangePO.getMinsNum1());
+                rActivePowerRangePO.setMinsNum1(rangePO.getMinsNum1() + rActivePowerRangePO.getMinsNum1());
-                rActivePowerRangePO.setMinsNum2(rangePO.getMinsNum2()+rActivePowerRangePO.getMinsNum2());
+                rActivePowerRangePO.setMinsNum2(rangePO.getMinsNum2() + rActivePowerRangePO.getMinsNum2());
-                rActivePowerRangePO.setMinsNum3(rangePO.getMinsNum3()+rActivePowerRangePO.getMinsNum3());
+                rActivePowerRangePO.setMinsNum3(rangePO.getMinsNum3() + rActivePowerRangePO.getMinsNum3());
-                rActivePowerRangePO.setMinsNum4(rangePO.getMinsNum4()+rActivePowerRangePO.getMinsNum4());
+                rActivePowerRangePO.setMinsNum4(rangePO.getMinsNum4() + rActivePowerRangePO.getMinsNum4());
-                rActivePowerRangePO.setMinsNum5(rangePO.getMinsNum5()+rActivePowerRangePO.getMinsNum5());
+                rActivePowerRangePO.setMinsNum5(rangePO.getMinsNum5() + rActivePowerRangePO.getMinsNum5());
-                rActivePowerRangePO.setMinsNum6(rangePO.getMinsNum6()+rActivePowerRangePO.getMinsNum6());
+                rActivePowerRangePO.setMinsNum6(rangePO.getMinsNum6() + rActivePowerRangePO.getMinsNum6());
-                rActivePowerRangePO.setMinsNum7(rangePO.getMinsNum7()+rActivePowerRangePO.getMinsNum7());
+                rActivePowerRangePO.setMinsNum7(rangePO.getMinsNum7() + rActivePowerRangePO.getMinsNum7());
-                rActivePowerRangePO.setMinsNum8(rangePO.getMinsNum8()+rActivePowerRangePO.getMinsNum8());
+                rActivePowerRangePO.setMinsNum8(rangePO.getMinsNum8() + rActivePowerRangePO.getMinsNum8());
-                rActivePowerRangePO.setMinsNum9(rangePO.getMinsNum9()+rActivePowerRangePO.getMinsNum9());
+                rActivePowerRangePO.setMinsNum9(rangePO.getMinsNum9() + rActivePowerRangePO.getMinsNum9());
-                rActivePowerRangePO.setIsOrNot0(rangePO.getIsOrNot0()+rActivePowerRangePO.getIsOrNot0());
+                rActivePowerRangePO.setIsOrNot0(rangePO.getIsOrNot0() + rActivePowerRangePO.getIsOrNot0());
-                rActivePowerRangePO.setIsOrNot1(rangePO.getIsOrNot1()+rActivePowerRangePO.getIsOrNot1());
+                rActivePowerRangePO.setIsOrNot1(rangePO.getIsOrNot1() + rActivePowerRangePO.getIsOrNot1());
-                rActivePowerRangePO.setIsOrNot2(rangePO.getIsOrNot2()+rActivePowerRangePO.getIsOrNot2());
+                rActivePowerRangePO.setIsOrNot2(rangePO.getIsOrNot2() + rActivePowerRangePO.getIsOrNot2());
-                rActivePowerRangePO.setIsOrNot3(rangePO.getIsOrNot3()+rActivePowerRangePO.getIsOrNot3());
+                rActivePowerRangePO.setIsOrNot3(rangePO.getIsOrNot3() + rActivePowerRangePO.getIsOrNot3());
-                rActivePowerRangePO.setIsOrNot4(rangePO.getIsOrNot4()+rActivePowerRangePO.getIsOrNot4());
+                rActivePowerRangePO.setIsOrNot4(rangePO.getIsOrNot4() + rActivePowerRangePO.getIsOrNot4());
-                rActivePowerRangePO.setIsOrNot5(rangePO.getIsOrNot5()+rActivePowerRangePO.getIsOrNot5());
+                rActivePowerRangePO.setIsOrNot5(rangePO.getIsOrNot5() + rActivePowerRangePO.getIsOrNot5());
-                rActivePowerRangePO.setIsOrNot6(rangePO.getIsOrNot6()+rActivePowerRangePO.getIsOrNot6());
+                rActivePowerRangePO.setIsOrNot6(rangePO.getIsOrNot6() + rActivePowerRangePO.getIsOrNot6());
-                rActivePowerRangePO.setIsOrNot7(rangePO.getIsOrNot7()+rActivePowerRangePO.getIsOrNot7());
+                rActivePowerRangePO.setIsOrNot7(rangePO.getIsOrNot7() + rActivePowerRangePO.getIsOrNot7());
-                rActivePowerRangePO.setIsOrNot8(rangePO.getIsOrNot8()+rActivePowerRangePO.getIsOrNot8());
+                rActivePowerRangePO.setIsOrNot8(rangePO.getIsOrNot8() + rActivePowerRangePO.getIsOrNot8());
-                rActivePowerRangePO.setIsOrNot9(rangePO.getIsOrNot9()+rActivePowerRangePO.getIsOrNot9());
+                rActivePowerRangePO.setIsOrNot9(rangePO.getIsOrNot9() + rActivePowerRangePO.getIsOrNot9());
+                rActivePowerRangePO.setMinsTime0(rangePO.getMinsTime0() + "&" + rActivePowerRangePO.getMinsTime0());
+                rActivePowerRangePO.setMinsTime1(rangePO.getMinsTime1() + "&" + rActivePowerRangePO.getMinsTime1());
+                rActivePowerRangePO.setMinsTime2(rangePO.getMinsTime2() + "&" + rActivePowerRangePO.getMinsTime2());
+                rActivePowerRangePO.setMinsTime3(rangePO.getMinsTime3() + "&" + rActivePowerRangePO.getMinsTime3());
+                rActivePowerRangePO.setMinsTime4(rangePO.getMinsTime4() + "&" + rActivePowerRangePO.getMinsTime4());
+                rActivePowerRangePO.setMinsTime5(rangePO.getMinsTime5() + "&" + rActivePowerRangePO.getMinsTime5());
+                rActivePowerRangePO.setMinsTime6(rangePO.getMinsTime6() + "&" + rActivePowerRangePO.getMinsTime6());
+                rActivePowerRangePO.setMinsTime7(rangePO.getMinsTime7() + "&" + rActivePowerRangePO.getMinsTime7());
+                rActivePowerRangePO.setMinsTime8(rangePO.getMinsTime8() + "&" + rActivePowerRangePO.getMinsTime8());
+                rActivePowerRangePO.setMinsTime9(rangePO.getMinsTime9() + "&" + rActivePowerRangePO.getMinsTime9());
             }
             return rActivePowerRangePO;
         }