异常数据清洗

pqs-device/pq-device/pq-device-boot/pom.xml

@@ -60,6 +60,20 @@
             <scope>compile</scope>
         </dependency>
 
+        <dependency>
+            <groupId>com.njcn.platform</groupId>
+            <artifactId>data-processing-api</artifactId>
+            <version>1.0.0</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.njcn</groupId>
+            <artifactId>harmonic-api</artifactId>
+            <version>1.0.0</version>
+            <scope>compile</scope>
+        </dependency>
+
     </dependencies>
 
 </project>

pqs-device/pq-device/pq-device-boot/src/main/java/com/njcn/device/pq/controller/DataVerifyController.java

@@ -1,6 +1,7 @@
 package com.njcn.device.pq.controller;
 
 
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.njcn.common.pojo.annotation.OperateInfo;
 import com.njcn.common.pojo.enums.common.LogEnum;
 import com.njcn.common.pojo.enums.response.CommonResponseEnum;
@@ -8,6 +9,7 @@ import com.njcn.common.pojo.response.HttpResult;
 import com.njcn.common.utils.HttpResultUtil;
 import com.njcn.device.pq.pojo.param.dataClean.MonitorBaseParam;
 
+import com.njcn.device.pq.pojo.vo.dataClean.DetailAbnormalVO;
 import com.njcn.device.pq.pojo.vo.dataClean.VerifyMonitorVO;
 import com.njcn.device.pq.service.IDataVerifyService;
 import io.swagger.annotations.Api;
@@ -53,18 +55,45 @@ public class DataVerifyController extends BaseController {
     }
 
 
-/*    *//**
-     * 异常指标统计
-     *//*
+    /**
+     * 弹框-获取异常监测点列表
+     */
     @OperateInfo(info = LogEnum.BUSINESS_COMMON)
-    @PostMapping("/getAbnormalTarget")
-    @ApiOperation("获取异常监测点相关信息")
-    public HttpResult<PowerQualityIndicatorsVO> getAbnormalTarget(@RequestBody MonitorBaseParam monitorBaseParam){
-        String methodDescribe = getMethodDescribe("getAbnormalTarget");
-        PowerQualityIndicatorsVO powerQualityIndicatorsVO = iDataVerifyService.getAbnormalTarget(monitorBaseParam);
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, powerQualityIndicatorsVO, methodDescribe);
-    }*/
+    @PostMapping("/monitorAbnormalTable")
+    @ApiOperation("弹框-获取异常监测点列表")
+    public HttpResult<List<DetailAbnormalVO>> monitorAbnormalTable(@RequestBody MonitorBaseParam monitorBaseParam){
+        String methodDescribe = getMethodDescribe("monitorAbnormalDetail");
+        List<DetailAbnormalVO> page = iDataVerifyService.monitorAbnormalTable(monitorBaseParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, page, methodDescribe);
+    }
 
 
+
+    /**
+     * 获取稳态告警监测点相关信息
+     */
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/monitorAbnormalTableDetail")
+    @ApiOperation("弹框-获取异常监测点列表详情")
+    public HttpResult<List<DetailAbnormalVO.DetailAbnormalInnerVO>> monitorAbnormalTableDetail(@RequestBody MonitorBaseParam monitorBaseParam){
+        String methodDescribe = getMethodDescribe("monitorAbnormalTableDetail");
+        List<DetailAbnormalVO.DetailAbnormalInnerVO> list = iDataVerifyService.monitorAbnormalTableDetail(monitorBaseParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe);
+    }
+
+
+
+    /**
+     * 获取稳态告警数据
+     */
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/getMonitorLimitData")
+    @ApiOperation("获取稳态告警数据")
+    public HttpResult<VerifyMonitorVO> getMonitorLimitData(@RequestBody MonitorBaseParam monitorBaseParam){
+        String methodDescribe = getMethodDescribe("getMonitorLimitData");
+        VerifyMonitorVO verifyMonitorVO = iDataVerifyService.getMonitorVerifyData(monitorBaseParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, verifyMonitorVO, methodDescribe);
+    }
+
 }
 

pqs-device/pq-device/pq-device-boot/src/main/java/com/njcn/device/pq/mapper/mapping/LineMapper.xml

@@ -551,6 +551,7 @@
         substation.id subId,
         substation.Name subName,
         subscale.name subScale,
+        device.name deviceName,
         pqdevice.IP ip,
         factory.Name manufacturer,
         voltage.id voltageId,
@@ -575,7 +576,10 @@
         detail.Superiors_Substation,
         detail.Hang_Line,
         loadtype.name loadType,
-        detail.New_Station_Id as newStationId
+        detail.New_Station_Id as newStationId,
+        detail.obj_id,
+        detail.big_obj_type,
+        detail.small_obj_type
         FROM
         pq_line line,
         pq_line_detail detail,
@@ -1179,7 +1183,7 @@
     </select>
 
     <select id="getMonitorListDetail" resultType="com.njcn.device.biz.pojo.dto.LineDevGetDTO">
