feat(rstatlimitrate): 新增越限概率分布统计功能

- 添加越限程度概率分布接口及实现
- 添加越限时间概率分布接口及实现

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

@@ -0,0 +1,9 @@
+package com.njcn.harmonic.pojo.param;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class LimitProbabilityQueryParam extends MainLineStatLimitRateDetailsQueryParam {
+}

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

@@ -0,0 +1,24 @@
+package com.njcn.harmonic.pojo.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+@Data
+public class LimitProbabilityVO {
+
+    @ApiModelProperty("监测点id")
+    private String lineId;
+    @ApiModelProperty("监测点名称")
+    private String lineName;
+    @ApiModelProperty("指标名称")
+    private String indexName;
+    @ApiModelProperty("指标编码")
+    private String indexCode;
+    @ApiModelProperty("占比")
+    private double proportion;
+    @ApiModelProperty("越限程度档级对应次数")
+    private List<Map<Integer, Integer>> extentGrades;
+}

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

@@ -0,0 +1,21 @@
+package com.njcn.harmonic.pojo.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+@Data
+public class LimitTimeProbabilityVO {
+
+    @ApiModelProperty("时间段")
+    private String timePeriod;
+    @ApiModelProperty("次数")
+    private int times;
+    @ApiModelProperty("监测点id")
+    private String lineId;
+    @ApiModelProperty("监测点名称")
+    private String lineName;
+    @ApiModelProperty("指标名称")
+    private String indexName;
+    @ApiModelProperty("指标编码")
+    private String indexCode;
+}

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

@@ -7,13 +7,13 @@ import lombok.Data;
 public class TotalLimitTotalStatisticsVO {
 
     @ApiModelProperty("闪变越限占比")
-    private int flicker;
+    private double flicker;
     @ApiModelProperty("谐波电压越限占比")
-    private int uharm;
+    private double uharm;
     @ApiModelProperty("谐波电流越限占比")
-    private int iharm;
+    private double iharm;
     @ApiModelProperty("电压偏差越限占比")
-    private int voltageDev;
+    private double voltageDev;
     @ApiModelProperty("三相不平衡越限占比")
-    private int ubalance;
+    private double ubalance;
 }

pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDetailDController.java

@@ -10,8 +10,11 @@ import com.njcn.common.utils.HttpResultUtil;
 import com.njcn.harmonic.pojo.param.LimitCalendarQueryParam;
 import com.njcn.harmonic.pojo.param.LimitExtentDayQueryParam;
 import com.njcn.harmonic.pojo.param.LimitExtentQueryParam;
+import com.njcn.harmonic.pojo.param.LimitProbabilityQueryParam;
 import com.njcn.harmonic.pojo.vo.LimitCalendarVO;
 import com.njcn.harmonic.pojo.vo.LimitExtentVO;
+import com.njcn.harmonic.pojo.vo.LimitProbabilityVO;
+import com.njcn.harmonic.pojo.vo.LimitTimeProbabilityVO;
 import com.njcn.harmonic.rstatlimitrate.service.IRStatLimitRateDetailDService;
 import com.njcn.web.controller.BaseController;
 import io.swagger.annotations.Api;
@@ -59,4 +62,24 @@ public class RStatLimitRateDetailDController extends BaseController {
         return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
     }
 
