异常数据清洗功能开发

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

@@ -10,6 +10,7 @@ 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.PowerQualityIndicatorsVO;
 import com.njcn.device.pq.pojo.vo.dataClean.VerifyMonitorVO;
 import com.njcn.device.pq.service.IDataVerifyService;
 import io.swagger.annotations.Api;
@@ -47,20 +48,29 @@ public class DataVerifyController extends BaseController {
      */
     @OperateInfo(info = LogEnum.BUSINESS_COMMON)
     @PostMapping("/getMonitorVerifyData")
-    @ApiOperation("获取异常监测点相关信息")
+    @ApiOperation("异常-获取异常数据主页面")
     public HttpResult<VerifyMonitorVO> getMonitorVerifyData(@RequestBody MonitorBaseParam monitorBaseParam){
         String methodDescribe = getMethodDescribe("getMonitorVerifyData");
         VerifyMonitorVO verifyMonitorVO = iDataVerifyService.getMonitorVerifyData(monitorBaseParam);
         return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, verifyMonitorVO, methodDescribe);
     }
 
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/getMonitorVerifyDay")
+    @ApiOperation("异常-更新按钮-获取异常数据列表")
+    public HttpResult<List<PowerQualityIndicatorsVO>> getMonitorVerifyDay(@RequestBody MonitorBaseParam monitorBaseParam){
+        String methodDescribe = getMethodDescribe("getMonitorVerifyDay");
+        List<PowerQualityIndicatorsVO> list = iDataVerifyService.getMonitorVerifyDay(monitorBaseParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe);
+    }
+
 
     /**
      * 弹框-获取异常监测点列表
      */
     @OperateInfo(info = LogEnum.BUSINESS_COMMON)
     @PostMapping("/monitorAbnormalTable")
-    @ApiOperation("弹框-获取异常监测点列表")
+    @ApiOperation("异常-弹框-获取异常监测点列表")
     public HttpResult<List<DetailAbnormalVO>> monitorAbnormalTable(@RequestBody MonitorBaseParam monitorBaseParam){
         String methodDescribe = getMethodDescribe("monitorAbnormalDetail");
         List<DetailAbnormalVO> page = iDataVerifyService.monitorAbnormalTable(monitorBaseParam);
@@ -91,9 +101,44 @@ public class DataVerifyController extends BaseController {
     @ApiOperation("获取稳态告警数据")
     public HttpResult<VerifyMonitorVO> getMonitorLimitData(@RequestBody MonitorBaseParam monitorBaseParam){
         String methodDescribe = getMethodDescribe("getMonitorLimitData");
-        VerifyMonitorVO verifyMonitorVO = iDataVerifyService.getMonitorVerifyData(monitorBaseParam);
+        VerifyMonitorVO verifyMonitorVO = iDataVerifyService.getMonitorLimitData(monitorBaseParam);
         return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, verifyMonitorVO, methodDescribe);
     }
 
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/getMonitorLimitDataDay")
+    @ApiOperation("更新按钮-获取稳态告警数据")
+    public HttpResult<List<PowerQualityIndicatorsVO>> getMonitorLimitDataDay(@RequestBody MonitorBaseParam monitorBaseParam){
+        String methodDescribe = getMethodDescribe("getMonitorLimitDataDay");
+        List<PowerQualityIndicatorsVO> verifyMonitorVO = iDataVerifyService.getMonitorLimitDataDay(monitorBaseParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, verifyMonitorVO, methodDescribe);
+    }
+
+    /**
+     * 弹框-获取异常监测点列表
+     */
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/monitorLimitTable")
+    @ApiOperation("弹框-获取稳态告警监测点列表")
+    public HttpResult<List<DetailAbnormalVO>> monitorLimitTable(@RequestBody MonitorBaseParam monitorBaseParam){
+        String methodDescribe = getMethodDescribe("monitorLimitTable");
+        List<DetailAbnormalVO> list = iDataVerifyService.monitorLimitTable(monitorBaseParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe);
+    }
+
+
+    /**
+     * 获取稳态告警监测点相关信息
+     */
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/monitorLimitTableDetail")
+    @ApiOperation("弹框-获取稳态告警监测点列表详情")
+    public HttpResult<List<DetailAbnormalVO.DetailLimitInnerVO>> monitorLimitTableDetail(@RequestBody MonitorBaseParam monitorBaseParam){
+        String methodDescribe = getMethodDescribe("monitorLimitTableDetail");
+        List<DetailAbnormalVO.DetailLimitInnerVO> list = iDataVerifyService.monitorLimitTableDetail(monitorBaseParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe);
+    }
+
+
 }
 

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

@@ -6,6 +6,7 @@ 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.PowerQualityIndicatorsVO;
 import com.njcn.device.pq.pojo.vo.dataClean.VerifyMonitorVO;
 
 import java.util.List;