-        select line.id pointId,dev.id devId,0 type,1 lineType,lineDetail.Time_Interval as timeInterval
+        select line.id pointId,line.name pointName, dev.id devId,0 type,1 lineType,lineDetail.Time_Interval as timeInterval
                from pq_line line
         inner join pq_line_detail lineDetail on line.id = lineDetail.id
         inner join pq_line subv on line.pid = subv.id

pqs-device/pq-device/pq-device-boot/src/main/java/com/njcn/device/pq/service/IDataVerifyService.java

@@ -1,9 +1,11 @@
 package com.njcn.device.pq.service;
 
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.IService;
 import com.njcn.device.pq.pojo.param.dataClean.MonitorBaseParam;
 import com.njcn.device.pq.pojo.po.DataVerify;
 
+import com.njcn.device.pq.pojo.vo.dataClean.DetailAbnormalVO;
 import com.njcn.device.pq.pojo.vo.dataClean.VerifyMonitorVO;
 
 import java.util.List;
@@ -23,8 +25,13 @@ public interface IDataVerifyService extends IService<DataVerify> {
     VerifyMonitorVO getMonitorVerifyData(MonitorBaseParam monitorBaseParam);
 
 
+    List<DetailAbnormalVO> monitorAbnormalTable(MonitorBaseParam monitorBaseParam);
 
 
 
+    List<DetailAbnormalVO.DetailAbnormalInnerVO> monitorAbnormalTableDetail(MonitorBaseParam monitorBaseParam);
+
+
+    VerifyMonitorVO getMonitorLimitData(MonitorBaseParam monitorBaseParam);
 
 }

pqs-device/pq-device/pq-device-boot/src/main/java/com/njcn/device/pq/service/impl/DataVerifyServiceImpl.java

@@ -3,23 +3,48 @@ package com.njcn.device.pq.service.impl;
 
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.date.*;
+import com.alibaba.nacos.shaded.org.checkerframework.checker.units.qual.C;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.dataProcess.api.PqReasonableRangeFeignClient;
+import com.njcn.dataProcess.enums.DataCleanEnum;
+import com.njcn.dataProcess.param.DataCleanParam;
+import com.njcn.dataProcess.pojo.dto.PqReasonableRangeDto;
+import com.njcn.device.biz.pojo.dto.LineDevGetDTO;
 import com.njcn.device.pq.constant.Param;
 import com.njcn.device.pq.mapper.DataVerifyMapper;
+import com.njcn.device.pq.mapper.LineDetailMapper;
 import com.njcn.device.pq.mapper.LineMapper;
 import com.njcn.device.pq.pojo.param.dataClean.MonitorBaseParam;
 import com.njcn.device.pq.pojo.po.DataVerify;
 
+import com.njcn.device.pq.pojo.po.Line;
+import com.njcn.device.pq.pojo.po.LineDetail;
+import com.njcn.device.pq.pojo.vo.AreaLineInfoVO;
+import com.njcn.device.pq.pojo.vo.dataClean.DetailAbnormalVO;
+import com.njcn.device.pq.pojo.vo.dataClean.PowerQualityIndicatorsVO;
 import com.njcn.device.pq.pojo.vo.dataClean.VerifyMonitorVO;
+import com.njcn.device.pq.pojo.vo.dataClean.VerifyTargetVO;
 import com.njcn.device.pq.service.CommTerminalService;
 import com.njcn.device.pq.service.IDataVerifyService;
 import com.njcn.device.pq.service.LineService;
+import com.njcn.supervision.api.UserLedgerFeignClient;
+import com.njcn.supervision.pojo.vo.user.NewUserReportVO;
+import com.njcn.supervision.pojo.vo.user.UserLedgerVO;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.api.DictTreeFeignClient;
+import com.njcn.system.enums.DicDataEnum;
+import com.njcn.system.pojo.po.DictData;
+import com.njcn.system.pojo.po.SysDicTreePO;
 import lombok.RequiredArgsConstructor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 
 import java.text.DateFormat;
 import java.time.LocalDate;
+import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.*;
 import java.util.function.Function;
@@ -28,9 +53,10 @@ import java.util.stream.Collectors;
 
 import static com.njcn.device.pq.constant.Param.freq;
 
