有功功率稳态表格和详情调整

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

@@ -24,6 +24,9 @@ public class PowerStatisticsParam extends BaseParam {
     @ApiModelProperty("指标分类ID(用于查询指标详细数据的指标分类ID)")
     private String statisticalId;
 
+    @ApiModelProperty("指标分类ID(用于查询指标详细数据的指标分类ID)")
+    private String code;
+
     @ApiModelProperty("区间字段(用于查询指标越限列表)")
     private String field;
 

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

@@ -26,7 +26,7 @@ public class RActivePowerRangePO extends BaseEntity {
     /**
      * 日期（天）
      */
-    private LocalDate timeId;
+    private String timeId;
 
     /**
      * 0%~10%区间时间Json

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

@@ -40,28 +40,4 @@ public class PowerStatisticsTargetVO {
     @ApiModelProperty("电流不平衡度")
     private Integer sequenceCurrentUnbalance = 0;
 
-    @ApiModelProperty("电压偏差详情")
-    private List<ThdDataVO> voltageOffsetList = new ArrayList<>();
-
-    @ApiModelProperty("谐波电压详情")
-    private List<ThdDataVO> vTimesList = new ArrayList<>();
-
-    @ApiModelProperty("谐波电流详情")
-    private List<ThdDataVO> iTimestList = new ArrayList<>();
-
-    @ApiModelProperty("三相电压不平衡度详情")
-    private List<ThdDataVO> ubalanceList = new ArrayList<>();
-
-    @ApiModelProperty("电压波动")
-    private List<ThdDataVO> voltageFluctuationList = new ArrayList<>();
-
-    @ApiModelProperty("闪变详情")
-    private List<ThdDataVO> flickerList = new ArrayList<>();
-
-    @ApiModelProperty("间谐波电压含有率详情")
-    private List<ThdDataVO> interHarmonicList = new ArrayList<>();
-
-    @ApiModelProperty("电流不平衡度详情")
-    private List<ThdDataVO> sequenceCurrentUnbalanceList = new ArrayList<>();
-
 }

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

@@ -0,0 +1,177 @@
+package com.njcn.harmonic.pojo.vo;
+
+import lombok.Data;
+
+import java.util.List;
+
+
+/**
+ * 有功功率趋势 实体类
+ * @author guofeihu
+ * @since 2024-08-20
+ */
+@Data
+public class RActivePowerRangeVO {
+
+
+    /**
+     * 监测点ID
+     */
+    private String lineId;
+
+    /**
+     * 日期（天）
+     */
+    private List<String> timeId;
+
+    /**
+     * 0%~10%区间时间Json
+     */
+    private List<String> minsTime0;
+
+    /**
+     * 0%~10%区间个数
+     */
+    private Integer minsNum0 = 0;
+
+    /**
+     * 0%~10%区间是否越限
+     */
+    private Integer isOrNot0 = 0;
+
+    /**
+     * 10%~20%区间时间Json
+     */
+    private List<String> minsTime1;
+
+    /**
+     * 10%~20%区间个数
+     */
+    private Integer minsNum1 = 0;;
+
+    /**
+     * 10%~20%区间是否越限
+     */
+    private Integer isOrNot1 = 0;
+
+    /**
+     * 20%~30%区间时间Json
+     */
+    private List<String> minsTime2;
+
+    /**
+     * 20%~30%区间个数
+     */
+    private Integer minsNum2 = 0;;
+
+    /**
+     * 20%~30%区间是否越限
+     */
+    private Integer isOrNot2 = 0;
+
+    /**
+     * 30%~40%区间时间Json
+     */
+    private List<String> minsTime3;
+
+    /**
+     * 30%~40%区间个数
+     */
+    private Integer minsNum3 = 0;;
+
+    /**
+     * 30%~40%区间是否越限
+     */
+    private Integer isOrNot3 = 0;
+
+    /**
+     * 40%~50%区间时间Json
+     */
+    private List<String> minsTime4;
+
+    /**
+     * 40%~50%区间个数
+     */
+    private Integer minsNum4 = 0;;
+
+    /**
+     * 40%~50%区间是否越限
+     */
+    private Integer isOrNot4 = 0;
+
+    /**
+     * 50%~60%区间时间Json
+     */
+    private List<String> minsTime5;
+
+    /**
+     * 50%~60%区间个数
+     */
+    private Integer minsNum5 = 0;;
+
+    /**
+     * 50%~60%区间是否越限
+     */
+    private Integer isOrNot5 = 0;
+
+    /**
+     * 60%~70%区间时间Json
+     */
+    private List<String> minsTime6;
+
+    /**
+     * 60%~70%区间个数
+     */
+    private Integer minsNum6 = 0;;
+
+    /**
+     * 60%~70%区间是否越限
+     */
+    private Integer isOrNot6 = 0;
+
+    /**
+     * 70%~80%区间时间Json
+     */
+    private List<String> minsTime7;
+
+    /**
+     * 70%~80%区间个数
+     */
+    private Integer minsNum7 = 0;;
+
+    /**
+     * 70%~80%区间是否越限
+     */
+    private Integer isOrNot7 = 0;
+
+    /**
+     * 80%~90%区间时间Json
+     */
+    private List<String> minsTime8;
+
+    /**
+     * 80%~90%区间个数
+     */
+    private Integer minsNum8 = 0;;
+
+    /**
+     * 80%~90%区间是否越限
+     */
+    private Integer isOrNot8 = 0;
+
+    /**
+     * 90%~100%区间时间Json
+     */
+    private List<String> minsTime9;
+
+    /**
+     * 90%~100%区间个数
+     */
+    private Integer minsNum9 = 0;;
+
+    /**
+     * 90%~100%区间是否越限
+     */
+    private Integer isOrNot9 = 0;
+
+}

pqs-harmonic/harmonic-boot/pom.xml

@@ -112,6 +112,12 @@
             <artifactId>cs-device-api</artifactId>
             <version>1.0.0</version>
         </dependency>
+        <dependency>
+            <groupId>com.njcn.platform</groupId>
+            <artifactId>data-processing-api</artifactId>
+            <version>1.0.0</version>
+            <scope>compile</scope>
+        </dependency>
     </dependencies>
 
     <build>

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/controller/powerstatistics/PowerStatisticsController.java

@@ -66,7 +66,7 @@ public class PowerStatisticsController extends BaseController {
     @ApiOperation("点击越限列表时间查询指标的详细数据")
     public HttpResult<List<ThdDataVO>> getTargetByTime(@RequestBody @Validated PowerStatisticsParam powerStatisticsParam) {
         String methodDescribe = getMethodDescribe("getTargetByTime");
-        List<ThdDataVO> targetByTime = powerStatisticsService.getTargetByTime(powerStatisticsParam);
+        List<ThdDataVO> targetByTime = powerStatisticsService.getTargetByTimeDetail(powerStatisticsParam);
         return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, targetByTime, methodDescribe);
     }
 

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

@@ -29,11 +29,11 @@ public interface PowerStatisticsService {
     List<PowerStatisticsTargetVO> getTargetLimitById(PowerStatisticsParam powerStatisticsParam);
 
     /**
-     * 点击越限列表时间查询指标的详细数据
+     * 查询稳态详情信息
-     * @param powerStatisticsParam
+     * @param param
      * @return
      */
-    List<ThdDataVO> getTargetByTime(PowerStatisticsParam powerStatisticsParam);
+    List<ThdDataVO> getTargetByTimeDetail(PowerStatisticsParam param);
 
     /**
      * 导出区间数据

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

@@ -3,6 +3,7 @@ package com.njcn.harmonic.service.activepowerrange;
 import com.github.jeffreyning.mybatisplus.service.IMppService;
 import com.njcn.harmonic.pojo.po.RActivePowerRangePO;
 import com.njcn.harmonic.pojo.vo.PowerStatisticsTargetVO;
+import com.njcn.harmonic.pojo.vo.RActivePowerRangeVO;
 import com.njcn.prepare.harmonic.pojo.param.RActivePowerRangeParam;
 
 import java.util.List;
@@ -14,14 +15,10 @@ import java.util.List;
  */
 public interface RActivePowerRangeService extends IMppService<RActivePowerRangePO> {
 
-    /**
-     * 有功功率趋势记录(用于定时任务)
-     */
-    List<PowerStatisticsTargetVO> record(RActivePowerRangeParam rActivePowerRangeParam);
 
     /**
      * 根据监测点ID及时间获取有功功率趋势
      */
-    RActivePowerRangePO getDataByLineId(String lineId, String startTime, String endTime);
+    RActivePowerRangeVO getDataByLineId(String lineId, String startTime, String endTime);
 
 }

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

@@ -2,25 +2,26 @@ package com.njcn.harmonic.service.activepowerrange.impl;
 
 import cn.afterturn.easypoi.excel.ExcelExportUtil;
 import cn.afterturn.easypoi.excel.entity.ExportParams;
-import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
 import com.alibaba.excel.EasyExcel;
 import com.alibaba.excel.ExcelWriter;
 import com.alibaba.excel.write.metadata.WriteSheet;
+import com.alibaba.fastjson.JSONArray;
+import com.njcn.dataProcess.api.*;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.*;
+import com.njcn.device.biz.pojo.po.Overlimit;
+import com.njcn.device.pq.api.OverLimitClient;
 import com.njcn.harmonic.constant.Param;
 import com.njcn.harmonic.pojo.param.PowerStatisticsParam;
-import com.njcn.harmonic.pojo.po.RActivePowerRangePO;
 import com.njcn.harmonic.pojo.vo.*;
 import com.njcn.harmonic.service.activepowerrange.PowerStatisticsService;
 import com.njcn.harmonic.service.activepowerrange.RActivePowerRangeService;
-import com.njcn.influx.pojo.bo.CommonQueryParam;
-import com.njcn.influx.pojo.constant.InfluxDBTableConstant;
-import com.njcn.influx.pojo.dto.StatisticalDataDTO;
 import com.njcn.influx.service.CommonService;
 import com.njcn.poi.util.PoiUtil;
-import com.njcn.prepare.harmonic.pojo.param.RActivePowerRangeParam;
 import com.njcn.system.api.EpdFeignClient;
-import com.njcn.system.pojo.po.EleEpdPqd;
 import lombok.RequiredArgsConstructor;
 import org.apache.poi.ss.usermodel.*;
 import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
@@ -32,10 +33,13 @@ import org.springframework.stereotype.Service;
 import javax.servlet.http.HttpServletResponse;
 import java.io.IOException;
 import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.text.DecimalFormat;
 import java.util.*;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 /**
@@ -53,41 +57,24 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService {
     private final DecimalFormat df = new DecimalFormat(Param.DECIMAL_FORMATSTR);
     private final DecimalFormat dftwo = new DecimalFormat(Param.DECIMAL_FORMATTWOSTR);
     private final EpdFeignClient epdFeignClient;
-
+    private final DataVFeignClient dataVFeignClient;
-    private List<String> METHODS = Arrays.asList(InfluxDBTableConstant.AVG, InfluxDBTableConstant.CP95, InfluxDBTableConstant.MIN, InfluxDBTableConstant.MAX);
+    private final DataIFeignClient dataIFeignClient;
-
+    private final DataPltFeignClient dataPltFeignClient;
-    private List<String> PHASE = Arrays.asList(InfluxDBTableConstant.PHASE_TYPE_A, InfluxDBTableConstant.PHASE_TYPE_B, InfluxDBTableConstant.PHASE_TYPE_C);
+    private final DataInharmVFeignClient dataInharmVFeignClient;
+    private final DataHarmRateVFeignClient dataHarmRateVFeignClient;
+    private final OverLimitClient overLimitClient;
+    private final DataLimitRateDetailFeignClient dataLimitRateDetailFeignClient;
 
     private List<String> times = Arrays.asList("0~10%", "10~20%", "20~30%", "30~40%", "40~50%", "50~60%", "60~70%", "70~80%", "80~90%", "90~100%");
 
-    Map<String, String> DATABSEMAP = new HashMap() {{
-        put("PPVDev", "电压偏差");
-        put("ImbNgV", "三相电压不平衡度");
-        put("PhFluc", "电压波动");
-        put("PhPlt", "长时闪变");
-        put("ImbNgA", "电流不平衡度");
-    }};
-
-    Map<String, String> UHARMMAP = new HashMap() {{
-        put("HRPhV", "谐波电压");
-    }};
-
-    Map<String, String> IHARMMAP = new HashMap() {{
-        put("HA", "谐波电流");
-    }};
-
-    Map<String, String> INTERHARMONICMAP = new HashMap() {{
-        put("IHRPhV", "间谐波电压含有率");
-    }};
-
     @Override
     public PowerStatisticsVO getDataByLineId(PowerStatisticsParam powerStatisticsParam) {
         //执行完就可以获取到区间数据了
-        RActivePowerRangePO rActivePowerRangePO = rActivePowerRangeService.getDataByLineId(powerStatisticsParam.getLineId(),
+        RActivePowerRangeVO rActivePowerRangePO = rActivePowerRangeService.getDataByLineId(powerStatisticsParam.getLineId(),
                 powerStatisticsParam.getSearchBeginTime(), powerStatisticsParam.getSearchEndTime());
         //如果的确没有统计到数据则默认
         if (rActivePowerRangePO == null) {
-            rActivePowerRangePO = new RActivePowerRangePO();
+            rActivePowerRangePO = new RActivePowerRangeVO();
         }
         PowerStatisticsVO powerStatisticsVO = new PowerStatisticsVO();
         BeanUtils.copyProperties(rActivePowerRangePO, powerStatisticsVO);
@@ -115,24 +102,190 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService {
     @Override
     public List<PowerStatisticsTargetVO> getTargetLimitById(PowerStatisticsParam powerStatisticsParam) {
         List<PowerStatisticsTargetVO> record = new ArrayList<>();
-        RActivePowerRangeParam rActivePowerRangeParam = new RActivePowerRangeParam();
+        RActivePowerRangeVO rActivePowerRangePO = rActivePowerRangeService.getDataByLineId(powerStatisticsParam.getLineId(),
-        BeanUtil.copyProperties(powerStatisticsParam, rActivePowerRangeParam);
-        rActivePowerRangeParam.setSearch(true);
-        RActivePowerRangePO rActivePowerRangePO = rActivePowerRangeService.getDataByLineId(powerStatisticsParam.getLineId(),
                 powerStatisticsParam.getSearchBeginTime(), powerStatisticsParam.getSearchEndTime());
-        if (rActivePowerRangePO != null) {
+        //获取电压数据
+        LineCountEvaluateParam lineParam = new LineCountEvaluateParam();
+        lineParam.setLineId(Collections.singletonList(rActivePowerRangePO.getLineId()));
+        LineCountEvaluateParam lineCountEvaluateParam = new LineCountEvaluateParam();
+        lineCountEvaluateParam.setLineId(Collections.singletonList(rActivePowerRangePO.getLineId()));
+        lineCountEvaluateParam.setStartTime(powerStatisticsParam.getSearchBeginTime());
+        lineCountEvaluateParam.setEndTime(powerStatisticsParam.getSearchBeginTime());
+        //获取超标数据
+        List<DataLimitRateDetailTimeDto> dtoList = dataLimitRateDetailFeignClient.getLimitRateDetailTimeList(lineCountEvaluateParam).getData();
+        Map<String, DataLimitRateDetailTimeDto> timeDateMap = dtoList.stream().collect(Collectors.toMap(x -> x.getTime(), Function.identity()));
+        if (ObjectUtil.isNotNull(rActivePowerRangePO)) {
+            List<String> timeId = rActivePowerRangePO.getTimeId();
             String times = reflexObjValue(rActivePowerRangePO, "minsTime" + powerStatisticsParam.getField()).toString().replace("null", "");
-            rActivePowerRangeParam.setSearchTimeFort(false);
+            List<String> timeList = JSONArray.parseArray(times, String.class);
-            for (String se : times.split("&")) {
+            for (int i = 0; i < timeId.size(); i++) {
-                String startTime = se.split(",")[0];
+                String date = timeId.get(i);
-                String endTime = se.split(",")[1];
+                List<String> strings = JSONArray.parseArray(timeList.get(i), String.class);
-                rActivePowerRangeParam.setSearchBeginTime(startTime);
+                if (CollUtil.isNotEmpty(strings)) {
-                rActivePowerRangeParam.setSearchEndTime(endTime);
+                    for (String time : strings) {
-                record.addAll(rActivePowerRangeService.record(rActivePowerRangeParam));
+                        PowerStatisticsTargetVO vo = new PowerStatisticsTargetVO();
+                        String t = date + " " + time;
+                        vo.setTime(t);
+                        if (timeDateMap.containsKey(date)) {
+                            DataLimitRateDetailTimeDto rateDetail = timeDateMap.get(date);
+                            vo.setVoltageOffset(isCross(t, rateDetail.getVoltageDevOvertime()));
+                            vo.setSequenceCurrentUnbalance(isCross(t, rateDetail.getINegOvertime()));
+                            vo.setUbalance(isCross(t, rateDetail.getUbalanceOvertime()));
+                            vo.setFlicker(isCross(t, rateDetail.getFlickerOvertime()));
+                            vo.setVTimes(isCross(t, rateDetail.getUharmOvertime()));
+                            vo.setITimes(isCross(t, rateDetail.getIharmOvertime()));
+                            vo.setInterHarmonic(isCross(t, rateDetail.getInuharmOvertime()));
+                        }
+                        record.add(vo);
+                    }
+                }
             }
+
+
         }
         return record.stream().sorted(Comparator.comparing(PowerStatisticsTargetVO::getTime)).collect(Collectors.toList());
+    }
 
+    @Override
+    public List<ThdDataVO> getTargetByTimeDetail(PowerStatisticsParam param) {
+        List<ThdDataVO> info = new ArrayList<>();
+        //获取越线详情
+        List<Overlimit> data = overLimitClient.getOverLimitByLineIds(Collections.singletonList(param.getLineId())).getData();
+        Overlimit overlimit = data.get(0);
+        LineCountEvaluateParam evaluateParam = new LineCountEvaluateParam();
+        evaluateParam.setLineId(Collections.singletonList(param.getLineId()));
+        evaluateParam.setStartTime(param.getSearchBeginTime());
+        evaluateParam.setEndTime(param.getSearchEndTime());
+        if ("1".equals(param.getStatisticalId())) {
+            //电压数据
+            List<DataVDto> dataVAllTime = dataVFeignClient.getRawData(evaluateParam).getData();
+            //闪变数据
+            List<DataPltDto> dataFlickerAllTime = dataPltFeignClient.getRawData(evaluateParam).getData();
+            //电流数据
+            List<DataIDto> dataIList = dataIFeignClient.getRawData(evaluateParam).getData();
+            //电压偏差
+            if ("Dev".equals(param.getCode()) || StrUtil.isBlank(param.getCode())) {
+                addThdData(info, overlimit.getVoltageDev(), "vuDev", dataVAllTime, "电压上偏差");
+                addThdData(info, overlimit.getUvoltageDev(), "vlDev", dataVAllTime, "电压下偏差");
+            }
+            //电压不平横度
+            if ("Unbalance".equals(param.getCode()) || StrUtil.isBlank(param.getCode())) {
+                addThdData(info, overlimit.getUbalance(), "vUnbalance", dataVAllTime, "三相电压不平横度");
+            }
+            //闪变
+            if ("plt".equals(param.getCode()) || StrUtil.isBlank(param.getCode())) {
+                addThdData(info, overlimit.getFlicker(), "plt", dataFlickerAllTime, "长时闪变");
+            }
+            //电流不平衡度
+            if ("iNeg".equals(param.getCode()) || StrUtil.isBlank(param.getCode())) {
+                addThdData(info, overlimit.getINeg(), "iNeg", dataIList, "电流不平衡度");
+            }
+        }
+        if ("2".equals(param.getStatisticalId())) {
+            //谐波数据
+            List<DataHarmDto> dataVHarmList = dataHarmRateVFeignClient.getRawData(evaluateParam).getData();
+            addThdData(info, overlimit, "getUharm", "v", 2, 26, dataVHarmList, "谐波电压");
+        }
+        if ("3".equals(param.getStatisticalId())) {
+            //电流数据
+            List<DataIDto> dataIList = dataIFeignClient.getRawData(evaluateParam).getData();
+            addThdData(info, overlimit, "getUharm", "i", 2, 26, dataIList, "谐波电流");
+
+        }
+        if ("4".equals(param.getStatisticalId())) {
+            //间谐波数据
+            List<DataHarmDto> dataVInHarmList = dataInharmVFeignClient.getRawData(evaluateParam).getData();
+            addThdData(info, overlimit, "getInuharm", "v", 1, 17, dataVInHarmList, "间谐波电压");
+        }
+        return info;
+    }
+
+    private void addThdData(List<ThdDataVO> info, Overlimit overlimit, String limitField, String fieldName, Integer start, Integer end, List<?> dataAllTime, String anotherName) {
+        if (CollUtil.isNotEmpty(dataAllTime)) {
+            for (int i = start; i < end; i++) {
+                int finalI = i;
+                List<String> collect = dataAllTime.stream().map(x -> data(x, fieldName + finalI)).filter(x -> ObjectUtil.isNotNull(x)).collect(Collectors.toList());
+                if (CollUtil.isNotEmpty(collect)) {
+                    ThdDataVO vo = new ThdDataVO();
+                    try {
+                        Method getUharmMethod = Overlimit.class.getMethod(limitField + i);
+                        float limit = (float) getUharmMethod.invoke(overlimit);
+                        vo.setLimit(limit);
+                    } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+                        throw new RuntimeException(e);
+                    }
+                    vo.setAnotherName(anotherName);
+                    if ("getInuharm".equals(limitField)) {
+                        vo.setAnotherName(i - 0.5 + "次");
+                    } else {
+                        vo.setAnotherName(i + "次");
+                    }
+                    for (String s : collect) {
+                        setDataV(vo, s);
+                    }
+                    info.add(vo);
+                }
+            }
+
+        }
+    }
+
+    private void addThdData(List<ThdDataVO> info, Float limit, String fieldName, List<?> dataAllTime, String anotherName) {
+        if (CollUtil.isNotEmpty(dataAllTime)) {
+            List<String> collect = dataAllTime.stream().map(x -> data(x, fieldName)).filter(x -> ObjectUtil.isNotNull(x)).collect(Collectors.toList());
+            if (CollUtil.isNotEmpty(collect)) {
+                ThdDataVO vo = new ThdDataVO();
+                vo.setLimit(limit);
+                vo.setAnotherName(anotherName);
+                for (String s : collect) {
+                    setDataV(vo, s);
+                }
+                info.add(vo);
+            }
+        }
+    }
+
+    private void setDataV(ThdDataVO dto, String fieldName) {
+        String[] split = fieldName.split("&");
+        if (split.length > 1) {
+            try {
+                Class clazz = dto.getClass();
+                Field field = clazz.getDeclaredField(split[0]);
+                field.setAccessible(true);
+                field.set(dto, split[1]);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+    private String data(Object dto, String fieldName) {
+        try {
+            Class clazz = dto.getClass();
+            Field field = clazz.getDeclaredField(fieldName);
+            field.setAccessible(true);
+            Object o = field.get(dto);
+            if (ObjectUtil.isNotNull(o)) {
+                Field phasicType = clazz.getDeclaredField("phasicType");
+                phasicType.setAccessible(true);
+                String phasic = phasicType.get(dto).toString();
+                Field valueType = clazz.getDeclaredField("valueType");
+                valueType.setAccessible(true);
+                String value = valueType.get(dto).toString();
+                return value.toUpperCase() + "Phase" + phasic + "&" + o;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    private Integer isCross(String time, List<String> timeCross) {
+        if (timeCross.contains(time)) {
+            return 1;
+        }
+        return 0;
     }
 
     /**
@@ -155,177 +308,6 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService {
         return null;
     }
 
-    @Override
-    public List<ThdDataVO> getTargetByTime(PowerStatisticsParam powerStatisticsParam) {
-        List<ThdDataVO> result = new ArrayList();
-        List<EleEpdPqd> eleEpdPqds = new ArrayList<>();
-        //获取固定指标具体请看
-        if ("1".equals(powerStatisticsParam.getStatisticalId())) {
-            DATABSEMAP.forEach((key, value) -> {
-                EleEpdPqd epdPqd = epdFeignClient.findByName(key).getData();
-                if(ObjectUtil.isNotEmpty(epdPqd)){
-                    epdPqd.setShowName(value);
-                    eleEpdPqds.add(epdPqd);
-                }
-            });
-        }
-        if ("2".equals(powerStatisticsParam.getStatisticalId())) {
-            UHARMMAP.forEach((key, value) -> {
-                EleEpdPqd epdPqd = epdFeignClient.findByName(key).getData();
-                if(ObjectUtil.isNotEmpty(epdPqd)){
-                    epdPqd.setShowName(value);
-                    eleEpdPqds.add(epdPqd);
-                }
-            });
-        }
-        if ("3".equals(powerStatisticsParam.getStatisticalId())) {
-            IHARMMAP.forEach((key, value) -> {
-                EleEpdPqd epdPqd = epdFeignClient.findByName(key).getData();
-                if(ObjectUtil.isNotEmpty(epdPqd)){
-                    epdPqd.setShowName(value);
-                    eleEpdPqds.add(epdPqd);
-                }
-            });
-        }
-        if ("4".equals(powerStatisticsParam.getStatisticalId())) {
-            INTERHARMONICMAP.forEach((key, value) -> {
-                EleEpdPqd epdPqd = epdFeignClient.findByName(key).getData();
-                if(ObjectUtil.isNotEmpty(epdPqd)){
-                    epdPqd.setShowName(value);
-                    eleEpdPqds.add(epdPqd);
-                }
-            });
-        }
-        eleEpdPqds.forEach(epdPqd -> {
-            List<CommonQueryParam> commonQueryParams = new ArrayList<>();
-            commonQueryParams.clear();
-            //带有谐波次数的指标
-            if (epdPqd.getHarmEnd() != null && epdPqd.getHarmStart() != null) {
-                for (int i = epdPqd.getHarmStart().intValue(); i <= epdPqd.getHarmEnd().intValue(); i++) {
-                    ThdDataVO thdDataVO = new ThdDataVO();
-                    thdDataVO.setUnit(epdPqd.getUnit());
-                    thdDataVO.setTime(powerStatisticsParam.getSearchBeginTime());
-                    String index = i + "";
-                    if (epdPqd.getShowName().equals("间谐波电压含有率")) {
-                        thdDataVO.setAnotherName(Integer.parseInt(index) - 0.5 + "次");
-                    } else {
-                        thdDataVO.setAnotherName(index + "次");
-                    }
-                    getThdDataVO(epdPqd.getOtherName() + "_" + index, thdDataVO, epdPqd, powerStatisticsParam);
-                    result.add(thdDataVO);
-                }
-            } else {
-                //无谐波次数的指标
-                ThdDataVO thdDataVO = new ThdDataVO();
-                thdDataVO.setAnotherName(epdPqd.getShowName());
-                thdDataVO.setUnit(epdPqd.getUnit());
-                thdDataVO.setTime(powerStatisticsParam.getSearchBeginTime());
-                getThdDataVO(null, thdDataVO, epdPqd, powerStatisticsParam);
-                result.add(thdDataVO);
-            }
-        });
-        return result;
-    }
-
-    //将各个指标的所有的相别统计方式以表格的维度进行组装数据
-    private ThdDataVO getThdDataVO(String columnName, ThdDataVO thdDataVO, EleEpdPqd epdPqd, PowerStatisticsParam powerStatisticsParam) {
-        List<CommonQueryParam> commonQueryParams = new ArrayList<>();
-        CommonQueryParam commonQueryParam = new CommonQueryParam();
-        commonQueryParam.setLineId(powerStatisticsParam.getLineId());
-        commonQueryParam.setTableName(epdPqd.getClassId());
-        commonQueryParam.setColumnName(columnName == null ? epdPqd.getOtherName() : columnName);
-        commonQueryParam.setStartTime(powerStatisticsParam.getSearchBeginTime());
-        commonQueryParam.setEndTime(powerStatisticsParam.getSearchEndTime());
-        //唯一不同的条件时统计方式和相别,所以这边直接把所有的情况都考虑进去
-        commonQueryParam.setDataType(METHODS.get(0));
-        commonQueryParam.setPhasic(PHASE.get(0));
-        commonQueryParams.add(commonQueryParam);
-
-        List<StatisticalDataDTO> deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
-        if (!deviceRtData.isEmpty()) {
-            thdDataVO.setAVGPhaseA(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
-        }
-
-        commonQueryParam.setDataType(METHODS.get(0));
-        commonQueryParam.setPhasic(PHASE.get(1));
-        deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
-        if (!deviceRtData.isEmpty()) {
-            thdDataVO.setAVGPhaseB(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
-        }
-
-        commonQueryParam.setDataType(METHODS.get(0));
-        commonQueryParam.setPhasic(PHASE.get(2));
-        deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
-        if (!deviceRtData.isEmpty()) {
-            thdDataVO.setAVGPhaseC(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
-        }
-
-        commonQueryParam.setDataType(METHODS.get(1));
-        commonQueryParam.setPhasic(PHASE.get(0));
-        deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
-        if (!deviceRtData.isEmpty()) {
-            thdDataVO.setCP95PhaseA(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
-        }
-
-        commonQueryParam.setDataType(METHODS.get(1));
-        commonQueryParam.setPhasic(PHASE.get(1));
-        deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
-        if (!deviceRtData.isEmpty()) {
-            thdDataVO.setCP95PhaseB(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
-        }
-
-        commonQueryParam.setDataType(METHODS.get(1));
-        commonQueryParam.setPhasic(PHASE.get(2));
-        deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
-        if (!deviceRtData.isEmpty()) {
-            thdDataVO.setCP95PhaseC(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
-        }
-
-
-        commonQueryParam.setDataType(METHODS.get(2));
-        commonQueryParam.setPhasic(PHASE.get(0));
-        deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
-        if (!deviceRtData.isEmpty()) {
-            thdDataVO.setMINPhaseA(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
-        }
-
-        commonQueryParam.setDataType(METHODS.get(2));
-        commonQueryParam.setPhasic(PHASE.get(1));
-        deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
-        if (!deviceRtData.isEmpty()) {
-            thdDataVO.setMINPhaseB(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
-        }
-
-        commonQueryParam.setDataType(METHODS.get(2));
-        commonQueryParam.setPhasic(PHASE.get(2));
-        deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
-        if (!deviceRtData.isEmpty()) {
-            thdDataVO.setMINPhaseC(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
-        }
-
-
-        commonQueryParam.setDataType(METHODS.get(3));
-        commonQueryParam.setPhasic(PHASE.get(0));
-        deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
-        if (!deviceRtData.isEmpty()) {
-            thdDataVO.setMAXPhaseA(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
-        }
-
-        commonQueryParam.setDataType(METHODS.get(3));
-        commonQueryParam.setPhasic(PHASE.get(1));
-        deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
-        if (!deviceRtData.isEmpty()) {
-            thdDataVO.setMAXPhaseB(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
-        }
-
-        commonQueryParam.setDataType(METHODS.get(3));
-        commonQueryParam.setPhasic(PHASE.get(2));
-        deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
-        if (!deviceRtData.isEmpty()) {
-            thdDataVO.setMAXPhaseC(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
-        }
-        return thdDataVO;
-    }
 
     @Override
     public void exportExcelRangTemplate(PowerStatisticsParam powerStatisticsParam, HttpServletResponse response) {
@@ -498,9 +480,9 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService {
         for (String time : times) {
             powerStatisticsParam.setSearchBeginTime(time);
             powerStatisticsParam.setSearchEndTime(time);
-            for (int i = 1; i <= 4; i++) {
+            for (int i = 1; i < 5; i++) {
                 powerStatisticsParam.setStatisticalId(i + "");
-                List<ThdDataVO> thdDataVOList = getTargetByTime(powerStatisticsParam);
+                List<ThdDataVO> thdDataVOList = getTargetByTimeDetail(powerStatisticsParam);
                 if (i != 1) {
                     for (ThdDataVO thdDataVO : thdDataVOList) {
                         switch (i) {

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

@@ -1,11 +1,14 @@
 package com.njcn.harmonic.service.activepowerrange.impl;
 
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.event.pojo.constant.Param;
 import com.njcn.harmonic.mapper.RActivePowerRangeMapper;
 import com.njcn.harmonic.pojo.po.RActivePowerRangePO;
 import com.njcn.harmonic.pojo.vo.PowerStatisticsTargetVO;
+import com.njcn.harmonic.pojo.vo.RActivePowerRangeVO;
 import com.njcn.harmonic.service.activepowerrange.RActivePowerRangeService;
 import com.njcn.influx.pojo.constant.InfluxDBTableConstant;
 import com.njcn.prepare.harmonic.pojo.param.RActivePowerRangeParam;
@@ -18,6 +21,7 @@ import java.text.DecimalFormat;
 import java.text.SimpleDateFormat;
 import java.time.format.DateTimeFormatter;
 import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * 有功功率趋势 服务实现类
@@ -52,61 +56,67 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl<RActivePowerRan
      * 间谐波电压含有率	data_inharm_v	v1-v16	0.5-15.5次间谐波电压含有率	有一个指标超标，则谐波电压超标
      * 电流不平衡度	data_i	i_unbalance	这个不确定，找宝哥确认下
      *
-     * @param rActivePowerRangeParam
+     * @param 
      * @return
      */
-    @Override
-    @Transactional(rollbackFor = Exception.class)
-    public List<PowerStatisticsTargetVO> record(RActivePowerRangeParam rActivePowerRangeParam) {
-
-        return null;
-    }
-
 
     @Override
-    public RActivePowerRangePO getDataByLineId(String lineId, String startTime, String endTime) {
+    public RActivePowerRangeVO 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)
-                .between(RActivePowerRangePO::getTimeId, startTime, endTime);
+                .eq(RActivePowerRangePO::getState, "1")
+                .between(RActivePowerRangePO::getTimeId, startTime, endTime)
+                .orderByAsc(RActivePowerRangePO::getTimeId)
+        ;
         List<RActivePowerRangePO> rActivePowerRangePOS = this.baseMapper.selectList(lambdaQueryWrapper);
         if (!rActivePowerRangePOS.isEmpty()) {
-            RActivePowerRangePO rActivePowerRangePO = new RActivePowerRangePO();
+            RActivePowerRangeVO rActivePowerRangePO = new RActivePowerRangeVO();
             rActivePowerRangePO.setLineId(lineId);
+            rActivePowerRangePO.setTimeId(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getTimeId).collect(Collectors.toList()));
+
+
             //多条记录则次数累加,是否越限只要有一个区间越限则统一视为该区间越限
-            for (RActivePowerRangePO rangePO : rActivePowerRangePOS) {
+            rActivePowerRangePO.setMinsNum0(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum0).sum());
-                rActivePowerRangePO.setMinsNum0(rangePO.getMinsNum0() + rActivePowerRangePO.getMinsNum0());
+            rActivePowerRangePO.setMinsNum1(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum1).sum());
-                rActivePowerRangePO.setMinsNum1(rangePO.getMinsNum1() + rActivePowerRangePO.getMinsNum1());
+            rActivePowerRangePO.setMinsNum2(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum2).sum());
-                rActivePowerRangePO.setMinsNum2(rangePO.getMinsNum2() + rActivePowerRangePO.getMinsNum2());
+            rActivePowerRangePO.setMinsNum3(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum3).sum());
-                rActivePowerRangePO.setMinsNum3(rangePO.getMinsNum3() + rActivePowerRangePO.getMinsNum3());
+            rActivePowerRangePO.setMinsNum4(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum4).sum());
-                rActivePowerRangePO.setMinsNum4(rangePO.getMinsNum4() + rActivePowerRangePO.getMinsNum4());
+            rActivePowerRangePO.setMinsNum5(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum5).sum());
-                rActivePowerRangePO.setMinsNum5(rangePO.getMinsNum5() + rActivePowerRangePO.getMinsNum5());
+            rActivePowerRangePO.setMinsNum6(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum6).sum());
-                rActivePowerRangePO.setMinsNum6(rangePO.getMinsNum6() + rActivePowerRangePO.getMinsNum6());
+            rActivePowerRangePO.setMinsNum7(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum7).sum());
-                rActivePowerRangePO.setMinsNum7(rangePO.getMinsNum7() + rActivePowerRangePO.getMinsNum7());
+            rActivePowerRangePO.setMinsNum8(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum8).sum());
-                rActivePowerRangePO.setMinsNum8(rangePO.getMinsNum8() + rActivePowerRangePO.getMinsNum8());
+            rActivePowerRangePO.setMinsNum9(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum9).sum());
-                rActivePowerRangePO.setMinsNum9(rangePO.getMinsNum9() + rActivePowerRangePO.getMinsNum9());
+            rActivePowerRangePO.setIsOrNot0(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum0).sum());
-                rActivePowerRangePO.setIsOrNot0(rangePO.getIsOrNot0() + rActivePowerRangePO.getIsOrNot0());
+            rActivePowerRangePO.setIsOrNot1(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum1).sum());
-                rActivePowerRangePO.setIsOrNot1(rangePO.getIsOrNot1() + rActivePowerRangePO.getIsOrNot1());
+            rActivePowerRangePO.setIsOrNot2(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum2).sum());
-                rActivePowerRangePO.setIsOrNot2(rangePO.getIsOrNot2() + rActivePowerRangePO.getIsOrNot2());
+            rActivePowerRangePO.setIsOrNot3(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum3).sum());
-                rActivePowerRangePO.setIsOrNot3(rangePO.getIsOrNot3() + rActivePowerRangePO.getIsOrNot3());
+            rActivePowerRangePO.setIsOrNot4(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum4).sum());
-                rActivePowerRangePO.setIsOrNot4(rangePO.getIsOrNot4() + rActivePowerRangePO.getIsOrNot4());
+            rActivePowerRangePO.setIsOrNot5(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum5).sum());
-                rActivePowerRangePO.setIsOrNot5(rangePO.getIsOrNot5() + rActivePowerRangePO.getIsOrNot5());
+            rActivePowerRangePO.setIsOrNot6(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum6).sum());
-                rActivePowerRangePO.setIsOrNot6(rangePO.getIsOrNot6() + rActivePowerRangePO.getIsOrNot6());
+            rActivePowerRangePO.setIsOrNot7(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum7).sum());
-                rActivePowerRangePO.setIsOrNot7(rangePO.getIsOrNot7() + rActivePowerRangePO.getIsOrNot7());
+            rActivePowerRangePO.setIsOrNot8(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum8).sum());
-                rActivePowerRangePO.setIsOrNot8(rangePO.getIsOrNot8() + rActivePowerRangePO.getIsOrNot8());
+            rActivePowerRangePO.setIsOrNot9(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum9).sum());
-                rActivePowerRangePO.setIsOrNot9(rangePO.getIsOrNot9() + rActivePowerRangePO.getIsOrNot9());
+
-                rActivePowerRangePO.setMinsTime0(rangePO.getMinsTime0() + "&" + rActivePowerRangePO.getMinsTime0());
+
-                rActivePowerRangePO.setMinsTime1(rangePO.getMinsTime1() + "&" + rActivePowerRangePO.getMinsTime1());
+            rActivePowerRangePO.setMinsTime0(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime0).collect(Collectors.toList()));
-                rActivePowerRangePO.setMinsTime2(rangePO.getMinsTime2() + "&" + rActivePowerRangePO.getMinsTime2());
+            rActivePowerRangePO.setMinsTime1(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime1).collect(Collectors.toList()));
-                rActivePowerRangePO.setMinsTime3(rangePO.getMinsTime3() + "&" + rActivePowerRangePO.getMinsTime3());
+            rActivePowerRangePO.setMinsTime2(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime2).collect(Collectors.toList()));
-                rActivePowerRangePO.setMinsTime4(rangePO.getMinsTime4() + "&" + rActivePowerRangePO.getMinsTime4());
+            rActivePowerRangePO.setMinsTime3(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime3).collect(Collectors.toList()));
-                rActivePowerRangePO.setMinsTime5(rangePO.getMinsTime5() + "&" + rActivePowerRangePO.getMinsTime5());
+            rActivePowerRangePO.setMinsTime4(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime4).collect(Collectors.toList()));
-                rActivePowerRangePO.setMinsTime6(rangePO.getMinsTime6() + "&" + rActivePowerRangePO.getMinsTime6());
+            rActivePowerRangePO.setMinsTime5(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime5).collect(Collectors.toList()));
-                rActivePowerRangePO.setMinsTime7(rangePO.getMinsTime7() + "&" + rActivePowerRangePO.getMinsTime7());
+            rActivePowerRangePO.setMinsTime6(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime6).collect(Collectors.toList()));
-                rActivePowerRangePO.setMinsTime8(rangePO.getMinsTime8() + "&" + rActivePowerRangePO.getMinsTime8());
+            rActivePowerRangePO.setMinsTime7(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime7).collect(Collectors.toList()));
-                rActivePowerRangePO.setMinsTime9(rangePO.getMinsTime9() + "&" + rActivePowerRangePO.getMinsTime9());
+            rActivePowerRangePO.setMinsTime8(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime8).collect(Collectors.toList()));
-            }
+            rActivePowerRangePO.setMinsTime9(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime9).collect(Collectors.toList()));
             return rActivePowerRangePO;
         }
         return null;
     }
+
+    private String minsTimeJson(List<String> list) {
+        if (CollUtil.isNotEmpty(list)) {
+
+        }
+        return null;
+    }
 }