@@ -24,6 +25,8 @@ public interface IDataVerifyService extends IService<DataVerify> {
 
     VerifyMonitorVO getMonitorVerifyData(MonitorBaseParam monitorBaseParam);
 
+    List<PowerQualityIndicatorsVO> getMonitorVerifyDay(MonitorBaseParam monitorBaseParam);
+
 
     List<DetailAbnormalVO> monitorAbnormalTable(MonitorBaseParam monitorBaseParam);
 
@@ -34,4 +37,11 @@ public interface IDataVerifyService extends IService<DataVerify> {
 
     VerifyMonitorVO getMonitorLimitData(MonitorBaseParam monitorBaseParam);
 
+    List<PowerQualityIndicatorsVO> getMonitorLimitDataDay(MonitorBaseParam monitorBaseParam);
+
+    List<DetailAbnormalVO> monitorLimitTable(MonitorBaseParam monitorBaseParam);
+
+    List<DetailAbnormalVO.DetailLimitInnerVO> monitorLimitTableDetail(MonitorBaseParam monitorBaseParam);
+
+
 }

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

@@ -3,13 +3,24 @@ package com.njcn.device.pq.service.impl;
 
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.date.*;
+import cn.hutool.core.util.ArrayUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONArray;
+import cn.hutool.json.JSONObject;
 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.DataLimitRateDetailFeignClient;
+import com.njcn.dataProcess.api.DataLimitRateFeignClient;
+import com.njcn.dataProcess.api.DataLimitTargetFeignClient;
 import com.njcn.dataProcess.api.PqReasonableRangeFeignClient;
 import com.njcn.dataProcess.enums.DataCleanEnum;
 import com.njcn.dataProcess.param.DataCleanParam;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataLimitRateDetailDto;
+import com.njcn.dataProcess.pojo.dto.DataLimitRateDto;
+import com.njcn.dataProcess.pojo.dto.DataLimitTargetDto;
 import com.njcn.dataProcess.pojo.dto.PqReasonableRangeDto;
 import com.njcn.device.biz.pojo.dto.LineDevGetDTO;
 import com.njcn.device.pq.constant.Param;
@@ -22,13 +33,11 @@ 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.pojo.vo.dataClean.*;
 import com.njcn.device.pq.service.CommTerminalService;
 import com.njcn.device.pq.service.IDataVerifyService;
 import com.njcn.device.pq.service.LineService;
+import com.njcn.harmonic.pojo.vo.RStatLimitTargetVO;
 import com.njcn.supervision.api.UserLedgerFeignClient;
 import com.njcn.supervision.pojo.vo.user.NewUserReportVO;
 import com.njcn.supervision.pojo.vo.user.UserLedgerVO;
@@ -42,6 +51,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 
+import java.lang.reflect.Field;
 import java.text.DateFormat;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@@ -50,6 +60,7 @@ import java.util.*;
 import java.util.function.Function;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static com.njcn.device.pq.constant.Param.freq;
 
@@ -68,6 +79,9 @@ public class DataVerifyServiceImpl extends ServiceImpl<DataVerifyMapper, DataVer
 
     private static final Logger logger = LoggerFactory.getLogger(DataVerifyServiceImpl.class);
 
+    private static final String SEPARATOR = "&";
+    private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN);
+
     private final CommTerminalService commTerminalService;
 
     private final LineMapper lineMapper;
@@ -78,27 +92,33 @@ public class DataVerifyServiceImpl extends ServiceImpl<DataVerifyMapper, DataVer
 
     private final PqReasonableRangeFeignClient pqReasonableRangeFeignClient;
 
+    private final DataLimitTargetFeignClient dataLimitTargetFeignClient;
+
+    private final DataLimitRateFeignClient dataLimitRateFeignClient;
+
+    private final DataLimitRateDetailFeignClient dataLimitRateDetailFeignClient;
 
 
     @Override
     public VerifyMonitorVO getMonitorVerifyData(MonitorBaseParam 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).orderByAsc(DataVerify::getTime);
-        List<DataVerify> dataVerifyList = this.list(lambdaQueryWrapper);
+        List<DataVerify> dataVerifyList = commQuery(monitorIds, monitorBaseParam);
         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);
-        verifyMonitorVO.setMapList(mapList);
+        verifyMonitorVO.setAbnormalNum(dataVerifyList.stream().collect(Collectors.groupingBy(DataVerify::getLineId)).size());
+        verifyMonitorVO.setMapList(getRangeAbnormalMonitor(monitorBaseParam, dataVerifyList));
         verifyMonitorVO.setTargetList(getAbnormalTarget(dataVerifyList));
         verifyMonitorVO.setMonitorAlarmInfo(getAbnormalTable(dataVerifyList, monitorBaseParam));
         return verifyMonitorVO;
     }
 
+    @Override
+    public List<PowerQualityIndicatorsVO> getMonitorVerifyDay(MonitorBaseParam monitorBaseParam) {
+        List<String> monitorIds = commTerminalService.getRunMonitorByDept(monitorBaseParam);
+        List<DataVerify> dataVerifyList = commQuery(monitorIds, monitorBaseParam);
+        return getAbnormalTable(dataVerifyList, monitorBaseParam);
+    }
+
     @Override
     public List<DetailAbnormalVO> monitorAbnormalTable(MonitorBaseParam monitorBaseParam) {
         List<DetailAbnormalVO> result = new ArrayList<>();
@@ -108,10 +128,15 @@ public class DataVerifyServiceImpl extends ServiceImpl<DataVerifyMapper, DataVer
         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())))