+
+    @PostMapping("/limitRateDetailD/limitProbabilityData")
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @ApiOperation("获取指标越限程度概率分布数据")
+    public HttpResult<List<LimitProbabilityVO>> limitProbabilityData(@RequestBody LimitProbabilityQueryParam queryParam) {
+        String methodDescribe = getMethodDescribe("limitProbabilityData");
+        List<LimitProbabilityVO> result = limitRateDetailDService.limitProbabilityData(queryParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
+    }
+
+    @PostMapping("/limitRateDetailD/limitTimeProbabilityData")
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @ApiOperation("获取指标越限时间概率分布数据")
+    public HttpResult<List<LimitTimeProbabilityVO>> limitTimeProbabilityData(@RequestBody LimitProbabilityQueryParam queryParam) {
+        String methodDescribe = getMethodDescribe("limitTimeProbabilityData");
+        List<LimitTimeProbabilityVO> result = limitRateDetailDService.limitTimeProbabilityData(queryParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
+    }
+
+
 }

pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDetailDService.java

@@ -5,9 +5,12 @@ import com.baomidou.mybatisplus.extension.service.IService;
 import com.njcn.harmonic.pojo.param.LimitCalendarQueryParam;
 import com.njcn.harmonic.pojo.param.LimitExtentDayQueryParam;
 import com.njcn.harmonic.pojo.param.LimitExtentQueryParam;
+import com.njcn.harmonic.pojo.param.LimitProbabilityQueryParam;
 import com.njcn.harmonic.pojo.po.day.RStatLimitRateDetailDPO;
 import com.njcn.harmonic.pojo.vo.LimitCalendarVO;
 import com.njcn.harmonic.pojo.vo.LimitExtentVO;
+import com.njcn.harmonic.pojo.vo.LimitProbabilityVO;
+import com.njcn.harmonic.pojo.vo.LimitTimeProbabilityVO;
 
 import java.util.List;
 
@@ -20,4 +23,8 @@ public interface IRStatLimitRateDetailDService extends IService<RStatLimitRateDe
     JSONArray limitExtentDayData(LimitExtentDayQueryParam param);
 
     List<LimitCalendarVO> limitCalendarData(LimitCalendarQueryParam param);
+
+    List<LimitProbabilityVO> limitProbabilityData(LimitProbabilityQueryParam param);
+
+    List<LimitTimeProbabilityVO> limitTimeProbabilityData(LimitProbabilityQueryParam param);
 }

pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDServiceImpl.java

@@ -25,6 +25,9 @@ import com.njcn.system.pojo.po.DictData;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -45,6 +48,7 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
 
     private final CsLineFeignClient csLineFeignClient;
     private final DicDataFeignClient dicDataFeignClient;
+    private final DecimalFormat df = new DecimalFormat("#0.00");
 
     @Override
     public List<RStatLimitRateDPO> monitorIdsGetLimitRateInfo(String date, List<String> monitorIds) {
@@ -360,11 +364,11 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
                 iharm += iharmList.stream().max(Integer::compareTo).get();
             }
             if (totalTime != 0) {
-                statisticsVO.setFlicker(flickerTotalTime / totalTime * 100);
+                statisticsVO.setFlicker(Double.parseDouble(df.format(BigDecimal.valueOf(flickerTotalTime / totalTime * 100L).setScale(2, RoundingMode.HALF_UP).doubleValue())));
-                statisticsVO.setVoltageDev(voltageDevTotalTime / totalTime * 100);
+                statisticsVO.setVoltageDev(Double.parseDouble(df.format(BigDecimal.valueOf(voltageDevTotalTime / totalTime * 100L).setScale(2, RoundingMode.HALF_UP).doubleValue())));
-                statisticsVO.setUbalance(ubalanceTotalTime / totalTime * 100);
+                statisticsVO.setUbalance(Double.parseDouble(df.format(BigDecimal.valueOf(ubalanceTotalTime / totalTime * 100L).setScale(2, RoundingMode.HALF_UP).doubleValue())));
-                statisticsVO.setUharm(uharm / totalTime * 100);
+                statisticsVO.setUharm(Double.parseDouble(df.format(BigDecimal.valueOf(uharm / totalTime * 100L).setScale(2, RoundingMode.HALF_UP).doubleValue())));
-                statisticsVO.setIharm(iharm / totalTime * 100);
+                statisticsVO.setIharm(Double.parseDouble(df.format(BigDecimal.valueOf(iharm / totalTime * 100L).setScale(2, RoundingMode.HALF_UP).doubleValue())));
             }
             result.add(statisticsVO);
 

pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDetailDServiceImpl.java

@@ -17,14 +17,22 @@ import com.njcn.device.pq.api.OverLimitClient;
 import com.njcn.harmonic.pojo.param.LimitCalendarQueryParam;
 import com.njcn.harmonic.pojo.param.LimitExtentDayQueryParam;
 import com.njcn.harmonic.pojo.param.LimitExtentQueryParam;
+import com.njcn.harmonic.pojo.param.LimitProbabilityQueryParam;
+import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
 import com.njcn.harmonic.pojo.po.day.RStatLimitRateDetailDPO;
 import com.njcn.harmonic.pojo.vo.LimitCalendarVO;
 import com.njcn.harmonic.pojo.vo.LimitExtentVO;
+import com.njcn.harmonic.pojo.vo.LimitProbabilityVO;
+import com.njcn.harmonic.pojo.vo.LimitTimeProbabilityVO;
 import com.njcn.harmonic.rstatlimitrate.mapper.RStatLimitRateDetailDMapper;