+
 /**
  * <p>
- *  服务实现类
+ * 服务实现类
  * </p>
  *
  * @author cdf
@@ -40,49 +66,150 @@ import static com.njcn.device.pq.constant.Param.freq;
 @RequiredArgsConstructor
 public class DataVerifyServiceImpl extends ServiceImpl<DataVerifyMapper, DataVerify> implements IDataVerifyService {
 
+    private static final Logger logger = LoggerFactory.getLogger(DataVerifyServiceImpl.class);
+
     private final CommTerminalService commTerminalService;
 
+    private final LineMapper lineMapper;
+
+    private final DictTreeFeignClient dictTreeFeignClient;
+
+    private final UserLedgerFeignClient userLedgerFeignClient;
+
+    private final PqReasonableRangeFeignClient pqReasonableRangeFeignClient;
+
+
+
     @Override
     public VerifyMonitorVO getMonitorVerifyData(MonitorBaseParam monitorBaseParam) {
-       List<String> monitorIds =  commTerminalService.getRunMonitorByDept(monitorBaseParam);
+        List<String> monitorIds = commTerminalService.getRunMonitorByDept(monitorBaseParam);
         LambdaQueryWrapper<DataVerify> lambdaQueryWrapper = new LambdaQueryWrapper<>();
-        lambdaQueryWrapper.between(DataVerify::getTime, DateUtil.beginOfDay(DateUtil.parse(monitorBaseParam.getSearchBeginTime())),DateUtil.endOfDay(DateUtil.parse(monitorBaseParam.getSearchEndTime())))
-                .in(DataVerify::getLineId,monitorIds);
+        lambdaQueryWrapper.between(DataVerify::getTime, DateUtil.beginOfDay(DateUtil.parse(monitorBaseParam.getSearchBeginTime())), DateUtil.endOfDay(DateUtil.parse(monitorBaseParam.getSearchEndTime())))
+                .in(DataVerify::getLineId, monitorIds).orderByAsc(DataVerify::getTime);
         List<DataVerify> dataVerifyList = this.list(lambdaQueryWrapper);
         VerifyMonitorVO verifyMonitorVO = new VerifyMonitorVO();
         verifyMonitorVO.setRunNum(monitorIds.size());
         int count = dataVerifyList.stream().collect(Collectors.groupingBy(DataVerify::getLineId)).size();
         verifyMonitorVO.setAbnormalNum(count);
 
-        List<Map<String, Object>> mapList = getRangeAbnormalMonitor(monitorBaseParam,dataVerifyList);
+        List<Map<String, Object>> mapList = getRangeAbnormalMonitor(monitorBaseParam, dataVerifyList);
         verifyMonitorVO.setMapList(mapList);
-        getAbnormalTarget(dataVerifyList,verifyMonitorVO);
+        verifyMonitorVO.setTargetList(getAbnormalTarget(dataVerifyList));
+        verifyMonitorVO.setMonitorAlarmInfo(getAbnormalTable(dataVerifyList, monitorBaseParam));
         return verifyMonitorVO;
     }
 
+    @Override
+    public List<DetailAbnormalVO> monitorAbnormalTable(MonitorBaseParam monitorBaseParam) {
+        List<DetailAbnormalVO> result = new ArrayList<>();
+        LambdaQueryWrapper<LineDetail> lineDetailQuery = new LambdaQueryWrapper<>();
+        lineDetailQuery.select(LineDetail::getId, LineDetail::getTimeInterval).in(LineDetail::getId, monitorBaseParam.getMonitorIds());
+        List<LineDevGetDTO> lineDetailList = lineMapper.getMonitorListDetail(monitorBaseParam.getMonitorIds());
+        Map<String, LineDevGetDTO> lineDetailMap = lineDetailList.stream().collect(Collectors.toMap(LineDevGetDTO::getPointId, Function.identity()));
+
+        LambdaQueryWrapper<DataVerify> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.between(DataVerify::getTime, DateUtil.beginOfDay(DateUtil.parse(monitorBaseParam.getSearchBeginTime())), DateUtil.endOfDay(DateUtil.parse(monitorBaseParam.getSearchEndTime())))
+                .in(DataVerify::getLineId, monitorBaseParam.getMonitorIds()).orderByAsc(DataVerify::getTime);
+        List<DataVerify> dataVerifyList = this.list(lambdaQueryWrapper);
+        Map<String, List<DataVerify>> dataMap = dataVerifyList.stream().collect(Collectors.groupingBy(it -> it.getTime().format(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN))));
+        dataMap.forEach((dateStr, data) -> {
+            Map<String, List<DataVerify>> lineMap = data.stream().collect(Collectors.groupingBy(DataVerify::getLineId));
+            lineMap.forEach((lineId, lineList) -> {
+                long count = lineList.stream().map(DataVerify::getTime).distinct().count();
+                DetailAbnormalVO detailAbnormalVO = new DetailAbnormalVO();
+                LineDevGetDTO lineDevGetDTO = lineDetailMap.get(lineId);
+                detailAbnormalVO.setTimeSum(lineDevGetDTO.getTimeInterval() * count);
+                detailAbnormalVO.setDate(dateStr);
+                detailAbnormalVO.setMonitorName(lineDevGetDTO.getPointName());
+                detailAbnormalVO.setMonitorId(lineDevGetDTO.getPointId());
+                result.add(detailAbnormalVO);
+            });
+        });
+        return result;
+    }
+
+    @Override
+    public List<DetailAbnormalVO.DetailAbnormalInnerVO> monitorAbnormalTableDetail(MonitorBaseParam monitorBaseParam) {
+        DataCleanParam dataCleanParam = new DataCleanParam();
+        dataCleanParam.setSystemType(DataCleanEnum.Pqs.getCode());
+        List<PqReasonableRangeDto> pqReasonableRangeDtoList = pqReasonableRangeFeignClient.getData(dataCleanParam).getData();
+        Map<String, PqReasonableRangeDto> dtoMap = pqReasonableRangeDtoList.stream().collect(Collectors.toMap(it -> it.getIndexCode() + it.getInfluxdbTableName(), Function.identity()));
+
+
+        List<DetailAbnormalVO.DetailAbnormalInnerVO> result = new ArrayList<>();
+        LambdaQueryWrapper<DataVerify> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.between(DataVerify::getTime, DateUtil.beginOfDay(DateUtil.parse(monitorBaseParam.getSearchBeginTime())), DateUtil.endOfDay(DateUtil.parse(monitorBaseParam.getSearchBeginTime())))
+                .eq(DataVerify::getLineId, monitorBaseParam.getMonitorId()).orderByAsc(DataVerify::getTime);
+        List<DataVerify> dataVerifyList = this.list(lambdaQueryWrapper);
+
+        Map<LocalDateTime, List<DataVerify>> listMap = dataVerifyList.stream().collect(Collectors.groupingBy(DataVerify::getTime));
+        listMap.forEach((time, timeList) -> {
+            Map<String,List<DataVerify>> indexMap = timeList.stream().collect(Collectors.groupingBy(it->it.getIndexCode()+"&"+it.getIndexTable()+"&"+it.getIndexName()));
+            indexMap.forEach((target, list) -> {
+                Map<String, List<DataVerify>> phaseMap = list.stream().collect(Collectors.groupingBy(DataVerify::getPhasicType));
+                phaseMap.forEach((phaseKey, valueList) -> {
+                    DetailAbnormalVO.DetailAbnormalInnerVO vo = new DetailAbnormalVO.DetailAbnormalInnerVO();
+                    vo.setTime(time.format(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)));
+                    String[] temKey = target.split("&");
+                    vo.setTargetName(temKey[2]);
+                    vo.setTargetKey(temKey[0]+temKey[1]);
+                    vo.setPhaseType(phaseKey);
+                    valueList.forEach(it->{
+                        switch (it.getValueType()){
+                            case "AVG":
+                                vo.setAvg(it.getAbnormalValue().toString());
+                                break;
+                            case "MAX":
+                                vo.setMax(it.getAbnormalValue().toString());
+                                break;
+                            case "MIN":
+                                vo.setMin(it.getAbnormalValue().toString());
+                                break;
+                            case "CP95":
+                                vo.setCp95(it.getAbnormalValue().toString());
+                                break;
+                        }
+                        PqReasonableRangeDto pqReasonableRangeDto = dtoMap.get(temKey[0]+temKey[1]);
+                        vo.setRangeDesc(pqReasonableRangeDto.getMinValue()+"~"+pqReasonableRangeDto.getMaxValue());
+                        result.add(vo);
+                    });
+                });
+            });
+        });
+
+        return result;
+    }
+
+    @Override
+    public VerifyMonitorVO getMonitorLimitData(MonitorBaseParam monitorBaseParam) {
+        List<String> monitorIds = commTerminalService.getRunMonitorByDept(monitorBaseParam);
+
+        return null;
+    }
+
     /**
      * 时间范围异常测点数量
      */