+        lambdaQueryWrapper.between(DataVerify::getTime, DateUtil.beginOfDay(DateUtil.parse(monitorBaseParam.getSearchBeginTime())),
+                        DateUtil.endOfDay(DateUtil.parse(monitorBaseParam.getSearchEndTime())))
                 .in(DataVerify::getLineId, monitorBaseParam.getMonitorIds()).orderByAsc(DataVerify::getTime);
+        if(StrUtil.isNotBlank(monitorBaseParam.getTargetKey())){
+            String[] target = monitorBaseParam.getTargetKey().split(SEPARATOR);
+            lambdaQueryWrapper.eq(DataVerify::getIndexCode,target[0]).eq(DataVerify::getIndexTable,target[1]);
+        }
         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))));
+        Map<String, List<DataVerify>> dataMap = dataVerifyList.stream().collect(Collectors.groupingBy(it -> it.getTime().format(DATE_FORMAT)));
         dataMap.forEach((dateStr, data) -> {
             Map<String, List<DataVerify>> lineMap = data.stream().collect(Collectors.groupingBy(DataVerify::getLineId));
             lineMap.forEach((lineId, lineList) -> {
@@ -122,6 +147,7 @@ public class DataVerifyServiceImpl extends ServiceImpl<DataVerifyMapper, DataVer
                 detailAbnormalVO.setDate(dateStr);
                 detailAbnormalVO.setMonitorName(lineDevGetDTO.getPointName());
                 detailAbnormalVO.setMonitorId(lineDevGetDTO.getPointId());
+                detailAbnormalVO.setTargetKey(monitorBaseParam.getTargetKey());
                 result.add(detailAbnormalVO);
             });
         });
@@ -130,32 +156,43 @@ public class DataVerifyServiceImpl extends ServiceImpl<DataVerifyMapper, DataVer
 
     @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()));
-
+        Map<String,PqReasonableRangeDto> dtoMap = getStandRange();
 
         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);
+                .in(DataVerify::getLineId, monitorBaseParam.getMonitorIds()).orderByAsc(DataVerify::getTime);
+        if(StrUtil.isNotBlank(monitorBaseParam.getTargetKey())){
+            String[] queryTarget = monitorBaseParam.getTargetKey().split(SEPARATOR);
+            lambdaQueryWrapper.eq(DataVerify::getIndexCode,queryTarget[0]).eq(DataVerify::getIndexTable,queryTarget[1]);
+        }
+
         List<DataVerify> dataVerifyList = this.list(lambdaQueryWrapper);
 