+import com.njcn.harmonic.rstatlimitrate.service.IRStatLimitRateDService;
 import com.njcn.harmonic.rstatlimitrate.service.IRStatLimitRateDetailDService;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
 import java.time.LocalDate;
 import java.util.*;
 import java.util.stream.Collectors;
@@ -36,26 +44,53 @@ public class RStatLimitRateDetailDServiceImpl extends ServiceImpl<RStatLimitRate
 
     private final CsLineFeignClient csLineFeignClient;
     private final OverLimitClient overLimitClient;
+    private final IRStatLimitRateDService rStatLimitRateDService;
 
+    private final DecimalFormat df = new DecimalFormat("#0.00");
+
+    static Map<String, String> indexMap = new HashMap<>();
+    static List<List<Integer>> timePeriodList = new ArrayList<>();
+    static List<List<Integer>> extentPeriodList = new ArrayList<>();
+
+    static {
+        indexMap.put("flicker", "闪变");
+        indexMap.put("uharm", "谐波电压");
+        indexMap.put("iharm", "谐波电流");
+        indexMap.put("ubalance", "三相电压不平衡度");
+        indexMap.put("voltageDev", "电压偏差");
+        indexMap.put("freqDev", "频率偏差");
+
+        timePeriodList.add(Arrays.asList(0, 8));
+        timePeriodList.add(Arrays.asList(8, 12));
+        timePeriodList.add(Arrays.asList(12, 14));
+        timePeriodList.add(Arrays.asList(14, 18));
+        timePeriodList.add(Arrays.asList(18, 24));
+
+        extentPeriodList.add(Arrays.asList(0, 20));
+        extentPeriodList.add(Arrays.asList(20, 40));
+        extentPeriodList.add(Arrays.asList(40, 60));
+        extentPeriodList.add(Arrays.asList(60, 80));
+        extentPeriodList.add(Arrays.asList(80, 100));
+    }
 
     @Override
     public List<LimitExtentVO> limitExtentData(LimitExtentQueryParam param) {
         List<LimitExtentVO> result = new ArrayList<>();
         LimitExtentVO flicker = new LimitExtentVO();
         flicker.setCode("flicker");
-        flicker.setName("闪变");
+        flicker.setName(indexMap.get(flicker.getCode()));
         LimitExtentVO uharm = new LimitExtentVO();
         uharm.setCode("uharm");
-        uharm.setName("谐波电压");
+        uharm.setName(indexMap.get(uharm.getCode()));
         LimitExtentVO iharm = new LimitExtentVO();
         iharm.setCode("iharm");
-        iharm.setName("谐波电流");
+        iharm.setName(indexMap.get(iharm.getCode()));
         LimitExtentVO voltageDev = new LimitExtentVO();
         voltageDev.setCode("voltageDev");
-        voltageDev.setName("电压偏差");
+        voltageDev.setName(indexMap.get(voltageDev.getCode()));
         LimitExtentVO ubalance = new LimitExtentVO();
         ubalance.setCode("ubalance");
-        ubalance.setName("电压三相不平衡");
+        ubalance.setName(indexMap.get(ubalance.getCode()));
         List<RStatLimitRateDetailDPO> detailList = this.list(new LambdaQueryWrapper<RStatLimitRateDetailDPO>()
                 .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDetailDPO::getTime, param.getSearchBeginTime())
                 .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDetailDPO::getTime, param.getSearchEndTime())
@@ -196,7 +231,7 @@ public class RStatLimitRateDetailDServiceImpl extends ServiceImpl<RStatLimitRate
                                 String itemKey = StrUtil.sub(key, 0, key.length() - 8);
                                 float limitValue = overlimitJSON.getFloat(itemKey);
                                 if (limitValue != 0) {
-                                    float overlimitPercent = (maxValue - limitValue) / limitValue * 100;
+                                    double overlimitPercent = Double.parseDouble(df.format(BigDecimal.valueOf((maxValue - limitValue) / limitValue * 100).setScale(2, RoundingMode.HALF_UP).doubleValue()));
                                     if (overlimitPercent >= 80) {
                                         status = 2;
                                     }
@@ -214,6 +249,171 @@ public class RStatLimitRateDetailDServiceImpl extends ServiceImpl<RStatLimitRate
         return result;
     }
 