-    private List<Map<String, Object>> getRangeAbnormalMonitor(MonitorBaseParam monitorBaseParam,List<DataVerify> dataVerifyList) {
+    private List<Map<String, Object>> getRangeAbnormalMonitor(MonitorBaseParam monitorBaseParam, List<DataVerify> dataVerifyList) {
         List<Map<String, Object>> result = new ArrayList<>();
         DateTime startTime = DateUtil.parse(monitorBaseParam.getSearchBeginTime());
         DateTime endTime = DateUtil.parse(monitorBaseParam.getSearchEndTime());
-        if(startTime.year() == endTime.year() && startTime.month() == endTime.month()){
-            DateRange ranged = DateUtil.range(DateUtil.parse(monitorBaseParam.getSearchBeginTime()),DateUtil.parse(monitorBaseParam.getSearchEndTime()), DateField.DAY_OF_MONTH);
-                Map<String,Integer> map = dataVerifyList.stream().collect(Collectors.groupingBy(it->it.getTime().format(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)),
-                        Collectors.mapping(DataVerify::getLineId, Collectors.collectingAndThen(Collectors.toSet(), Set::size))));
-                for (DateTime dateTime : ranged) {
-                    Map<String, Object> rangeMap = new HashMap<>();
-                    String time = DateUtil.format(dateTime, DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN));
-                    rangeMap.put("time", time);
-                    rangeMap.put("val", map.getOrDefault(time, 0));
-                    result.add(rangeMap);
-                }
-        }else {
+        if (startTime.year() == endTime.year() && startTime.month() == endTime.month()) {
+            DateRange ranged = DateUtil.range(DateUtil.parse(monitorBaseParam.getSearchBeginTime()), DateUtil.parse(monitorBaseParam.getSearchEndTime()), DateField.DAY_OF_MONTH);
+            Map<String, Integer> map = dataVerifyList.stream().collect(Collectors.groupingBy(it -> it.getTime().format(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)),
+                    Collectors.mapping(DataVerify::getLineId, Collectors.collectingAndThen(Collectors.toSet(), Set::size))));
+            for (DateTime dateTime : ranged) {
+                Map<String, Object> rangeMap = new HashMap<>();
+                String time = DateUtil.format(dateTime, DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN));
+                rangeMap.put("time", time);
+                rangeMap.put("val", map.getOrDefault(time, 0));
+                result.add(rangeMap);
+            }
+        } else {
             //不在一个月则展示月数据
-            DateRange ranged = DateUtil.range(DateUtil.parse(monitorBaseParam.getSearchBeginTime()),DateUtil.parse(monitorBaseParam.getSearchEndTime()), DateField.MONTH);
-            if(CollUtil.isNotEmpty(dataVerifyList)){
-                Map<String,Integer> map = dataVerifyList.stream().collect(Collectors.groupingBy(it->it.getTime().format(DateTimeFormatter.ofPattern(DatePattern.NORM_MONTH_PATTERN)),
+            DateRange ranged = DateUtil.range(DateUtil.parse(monitorBaseParam.getSearchBeginTime()), DateUtil.parse(monitorBaseParam.getSearchEndTime()), DateField.MONTH);
+            if (CollUtil.isNotEmpty(dataVerifyList)) {
+                Map<String, Integer> map = dataVerifyList.stream().collect(Collectors.groupingBy(it -> it.getTime().format(DateTimeFormatter.ofPattern(DatePattern.NORM_MONTH_PATTERN)),
                         Collectors.mapping(DataVerify::getLineId, Collectors.collectingAndThen(Collectors.toSet(), Set::size))));
                 for (DateTime dateTime : ranged) {
                     Map<String, Object> rangeMap = new HashMap<>();
@@ -100,101 +227,198 @@ public class DataVerifyServiceImpl extends ServiceImpl<DataVerifyMapper, DataVer
     /**
      * 指标异常测点数量
      */
-    public void getAbnormalTarget(List<DataVerify> dataVerifyList,VerifyMonitorVO powerQualityIndicatorsVO) {
-        Map<String,Set<String>> map = dataVerifyList.stream().collect(Collectors.groupingBy(it->it.getIndexCode()+"$"+it.getIndexTable(),Collectors.mapping(DataVerify::getLineId, Collectors.toSet())));
-        Pattern patternPhasic = Pattern.compile("v_(2|[3-9]|[1-4][0-9]|50)\\$data_harmphasic_v");
-        Pattern patternRate = Pattern.compile("v_(2|[3-9]|[1-4][0-9]|50)\\$data_harmrate_v");
-        Pattern patternInRate = Pattern.compile("v_(2|[3-9]|[1-4][0-9]|50)\\$data_inharmrate_v");
+    public List<VerifyTargetVO> getAbnormalTarget(List<DataVerify> dataVerifyList) {
+        List<VerifyTargetVO> voList = new ArrayList<>();
+        Map<String, Set<String>> dataMap = dataVerifyList.stream().collect(Collectors.groupingBy(it -> it.getIndexCode() + it.getIndexTable(), Collectors.mapping(DataVerify::getLineId, Collectors.toSet())));
+ /*       Pattern patternPhasic = Pattern.compile("v_(2|[3-9]|[1-4][0-9]|50)\\$DataHarmPhasicV");
+        Pattern patternRate = Pattern.compile("v_(2|[3-9]|[1-4][0-9]|50)\\$DataHarmRateV");
+        Pattern patternInRate = Pattern.compile("v_(2|[3-9]|[1-4][0-9]|50)\\$DataInHarmRateV");
 
         Set<String> harmPhasicSet = new HashSet<>();
         Set<String> harmVSet = new HashSet<>();
         Set<String> inHarmVSet = new HashSet<>();
-        Set<String> vRmsSet = new HashSet<>();
+        Set<String> vRmsSet = new HashSet<>();*/
+
+        DataCleanParam dataCleanParam = new DataCleanParam();
+        dataCleanParam.setSystemType(DataCleanEnum.Pqs.getCode());
+        List<PqReasonableRangeDto> pqReasonableRangeDtoList = pqReasonableRangeFeignClient.getData(dataCleanParam).getData();
+        Map<String, PqReasonableRangeDto> dtoMap = pqReasonableRangeDtoList.stream().collect(Collectors.toMap(it -> it.getIndexCode() + it.getInfluxdbTableName(), Function.identity()));
 
         //正序、负序和零序电压
-        Set<String> posVSet = new HashSet<>();
-        map.forEach((key,num)->{
-            if(patternPhasic.matcher(key).matches()){
-                key = Param.phasic_rate_$;
-            }else if(patternRate.matcher(key).matches()){
-                key = Param.v_rate;
-            }else if(patternInRate.matcher(key).matches()){
-                key = Param.in_v_rate;
+        List<VerifyTargetVO> result = new ArrayList<>();
+        dataMap.forEach((key, num) -> {
+            if (dtoMap.containsKey(key)) {
+                PqReasonableRangeDto desc = dtoMap.get(key);
+                assEmb(num, desc, result);
+            } else {
+                logger.error("存在未知异常指标: {}", key);
             }
 
-            switch (key){
-                case freq:
-                    powerQualityIndicatorsVO.setFrequency(num.size());
-                    break;
-                case Param.freq_dev:
-                    powerQualityIndicatorsVO.setFrequencyDeviation(num.size());
-                    break;
-                case Param.rms_v:
-                case Param.rms_lvr:
-                    vRmsSet.addAll(num);
-                    break;
-                case Param.vu_dev:
-                    powerQualityIndicatorsVO.setVoltageDeviation(num.size());
-                    break;
-                case Param.rms_i:
-                    powerQualityIndicatorsVO.setCurrentRms(num.size());
-                    break;
-                case Param.v_thd:
-                    powerQualityIndicatorsVO.setVoltageTotalHarmonicDistortion(num.size());
-                    break;
-                case Param.v_1_v:
-                    powerQualityIndicatorsVO.setPhaseOrLineVoltageFundamentalRms(num.size());
-                    break;
-                case Param.phasic_v_1:
-                    powerQualityIndicatorsVO.setPhaseOrLineVoltageFundamentalPhaseAngle(num.size());
-                    break;
-                case Param.phasic_rate_$:
-                    harmPhasicSet.addAll(num);
-                    break;
-                case Param.v_rate:
-                    harmVSet.addAll(num);
-                    break;
-                case Param.in_v_rate:
-                    inHarmVSet.addAll(num);
-                    break;
-                case Param.v_zero:
-                case Param.v_neg:
-                case Param.v_pos:
-                    posVSet.addAll(num);
-                    break;
-                case Param.v_unbalance:
-                    powerQualityIndicatorsVO.setBalanceV(num.size());
-                    break;
-                case Param.fluc:
-                    powerQualityIndicatorsVO.setVoltageFluctuation(num.size());
-                    break;
-                case Param.plt:
-                    powerQualityIndicatorsVO.setShortTermFlickerValue(num.size());
-                    break;
-                case Param.pst:
-                    powerQualityIndicatorsVO.setLongTermFlickerValue(num.size());
-                    break;
-                default:
-                    System.out.println("存在未知指标:"+key);
-                    break;
-            }
+
+
+           /* if((DataCleanEnum.Freq.getCode()+DataCleanEnum.DataV).equals(key)){
+               desc =  dtoMap.get(DataCleanEnum.Freq.getCode()+DataCleanEnum.DataV);
+               assEmb(num,desc,result);
+            }else if((DataCleanEnum.FreqDev.getCode()+DataCleanEnum.DataV).equals(key)){
+                desc =  dtoMap.get(DataCleanEnum.FreqDev.getCode()+DataCleanEnum.DataV);
+                assEmb(num,desc,result);
+            }else if((DataCleanEnum.RmsV.getCode()+DataCleanEnum.DataV).equals(key) || (DataCleanEnum.RmsLvr.getCode()+DataCleanEnum.DataV).equals(key)){
+                vRmsSet.addAll(num);
+            }else if((DataCleanEnum.VuDev.getCode()+DataCleanEnum.DataV).equals(key)){
+                desc =  dtoMap.get(DataCleanEnum.VuDev.getCode()+DataCleanEnum.DataV);
+                assEmb(num,desc,result);
+            }else if((DataCleanEnum.RmsI.getCode()+DataCleanEnum.DataI).equals(key)){
+                desc =  dtoMap.get(DataCleanEnum.RmsI.getCode()+DataCleanEnum.DataI);
+                assEmb(num,desc,result);
+            }else if((DataCleanEnum.VThd.getCode()+DataCleanEnum.DataV).equals(key)){
+                desc =  dtoMap.get(DataCleanEnum.VThd.getCode()+DataCleanEnum.DataV);
+                assEmb(num,desc,result);
+            }else if((DataCleanEnum.V_1.getCode()+DataCleanEnum.DataV).equals(key)){
+                desc =  dtoMap.get(DataCleanEnum.V_1.getCode()+DataCleanEnum.DataV);
+                assEmb(num,desc,result);
+            }else if((DataCleanEnum.V_1.getCode()+DataCleanEnum.DataHarmPhasicV).equals(key)){
+                desc =  dtoMap.get(DataCleanEnum.V_1.getCode()+DataCleanEnum.DataHarmPhasicV);
+                assEmb(num,desc,result);
+            }else if((DataCleanEnum.V.getCode()+DataCleanEnum.DataHarmPhasicV).equals(key)){
+                harmPhasicSet.addAll(num);
+            }else if((DataCleanEnum.V_Rate.getCode()+DataCleanEnum.DataV).equals(key)){
+                harmVSet.addAll(num);
+            }else if((DataCleanEnum.V_InHarm.getCode()+DataCleanEnum.DataInHarmV).equals(key)){
+                harmVSet.addAll(num);
+            }else if((DataCleanEnum.VZero.getCode()+DataCleanEnum.DataV).equals(key)){
+                desc =  dtoMap.get(DataCleanEnum.VZero.getCode()+DataCleanEnum.DataV);
+                assEmb(num,desc,result);
+            }else if((DataCleanEnum.VPos.getCode()+DataCleanEnum.DataV).equals(key)){
+                desc =  dtoMap.get(DataCleanEnum.VPos.getCode()+DataCleanEnum.DataV);
+                assEmb(num,desc,result);
+            }else if((DataCleanEnum.VNeg.getCode()+DataCleanEnum.DataV).equals(key)){
+                desc =  dtoMap.get(DataCleanEnum.VNeg.getCode()+DataCleanEnum.DataV);
+                assEmb(num,desc,result);
+            }else if((DataCleanEnum.VUnbalance.getCode()+DataCleanEnum.DataV).equals(key)){
+                desc =  dtoMap.get(DataCleanEnum.VUnbalance.getCode()+DataCleanEnum.DataV);
+                assEmb(num,desc,result);
+            }else if((DataCleanEnum.Fluc.getCode()+DataCleanEnum.DataFluc).equals(key)){
+                desc =  dtoMap.get(DataCleanEnum.Fluc.getCode()+DataCleanEnum.DataFluc);
+                assEmb(num,desc,result);
+            }else if((DataCleanEnum.Plt.getCode()+DataCleanEnum.DataPlt).equals(key)){
+                desc =  dtoMap.get(DataCleanEnum.Plt.getCode()+DataCleanEnum.DataPlt);
+                assEmb(num,desc,result);
+            }else if((DataCleanEnum.Pst.getCode()+DataCleanEnum.DataPlt).equals(key)){
+                desc =  dtoMap.get(DataCleanEnum.Pst.getCode()+DataCleanEnum.DataPlt);
+                assEmb(num,desc,result);
+            }else {
+                logger.warn("存在未知异常指标: {}", key);
+            }*/
+
         });
-        powerQualityIndicatorsVO.setHarmonicVoltagePhaseAngle(harmPhasicSet.size());
-        powerQualityIndicatorsVO.setHarmonicVoltageContentRate(harmVSet.size());
-        powerQualityIndicatorsVO.setInterHarmonicVoltageContentRate(inHarmVSet.size());
-        powerQualityIndicatorsVO.setPositiveNegativeZeroSequenceVoltage(posVSet.size());
-        powerQualityIndicatorsVO.setPhaseOrLineVoltageRms(vRmsSet.size());
+
+     /*   PqReasonableRangeDto desc =  dtoMap.get(DataCleanEnum.V.getCode()+DataCleanEnum.DataHarmPhasicV);
+        assEmb(harmPhasicSet,desc,result);
+        desc =  dtoMap.get(DataCleanEnum.V_Rate.getCode()+DataCleanEnum.DataHarmRateV);
+        assEmb(harmVSet,desc,result);
+        desc =  dtoMap.get(DataCleanEnum.V_InHarm.getCode()+DataCleanEnum.DataInHarmV);
+        assEmb(inHarmVSet,desc,result);
+        desc =  dtoMap.get(DataCleanEnum.RmsV.getCode()+DataCleanEnum.DataV);
+        assEmb(vRmsSet,desc,result);*/
+
+        Map<String, VerifyTargetVO> vMap = result.stream().collect(Collectors.toMap(VerifyTargetVO::getKey, Function.identity()));
+        Integer sort = 0;
+        Iterator<Map.Entry<String, PqReasonableRangeDto>> iterator = dtoMap.entrySet().iterator();
+        while (iterator.hasNext()) {
+            Map.Entry<String, PqReasonableRangeDto> entry = iterator.next();
+            if (vMap.containsKey(entry.getKey())) {
+                vMap.get(entry.getKey()).setSort(sort);
+            } else {
+                PqReasonableRangeDto dto = entry.getValue();
+                VerifyTargetVO verifyTargetVO = new VerifyTargetVO();
+                verifyTargetVO.setKey(dto.getIndexCode() + dto.getInfluxdbTableName());
+                verifyTargetVO.setTargetName(dto.getIndexName());
+                verifyTargetVO.setIds(new HashSet<>());
+                verifyTargetVO.setRangeDesc(dto.getMinValue() + "~" + dto.getMaxValue());
+                verifyTargetVO.setSort(sort);
+                result.add(verifyTargetVO);
+            }
+            sort++;
+        }
+        voList = result.stream().sorted(Comparator.comparing(VerifyTargetVO::getSort)).collect(Collectors.toList());
+        return voList;
+    }
+
+    private void assEmb(Set<String> ids, PqReasonableRangeDto dto, List<VerifyTargetVO> result) {
+        VerifyTargetVO verifyTargetVO = new VerifyTargetVO();
+        verifyTargetVO.setKey(dto.getIndexCode() + dto.getInfluxdbTableName());
+        verifyTargetVO.setTargetName(dto.getIndexName());
+        verifyTargetVO.setIds(ids);
+        verifyTargetVO.setRangeDesc(dto.getMinValue() + "~" + dto.getMaxValue());
+        result.add(verifyTargetVO);
     }
 
 
-
-    public void getAbnormalTable(List<DataVerify> dataVerifyList,VerifyMonitorVO powerQualityIndicatorsVO,MonitorBaseParam monitorBaseParam) {
-        Map<String,List<DataVerify>> dataMap = dataVerifyList.stream().collect(Collectors.groupingBy(DataVerify::getLineId));
-        dataMap.forEach((key,list)->{
-            list.stream().map(it->it.getTime().format(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN))).distinct().sorted(Comparator.comparing(Function.identity())).collect(Collectors.toList());
+    public List<PowerQualityIndicatorsVO> getAbnormalTable(List<DataVerify> dataVerifyList, MonitorBaseParam monitorBaseParam) {
+        List<PowerQualityIndicatorsVO> result = new ArrayList<>();
+        Map<String, List<DataVerify>> dataMap = dataVerifyList.stream().collect(Collectors.groupingBy(DataVerify::getLineId));
+        dataMap.forEach((key, list) -> {
+            List<LocalDate> dateList = list.stream().map(it -> it.getTime().toLocalDate()).distinct().sorted(Comparator.comparing(Function.identity())).collect(Collectors.toList());
+            Integer warnDay = monitorBaseParam.getWarnDayLimit();
+            Integer alarmDay = monitorBaseParam.getAlarmDayLimit();
+            //检查是否有连续指定天数的告警
+            boolean warnFlag = verData(dateList, warnDay);
+            boolean alarmFlag = verData(dateList, alarmDay);
+            if (warnFlag) {
+                PowerQualityIndicatorsVO vo = new PowerQualityIndicatorsVO();
+                vo.setMonitorId(key);
+                if (alarmFlag) {
+                    vo.setSeverity(1);
+                } else {
+                    vo.setSeverity(0);
+                }
+                vo.setAbnormalDay(dateList.size());
+                result.add(vo);
+            }
         });
+        if (CollUtil.isNotEmpty(result)) {
+            List<SysDicTreePO> dicTreePOList = dictTreeFeignClient.queryAllByType(Integer.valueOf(DicDataEnum.Obj_Type.getCode())).getData();
+            Map<String, SysDicTreePO> sysDicTreePOMap = dicTreePOList.stream().collect(Collectors.toMap(SysDicTreePO::getId, Function.identity()));
+            List<String> ids = result.stream().map(PowerQualityIndicatorsVO::getMonitorId).distinct().collect(Collectors.toList());
+            List<AreaLineInfoVO> areaLineInfoVOList = lineMapper.getBaseLineAreaInfo(ids, null, null);
+            Map<String, AreaLineInfoVO> areaMap = areaLineInfoVOList.stream().collect(Collectors.toMap(AreaLineInfoVO::getLineId, Function.identity()));
 
+            List<String> objIds = areaLineInfoVOList.stream().map(AreaLineInfoVO::getObjId).distinct().collect(Collectors.toList());
+            List<NewUserReportVO> userLedgerVOList = userLedgerFeignClient.getUserReportByIds(objIds).getData();
+            Map<String, NewUserReportVO> userMap = userLedgerVOList.stream().collect(Collectors.toMap(NewUserReportVO::getId, Function.identity()));
+            result.forEach(it -> {
+                if (areaMap.containsKey(it.getMonitorId())) {
+                    AreaLineInfoVO areaLineInfoVO = areaMap.get(it.getMonitorId());
+                    it.setMonitorName(areaLineInfoVO.getLineName());
+                    it.setStationName(areaLineInfoVO.getSubName());
+                    it.setDevName(areaLineInfoVO.getDeviceName());
+                    it.setVoltageLevel(areaLineInfoVO.getVoltageScale());
+                    if (sysDicTreePOMap.containsKey(areaLineInfoVO.getSmallObjType())) {
+                        it.setObjType(sysDicTreePOMap.get(areaLineInfoVO.getSmallObjType()).getName());
+                    }
+                    if (userMap.containsKey(areaLineInfoVO.getObjId())) {
+                        it.setObjName(userMap.get(areaLineInfoVO.getObjId()).getProjectName());
+                    }
+                }
+            });
+        }
+        return result;
     }
 
+    private Boolean verData(List<LocalDate> dateList, Integer day) {
+        for (int i = 0; i <= dateList.size() - day; i++) {
+            boolean isConsecutive = true;
+            for (int j = 1; j < day; j++) {
+                if (!dateList.get(i).plusDays(j).equals(dateList.get(i + j))) {
+                    isConsecutive = false;
+                    break;
+                }
+            }
+            if (isConsecutive) {
+                return true;
+            }
+        }
+        return false;
+    }
 
 }