-        Map<LocalDateTime, List<DataVerify>> listMap = dataVerifyList.stream().collect(Collectors.groupingBy(DataVerify::getTime));
+        Map<LocalDateTime, List<DataVerify>> listMap = dataVerifyList.stream().collect(Collectors.groupingBy(DataVerify::getTime,TreeMap::new,
+                Collectors.toList()));
         listMap.forEach((time, timeList) -> {
-            Map<String,List<DataVerify>> indexMap = timeList.stream().collect(Collectors.groupingBy(it->it.getIndexCode()+"&"+it.getIndexTable()+"&"+it.getIndexName()));
+            Map<String, List<DataVerify>> indexMap = timeList.stream().collect(Collectors.groupingBy(it -> it.getIndexCode() + SEPARATOR + it.getIndexTable() + SEPARATOR + it.getIndexName()));
             indexMap.forEach((target, list) -> {
+                String[] temKey = target.split(SEPARATOR);
+                PqReasonableRangeDto pqReasonableRangeDto = dtoMap.get(temKey[0] + temKey[1]);
+                String unit;
+                if(StrUtil.isNotBlank(pqReasonableRangeDto.getUnit())){
+                    unit = pqReasonableRangeDto.getUnit();
+                }else {
+                    unit = "";
+                }
+
                 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.setTargetKey(temKey[0] + temKey[1]);
                     vo.setPhaseType(phaseKey);
-                    valueList.forEach(it->{
-                        switch (it.getValueType()){
+                    vo.setRangeDesc(pqReasonableRangeDto.getMinValue() +unit+ " ~ " + pqReasonableRangeDto.getMaxValue()+unit);
+                    valueList.forEach(it -> {
+                        switch (it.getValueType()) {
                             case "AVG":
                                 vo.setAvg(it.getAbnormalValue().toString());
                                 break;
@@ -169,10 +206,8 @@ public class DataVerifyServiceImpl extends ServiceImpl<DataVerifyMapper, DataVer
                                 vo.setCp95(it.getAbnormalValue().toString());
                                 break;
                         }
-                        PqReasonableRangeDto pqReasonableRangeDto = dtoMap.get(temKey[0]+temKey[1]);
-                        vo.setRangeDesc(pqReasonableRangeDto.getMinValue()+"~"+pqReasonableRangeDto.getMaxValue());
-                        result.add(vo);
                     });
+                    result.add(vo);
                 });
             });
         });
@@ -183,10 +218,356 @@ public class DataVerifyServiceImpl extends ServiceImpl<DataVerifyMapper, DataVer
     @Override
     public VerifyMonitorVO getMonitorLimitData(MonitorBaseParam monitorBaseParam) {
         List<String> monitorIds = commTerminalService.getRunMonitorByDept(monitorBaseParam);
+        LineCountEvaluateParam lineCountEvaluateParam = new LineCountEvaluateParam();
+        lineCountEvaluateParam.setLineId(monitorIds);
+        lineCountEvaluateParam.setStartTime(monitorBaseParam.getSearchBeginTime());
+        lineCountEvaluateParam.setEndTime(monitorBaseParam.getSearchEndTime());
+        List<DataLimitTargetDto> limitTarget = dataLimitTargetFeignClient.getRawData(lineCountEvaluateParam).getData();
+        List<DataLimitTargetDto> limitList = limitTarget.stream().filter(it -> it.getAllTime() > 0).collect(Collectors.toList());
+        long abnormalCount = limitList.stream().map(DataLimitTargetDto::getLineId).distinct().count();
+        VerifyMonitorVO verifyMonitorVO = new VerifyMonitorVO();
+        verifyMonitorVO.setRunNum(monitorIds.size());
+        verifyMonitorVO.setAbnormalNum((int) abnormalCount);
 
-        return null;
+        List<Map<String, Object>> mapList = getRangeLimitMonitor(monitorBaseParam, limitList);
+        verifyMonitorVO.setMapList(mapList);
+        verifyMonitorVO.setMonitorAlarmInfo(getLimitTable(limitList, monitorBaseParam));
+        verifyMonitorVO.setTargetList(assLimitTarget(limitTarget));
+        return verifyMonitorVO;
     }
 
+    @Override
+    public List<PowerQualityIndicatorsVO> getMonitorLimitDataDay(MonitorBaseParam monitorBaseParam) {
+        List<String> monitorIds = commTerminalService.getRunMonitorByDept(monitorBaseParam);
+        LineCountEvaluateParam lineCountEvaluateParam = new LineCountEvaluateParam();
+        lineCountEvaluateParam.setLineId(monitorIds);
+        lineCountEvaluateParam.setStartTime(monitorBaseParam.getSearchBeginTime());
+        lineCountEvaluateParam.setEndTime(monitorBaseParam.getSearchEndTime());
+        List<DataLimitTargetDto> limitTarget = dataLimitTargetFeignClient.getRawData(lineCountEvaluateParam).getData();
+        List<DataLimitTargetDto> limitList = limitTarget.stream().filter(it -> it.getAllTime() > 0).collect(Collectors.toList());
+        return getLimitTable(limitList, monitorBaseParam);
+    }
+
+    @Override
+    public List<DetailAbnormalVO> monitorLimitTable(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()));
+
+        LineCountEvaluateParam lineCountEvaluateParam = new LineCountEvaluateParam();
+        lineCountEvaluateParam.setLineId(monitorBaseParam.getMonitorIds());
+        lineCountEvaluateParam.setStartTime(monitorBaseParam.getSearchBeginTime());
+        lineCountEvaluateParam.setEndTime(monitorBaseParam.getSearchEndTime());
+        List<DataLimitRateDetailDto> dataLimitRateDetailDtoList = dataLimitRateDetailFeignClient.getRawData(lineCountEvaluateParam).getData();
+        Map<LocalDate, List<DataLimitRateDetailDto>> limitMap = dataLimitRateDetailDtoList.stream().collect(Collectors.groupingBy(DataLimitRateDetailDto::getTime));
+
+        limitMap.forEach((date, list) -> {
+            Map<String, DataLimitRateDetailDto> map = list.stream().collect(Collectors.toMap(DataLimitRateDetailDto::getLineId, Function.identity()));
+            map.forEach((lineId, line) -> {
+                LineDevGetDTO lineInfoVO = lineDetailMap.get(lineId);
+                Integer timeInterval = lineInfoVO.getTimeInterval();
+                Set<String> timeSet = new HashSet<>();
+                List<String> specialTargetList = new ArrayList<>();
+                String jonsStr = "";
+                if (monitorBaseParam.getTargetKey().equals(DicDataEnum.VOLTAGE_DEV.getCode())) {
+                    //电压偏差
+                    jonsStr = line.getVoltageDevOvertime();
+                } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.FLICKER.getCode())) {
+                    jonsStr = line.getFlickerOvertime();
+                } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.phase_Voltage.getCode())) {
+                    jonsStr = line.getUbalanceOvertime();
+                } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.FREQUENCY_DEV.getCode())) {
+                    jonsStr = line.getFreqDevOvertime();
+                } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.NEG_CURRENT.getCode())) {
+                    jonsStr = line.getINegOvertime();
+                } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.THD_V.getCode())) {
+                    jonsStr = line.getUaberranceOvertime();
+                } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.HARMONIC_VOLTAGE.getCode())) {
+                    for (int i = 2; i <= 25; i++) {
+                        String uHarmKey = "uharm" + i + "Overtime";
+                        String json = getFieldValueForDetail(line, uHarmKey);
+                        if (StrUtil.isNotBlank(json)) {
+                            specialTargetList.add(json);
+                        }
+                    }
+                } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.HARMONIC_CURRENT.getCode())) {
+                    for (int i = 2; i <= 25; i++) {
+                        String uHarmKey = "iharm" + i + "Overtime";
+                        String json = getFieldValueForDetail(line, uHarmKey);
+                        if (StrUtil.isNotBlank(json)) {
+                            specialTargetList.add(json);
+                        }
+                    }
+                } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.INTERHARMONIC_VOLTAGE.getCode())) {
+                    for (int i = 1; i <= 16; i++) {
+                        String uHarmKey = "inuharm" + i + "Overtime";
+                        String json = getFieldValueForDetail(line, uHarmKey);
+                        if (StrUtil.isNotBlank(json)) {
+                            specialTargetList.add(json);
+                        }
+                    }
+                }
+
+                if (CollUtil.isNotEmpty(specialTargetList)) {
+                    for (String str : specialTargetList) {
+                        JSONArray jsonArray = new JSONArray(str);
+                        List<JsonBaseVO> jsonBaseVOList = jsonArray.toList(JsonBaseVO.class);
+                        jsonBaseVOList.forEach(it -> {
+                            timeSet.addAll(Arrays.asList(it.getTime().split(StrUtil.COMMA)));
+                        });
+                    }
+                } else {
+                    JSONArray jsonArray = new JSONArray(jonsStr);
+                    List<JsonBaseVO> jsonBaseVOList = jsonArray.toList(JsonBaseVO.class);
+                    jsonBaseVOList.forEach(it -> {
+                        timeSet.addAll(Arrays.asList(it.getTime().split(StrUtil.COMMA)));
+                    });
+                }
+
+                DetailAbnormalVO detailAbnormalVO = new DetailAbnormalVO();
+                detailAbnormalVO.setMonitorId(lineId);
+                detailAbnormalVO.setDate(date.format(DATE_FORMAT));
+                detailAbnormalVO.setMonitorName(lineInfoVO.getPointName());
+                detailAbnormalVO.setTimeSum((long) timeSet.size() * timeInterval);
+                detailAbnormalVO.setTargetKey(monitorBaseParam.getTargetKey());
+                result.add(detailAbnormalVO);
+            });
+        });
+        return result;
+    }
+
+    @Override
+    public List<DetailAbnormalVO.DetailLimitInnerVO> monitorLimitTableDetail(MonitorBaseParam monitorBaseParam) {
+        List<DetailAbnormalVO.DetailLimitInnerVO> result = new ArrayList<>();
+
+        LineCountEvaluateParam lineCountEvaluateParam = new LineCountEvaluateParam();
+        lineCountEvaluateParam.setLineId(Stream.of(monitorBaseParam.getMonitorIds().get(0)).collect(Collectors.toList()));
+        lineCountEvaluateParam.setStartTime(monitorBaseParam.getSearchBeginTime());
+        lineCountEvaluateParam.setEndTime(monitorBaseParam.getSearchBeginTime());
+        List<DataLimitRateDetailDto> dtoList = dataLimitRateDetailFeignClient.getRawData(lineCountEvaluateParam).getData();
+
+        if (CollUtil.isNotEmpty(dtoList)) {
+            DataLimitRateDetailDto dto = dtoList.get(0);
+            JSONArray jsonArray = new JSONArray();
+            List<String> specialTargetList = new ArrayList<>();
+
+            if (monitorBaseParam.getTargetKey().equals(DicDataEnum.VOLTAGE_DEV.getCode())) {
+                //电压偏差
+                jsonArray = new JSONArray(dto.getVoltageDevOvertime());
+            } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.FLICKER.getCode())) {
+                jsonArray = new JSONArray(dto.getFlickerOvertime());
+            }else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.phase_Voltage.getCode())) {
+                jsonArray = new JSONArray(dto.getUbalanceOvertime());
+            } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.FREQUENCY_DEV.getCode())) {
+                jsonArray = new JSONArray(dto.getFreqDevOvertime());
+            } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.NEG_CURRENT.getCode())) {
+                jsonArray = new JSONArray(dto.getINegOvertime());
+            } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.THD_V.getCode())) {
+                jsonArray = new JSONArray(dto.getUaberranceOvertime());
+            } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.HARMONIC_VOLTAGE.getCode())) {
+                for (int i = 2; i <= 25; i++) {
+                    String uHarmKey = "uharm" + i + "Overtime";
+                    String json = getFieldValueForDetail(dto, uHarmKey);
+                    if (StrUtil.isNotBlank(json)) {
+                        specialTargetList.add(json+SEPARATOR+i);
+                    }
+                }
+
+            } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.HARMONIC_CURRENT.getCode())) {
+                for (int i = 2; i <= 25; i++) {
+                    String uHarmKey = "iharm" + i + "Overtime";
+                    String json = getFieldValueForDetail(dto, uHarmKey);
+                    if (StrUtil.isNotBlank(json)) {
+                        specialTargetList.add(json+SEPARATOR+i);
+                    }
+                }
+
+            } else if (monitorBaseParam.getTargetKey().equals(DicDataEnum.INTERHARMONIC_VOLTAGE.getCode())) {
+                for (int i = 1; i <= 16; i++) {
+                    String uHarmKey = "inuharm" + i + "Overtime";
+                    String json = getFieldValueForDetail(dto, uHarmKey);
+                    if (StrUtil.isNotBlank(json)) {
+                        specialTargetList.add(json+SEPARATOR+i);
+                    }
+                }
+            }
+
+            if(CollUtil.isNotEmpty(specialTargetList)){
+                for(String strJson : specialTargetList){
+                    String[] temStr = strJson.split(SEPARATOR);
+                    JSONArray jsonTem = new JSONArray(temStr[0]);
+                    dealJsonArr(jsonTem,result,monitorBaseParam,temStr[1]);
+                }
+            }else {
+                dealJsonArr(jsonArray,result,monitorBaseParam,null);
+            }
+        }
+        return result;
+    }
+
+
+    /**
+     * 处理json数组
+     */
+    private void dealJsonArr(JSONArray jsonArray,List<DetailAbnormalVO.DetailLimitInnerVO> result,MonitorBaseParam monitorBaseParam,String count){
+        List<JsonBaseVO> jsonBaseVOList = jsonArray.toList(JsonBaseVO.class);
+        Map<String, List<JsonBaseVO>> jsonMap = jsonBaseVOList.stream().collect(Collectors.groupingBy(JsonBaseVO::getPhasic));
+        jsonMap.forEach((phasic, list) -> {
+            Map<String, List<JsonBaseVO>> valueTypeMap = list.stream().collect(Collectors.groupingBy(JsonBaseVO::getValueType));
+            DetailAbnormalVO.DetailLimitInnerVO vo = new DetailAbnormalVO.DetailLimitInnerVO();
+            valueTypeMap.forEach((valueTypeId, vList) -> {
+                vList.forEach(it -> {
+                    String[] timeArr = it.getTime().split(StrUtil.COMMA);
+                    String[] valArr = it.getValue().split(StrUtil.COMMA);
+                    for(int i = 0;i<timeArr.length;i++){
+                        vo.setType(it.getValueType());
+                        vo.setVal(valArr[i]);
+                        vo.setPhaseType(phasic);
+                        vo.setTargetName(StrUtil.isNotBlank(count) ? count+monitorBaseParam.getTargetKey():monitorBaseParam.getTargetKey());
+                        result.add(vo);
+                    }
+                });
+            });
+        });
+    }
+
+
+
+
+    private List<DataVerify> commQuery(List<String> monitorIds, MonitorBaseParam 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).orderByAsc(DataVerify::getTime);
+        return this.list(lambdaQueryWrapper);
+    }
+
+
+    private List<VerifyTargetVO> assLimitTarget(List<DataLimitTargetDto> limitList) {
+        List<VerifyTargetVO> verifyTargetVOList = new ArrayList<>();
+        Set<String> FLICKER = new HashSet<>();
+        Set<String> VOLTAGE_DEV = new HashSet<>();
+        Set<String> HARMONIC_VOLTAGE = new HashSet<>();
+        Set<String> HARMONIC_CURRENT = new HashSet<>();
+        Set<String> INTERHARMONIC_VOLTAGE = new HashSet<>();
+        Set<String> FREQUENCY_DEV = new HashSet<>();
+        Set<String> NEG_CURRENT = new HashSet<>();
+        Set<String> THD_V = new HashSet<>();
+        Set<String> phase_Voltage = new HashSet<>();
+        limitList.forEach(it -> {
+            if (it.getFlickerOvertime() > 0) {
+                FLICKER.add(it.getLineId());
+            }
+            if (it.getFreqDevOvertime() > 0) {
+                FREQUENCY_DEV.add(it.getLineId());
+            }
+            if (it.getVoltageDevOvertime() > 0) {
+                VOLTAGE_DEV.add(it.getLineId());
+            }
+            if (it.getINegOvertime() > 0) {
+                NEG_CURRENT.add(it.getLineId());
+            }
+            if (it.getUaberranceOvertime() > 0) {
+                THD_V.add(it.getLineId());
+            }
+            if (it.getUbalanceOvertime() > 0) {
+                phase_Voltage.add(it.getLineId());
+            }
+            for (int i = 2; i <= 25; i++) {
+                String uHarmKey = "uharm" + i + "Overtime";
+                String iHarmKey = "iharm" + i + "Overtime";
+                String inuHarmKey = "inuharm" + i + "Overtime";
+                if (getFieldValue(it, uHarmKey) != null && getFieldValue(it, uHarmKey) == 1) {
+                    HARMONIC_VOLTAGE.add(it.getLineId());
+                }
+                if (getFieldValue(it, iHarmKey) != null && getFieldValue(it, iHarmKey) == 1) {
+                    HARMONIC_CURRENT.add(it.getLineId());
+                }
+                if (getFieldValue(it, inuHarmKey) != null && getFieldValue(it, inuHarmKey) == 1) {
+                    INTERHARMONIC_VOLTAGE.add(it.getLineId());
+                }
+            }
+        });
+
+        Map<String, Set<String>> overLimitCount = new HashMap<>();
+        overLimitCount.put(DicDataEnum.FLICKER.getCode() + SEPARATOR + DicDataEnum.FLICKER.getName(), FLICKER);
+        overLimitCount.put(DicDataEnum.VOLTAGE_DEV.getCode() + SEPARATOR + DicDataEnum.VOLTAGE_DEV.getName(), VOLTAGE_DEV);
+        overLimitCount.put(DicDataEnum.HARMONIC_VOLTAGE.getCode() + SEPARATOR + DicDataEnum.HARMONIC_VOLTAGE.getName(), HARMONIC_VOLTAGE);
+        overLimitCount.put(DicDataEnum.HARMONIC_CURRENT.getCode() + SEPARATOR + DicDataEnum.HARMONIC_CURRENT.getName(), HARMONIC_CURRENT);
+        overLimitCount.put(DicDataEnum.INTERHARMONIC_VOLTAGE.getCode() + SEPARATOR + DicDataEnum.INTERHARMONIC_VOLTAGE.getName(), INTERHARMONIC_VOLTAGE);
+        overLimitCount.put(DicDataEnum.FREQUENCY_DEV.getCode() + SEPARATOR + DicDataEnum.FREQUENCY_DEV.getName(), FREQUENCY_DEV);
+        overLimitCount.put(DicDataEnum.NEG_CURRENT.getCode() + SEPARATOR + DicDataEnum.NEG_CURRENT.getName(), NEG_CURRENT);
+        overLimitCount.put(DicDataEnum.THD_V.getCode() + SEPARATOR + DicDataEnum.THD_V.getName(), THD_V);
+        overLimitCount.put(DicDataEnum.phase_Voltage.getCode() + SEPARATOR + DicDataEnum.phase_Voltage.getName(), phase_Voltage);
+
+        overLimitCount.forEach((key, set) -> {
+            String[] str = key.split(SEPARATOR);
+            VerifyTargetVO verifyTargetVO = new VerifyTargetVO();
+            verifyTargetVO.setTargetName(str[1]);
+            verifyTargetVO.setIds(set);
+            verifyTargetVO.setKey(str[0]);
+            verifyTargetVOList.add(verifyTargetVO);
+        });
+        return verifyTargetVOList;
+    }
+
+    private Integer getFieldValue(DataLimitTargetDto dto, String fieldName) {
+        try {
+            Field field = DataLimitTargetDto.class.getDeclaredField(fieldName);
+            field.setAccessible(true);
+            return (Integer) field.get(dto);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            logger.error("反射方法异常:{}", e.getMessage());
+            return null;
+        }
+    }
+
+    private String getFieldValueForDetail(DataLimitRateDetailDto dto, String fieldName) {
+        try {
+            Field field = DataLimitRateDetailDto.class.getDeclaredField(fieldName);
+            field.setAccessible(true);
+            return (String) field.get(dto);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            logger.error("反射方法异常:{}", e.getMessage());
+            return null;
+        }
+    }
+
+    private List<Map<String, Object>> getRangeLimitMonitor(MonitorBaseParam monitorBaseParam, List<DataLimitTargetDto> limitList) {
+        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 = limitList.stream().collect(Collectors.groupingBy(it -> it.getTime().format(DATE_FORMAT),
+                    Collectors.mapping(DataLimitTargetDto::getLineId, Collectors.collectingAndThen(Collectors.toSet(), Set::size))));
+            for (DateTime dateTime : ranged) {
+                Map<String, Object> rangeMap = new HashMap<>();
+                String time = DateUtil.format(dateTime,DATE_FORMAT);
+                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(limitList)) {
+                Map<String, Integer> map = limitList.stream().collect(Collectors.groupingBy(it -> it.getTime().format(DateTimeFormatter.ofPattern(DatePattern.NORM_MONTH_PATTERN)),
+                        Collectors.mapping(DataLimitTargetDto::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_MONTH_PATTERN));
+                    rangeMap.put("time", time);
+                    rangeMap.put("val", map.getOrDefault(time, 0));
+                    result.add(rangeMap);
+                }
+            }
+        }
+        return result;
+    }
+
+
     /**
      * 时间范围异常测点数量
      */