+    @Override
+    public List<LimitProbabilityVO> limitProbabilityData(LimitProbabilityQueryParam param) {
+        List<LimitProbabilityVO> result = new ArrayList<>();
+        List<RStatLimitRateDetailDPO> detailList = this.list(new LambdaQueryWrapper<RStatLimitRateDetailDPO>()
+                .eq(RStatLimitRateDetailDPO::getLineId, param.getLineId())
+                .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDetailDPO::getTime, param.getSearchBeginTime())
+                .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDetailDPO::getTime, param.getSearchEndTime())
+                .orderByAsc(RStatLimitRateDetailDPO::getTime)
+        );
+        List<RStatLimitRateDPO> lineRateList = rStatLimitRateDService
+                .list(new LambdaQueryWrapper<RStatLimitRateDPO>()
+                        .eq(RStatLimitRateDPO::getLineId, param.getLineId())
+                        .eq(RStatLimitRateDPO::getPhasicType, "T")
+                        .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime())
+                        .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime())
+                        .orderByAsc(RStatLimitRateDPO::getTime)
+                );
+        // 总次数
+        int totalTimes = lineRateList.stream().mapToInt(RStatLimitRateDPO::getAllTime).sum();
+
+        CsLinePO linePO = csLineFeignClient.getById(param.getLineId()).getData();
+        List<Overlimit> overlimitList = overLimitClient.getOverLimitByLineIds(Collections.singletonList(linePO.getLineId())).getData();
+        JSONObject overlimitJSON = null;
+        if (CollUtil.isNotEmpty(overlimitList)) {
+            overlimitJSON = JSONUtil.parseObj(overlimitList.get(0));
+        }
+        LimitProbabilityVO probabilityVO;
+        for (Map.Entry<String, String> indexEntry : indexMap.entrySet()) {
+            String indexCode = indexEntry.getKey();
+            probabilityVO = new LimitProbabilityVO();
+            probabilityVO.setIndexName(indexEntry.getValue());
+            probabilityVO.setIndexCode(indexCode);
+            probabilityVO.setLineId(linePO.getLineId());
+            probabilityVO.setLineName(linePO.getName());
+            // 计算占比
+            int limitTimes = 0;
+            for (RStatLimitRateDPO item : lineRateList) {
+                JSONObject entries = JSONUtil.parseObj(item);
+                List<Integer> valueList = new ArrayList<>();
+                for (Map.Entry<String, Object> entry : entries.entrySet()) {
+                    String key = entry.getKey();
+                    if (key.endsWith("Overtime")) {
+                        if (key.startsWith(indexCode)) {
+                            String value = entry.getValue().toString();
+                            Integer intValue = new Integer(value);
+                            valueList.add(intValue);
+                        }
+                    }
+                }
+                limitTimes += valueList.stream().max(Integer::compareTo).orElse(0);
+            }
+            if (totalTimes != 0) {
+                probabilityVO.setProportion(Double.parseDouble(df.format(BigDecimal.valueOf(limitTimes / totalTimes * 100L).setScale(2, RoundingMode.HALF_UP).doubleValue())));
+            } else {
+                probabilityVO.setProportion(0f);
+            }
+            // 计算越限程度
+            List<Double> extentValuesList = new ArrayList<>();
+            for (RStatLimitRateDetailDPO detail : detailList) {
+                JSONObject entries = JSONUtil.parseObj(detail);
+                for (Map.Entry<String, Object> dayEntry : entries.entrySet()) {
+                    String key = dayEntry.getKey();
+                    if (key.endsWith("Overtime") && key.startsWith(indexCode)) {
+                        double extentValue = 0;
+                        Object data = dayEntry.getValue();
+                        // 有数据有越限
+                        if (ObjectUtil.isNotEmpty(data)) {
+                            float maxValue = parseMaxValueFromJsonArray(data);
+                            if (overlimitJSON != null) {
+                                String itemKey = StrUtil.sub(key, 0, key.length() - 8);
+                                double limitValue = overlimitJSON.getDouble(itemKey);
+                                if (limitValue != 0) {
+                                    extentValue = Double.parseDouble(df.format(BigDecimal.valueOf((maxValue - limitValue) / limitValue * 100).setScale(2, RoundingMode.HALF_UP).doubleValue()));
+
+                                }
+                            }
+                        }
+                        extentValuesList.add(extentValue);
+                    }
+                }
+
+            }
+            List<Map<Integer, Integer>> extentGrades = new ArrayList<>();
+            for (int i = 0; i < extentPeriodList.size(); i++) {
+                Map<Integer, Integer> grade = new HashMap<>();
+                int times = 0;
+                for (Double extentValue : extentValuesList) {
+                    List<Integer> period = extentPeriodList.get(i);
+                    Integer start = period.get(0);
+                    Integer end = period.get(1);
+                    if (extentValue > start && extentValue <= end) {
+                        times++;
+                    }
+                }
+                grade.put(i, times);
+                extentGrades.add(grade);
+            }
+            probabilityVO.setExtentGrades(extentGrades);
+            result.add(probabilityVO);
+        }
+        return result;
+    }
+
+    @Override
+    public List<LimitTimeProbabilityVO> limitTimeProbabilityData(LimitProbabilityQueryParam param) {
+
+        List<LimitTimeProbabilityVO> result = new ArrayList<>();
+        List<RStatLimitRateDetailDPO> detailList = this.list(new LambdaQueryWrapper<RStatLimitRateDetailDPO>()
+                .eq(RStatLimitRateDetailDPO::getLineId, param.getLineId())
+                .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDetailDPO::getTime, param.getSearchBeginTime())
+                .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDetailDPO::getTime, param.getSearchEndTime())
+                .orderByAsc(RStatLimitRateDetailDPO::getTime)
+        );
+        CsLinePO linePO = csLineFeignClient.getById(param.getLineId()).getData();
+
+        LimitTimeProbabilityVO timeProbabilityVO;
+        JSONArray detailJSONArray = null;
+        if (CollUtil.isNotEmpty(detailList)) {
+            detailJSONArray = JSONUtil.parseArray(detailList);
+        }
+        for (Map.Entry<String, String> entry : indexMap.entrySet()) {
+            String indexCode = entry.getKey();
+            for (List<Integer> period : timePeriodList) {
+                timeProbabilityVO = new LimitTimeProbabilityVO();
+                timeProbabilityVO.setLineId(linePO.getLineId());
+                timeProbabilityVO.setLineName(linePO.getName());
+                timeProbabilityVO.setIndexName(entry.getValue());
+                timeProbabilityVO.setIndexCode(indexCode);
+                int start = period.get(0);
+                int end = period.get(1);
+                timeProbabilityVO.setTimePeriod(start + "时-" + end + "时");
+                int times = 0;
+                if (CollUtil.isNotEmpty(detailJSONArray)) {
+                    for (int i = 0; i < detailJSONArray.size(); i++) {
+                        JSONObject detail = detailJSONArray.getJSONObject(i);
+                        // 获取包含的指标key
+                        List<String> includeKeys = detail.keySet().stream().filter(f -> f.startsWith(indexCode)).collect(Collectors.toList());
+                        for (String key : includeKeys) {
+                            // 获取指标越限数据
+                            // [{"time": "17:10:00,17:20:00,17:30:00", "value": "7.1092,7.1092,7.1093", "phasic": "A", "valueType": "CP95"}, {"time": "17:10:00,17:20:00,17:30:00", "value": "7.8081,7.808,7.8081", "phasic": "C", "valueType": "CP95"}, {"time": "17:10:00,17:20:00,17:30:00", "value": "7.5095,7.5095,7.5095", "phasic": "B", "valueType": "CP95"}]
+                            JSONArray values = detail.getJSONArray(key);
+                            if (CollUtil.isNotEmpty(values)) {
+                                // 取出第一个数据
+                                JSONObject value = values.getJSONObject(0);
+                                // 获取时间
+                                String time = value.getStr("time");
+                                for (String t : StrUtil.split(time, StrUtil.COMMA)) {
+                                    // 判断在时间段内，次数加一
+                                    int hour = Integer.parseInt(t.substring(0, 2));
+                                    if (hour >= start && hour < end) {
+                                        times++;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                timeProbabilityVO.setTimes(times);
+                result.add(timeProbabilityVO);
+            }
+        }
+
+        return result;
+    }
+
     /**
      * 设置LimitExtentVO的最大值和相关信息
      */
@@ -376,4 +576,5 @@ public class RStatLimitRateDetailDServiceImpl extends ServiceImpl<RStatLimitRate
         }
         return null;
     }
+
 }