@@ -196,11 +577,11 @@ public class DataVerifyServiceImpl extends ServiceImpl<DataVerifyMapper, DataVer
         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)),
+            Map<String, Integer> map = dataVerifyList.stream().collect(Collectors.groupingBy(it -> it.getTime().format(DATE_FORMAT),
                     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));
+                String time = DateUtil.format(dateTime,DATE_FORMAT);
                 rangeMap.put("time", time);
                 rangeMap.put("val", map.getOrDefault(time, 0));
                 result.add(rangeMap);
@@ -223,159 +604,124 @@ public class DataVerifyServiceImpl extends ServiceImpl<DataVerifyMapper, DataVer
         return result;
     }
 
+    private DateRange getDateRange(MonitorBaseParam monitorBaseParam) {
+        DateTime start = DateUtil.parse(monitorBaseParam.getSearchBeginTime());
+        DateTime end = DateUtil.parse(monitorBaseParam.getSearchEndTime());
+        return DateUtil.range(start, end, start.year() == end.year() && start.month() == end.month() ? DateField.DAY_OF_MONTH : DateField.MONTH);
+    }
+
 
     /**
      * 指标异常测点数量
      */
     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<>();*/
-
-        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()));
-
+        Map<String, Set<String>> dataMap = dataVerifyList.stream().collect(Collectors.groupingBy(it ->
+                it.getIndexCode() + it.getIndexTable(), Collectors.mapping(DataVerify::getLineId, Collectors.toSet())));
+        Map<String,PqReasonableRangeDto> rangeMap = getStandRange();
         //正序、负序和零序电压
         List<VerifyTargetVO> result = new ArrayList<>();
         dataMap.forEach((key, num) -> {
-            if (dtoMap.containsKey(key)) {
-                PqReasonableRangeDto desc = dtoMap.get(key);
-                assEmb(num, desc, result);
+            if (rangeMap.containsKey(key)) {
+                PqReasonableRangeDto desc = rangeMap.get(key);
+                assembleEntity(num, desc, result);
             } else {
                 logger.error("存在未知异常指标: {}", key);
             }
-
-
-
-           /* 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);
-            }*/
-
         });
-
-     /*   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();
+        Iterator<Map.Entry<String, PqReasonableRangeDto>> iterator = rangeMap.entrySet().iterator();
         while (iterator.hasNext()) {
             Map.Entry<String, PqReasonableRangeDto> entry = iterator.next();
-            if (vMap.containsKey(entry.getKey())) {
-                vMap.get(entry.getKey()).setSort(sort);
-            } else {
+            if (!vMap.containsKey(entry.getKey())) {
                 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);
+                assembleEntity(new HashSet<>(),dto,result);
             }
-            sort++;
         }
-        voList = result.stream().sorted(Comparator.comparing(VerifyTargetVO::getSort)).collect(Collectors.toList());
-        return voList;
+        return result.stream().sorted(Comparator.comparing(VerifyTargetVO::getSort)).collect(Collectors.toList());
     }
 
-    private void assEmb(Set<String> ids, PqReasonableRangeDto dto, List<VerifyTargetVO> result) {
+    /**
+     *组装实体
+     */
+    private void assembleEntity(Set<String> ids, PqReasonableRangeDto dto, List<VerifyTargetVO> result) {
         VerifyTargetVO verifyTargetVO = new VerifyTargetVO();
-        verifyTargetVO.setKey(dto.getIndexCode() + dto.getInfluxdbTableName());
+        verifyTargetVO.setKey(dto.getIndexCode() +SEPARATOR+ dto.getInfluxdbTableName());
         verifyTargetVO.setTargetName(dto.getIndexName());
         verifyTargetVO.setIds(ids);
-        verifyTargetVO.setRangeDesc(dto.getMinValue() + "~" + dto.getMaxValue());
+        verifyTargetVO.setSort(dto.getSort());
+        String unit  = "";
+        if(StrUtil.isNotBlank(dto.getUnit())){
+            unit = dto.getUnit();
+        }
+        verifyTargetVO.setRangeDesc(dto.getMinValue()+unit + " ~ " + dto.getMaxValue()+unit);
         result.add(verifyTargetVO);
     }
 
 
+    /**
+     * 获取异常范围标准
+     */
+    private Map<String, PqReasonableRangeDto> getStandRange(){
+        DataCleanParam dataCleanParam = new DataCleanParam();
+        dataCleanParam.setSystemType(DataCleanEnum.Pqs.getCode());
+        List<PqReasonableRangeDto> pqReasonableRangeDtoList = pqReasonableRangeFeignClient.getData(dataCleanParam).getData();
+        return pqReasonableRangeDtoList.stream().collect(Collectors.toMap(it -> it.getIndexCode() + it.getInfluxdbTableName(), Function.identity()));
+    }
+
+
     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);
-            }
+            processTable(monitorBaseParam,dateList,result,key);
         });
+        dealTableResult(result);
+        return result;
+    }
+
+
+
+
+
+
+
+    public List<PowerQualityIndicatorsVO> getLimitTable(List<DataLimitTargetDto> dataVerifyList, MonitorBaseParam monitorBaseParam) {
+        List<PowerQualityIndicatorsVO> result = new ArrayList<>();
+        Map<String, List<DataLimitTargetDto>> dataMap = dataVerifyList.stream().collect(Collectors.groupingBy(DataLimitTargetDto::getLineId));
+        dataMap.forEach((key, list) -> {
+            List<LocalDate> dateList = list.stream().map(DataLimitTargetDto::getTime).distinct().sorted(Comparator.comparing(Function.identity())).collect(Collectors.toList());
+            processTable(monitorBaseParam,dateList,result,key);
+        });
+        dealTableResult(result);
+        return result;
+    }
+
+
+
+    /**
+     * 判断测点是否存在连续异常数据
+     */
+    private void  processTable(MonitorBaseParam monitorBaseParam,List<LocalDate> dateList,List<PowerQualityIndicatorsVO> result,String lineId) {
+        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(lineId);
+            if (alarmFlag) {
+                vo.setSeverity(1);
+            } else {
+                vo.setSeverity(0);
+            }
+            vo.setAbnormalDay(dateList.size());
+            result.add(vo);
+        }
+    }
+
+    private void dealTableResult(List<PowerQualityIndicatorsVO> result){
         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()));
@@ -402,9 +748,14 @@ public class DataVerifyServiceImpl extends ServiceImpl<DataVerifyMapper, DataVer
                 }
             });
         }
-        return result;
     }
 
+    /**
+     * 检查日期列表中是否存在连续指定天数的异常
+     * @param dateList 日期列表（已排序）
+     * @param day      连续天数阈值
+     * @return 是否存在连续异常
+     */
     private Boolean verData(List<LocalDate> dateList, Integer day) {
         for (int i = 0; i <= dateList.size() - day; i++) {
             boolean isConsecutive = true;
@@ -421,4 +772,7 @@ public class DataVerifyServiceImpl extends ServiceImpl<DataVerifyMapper, DataVer
         return false;
     }
 
+
+
+
 }