异常数据清洗

pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/pojo/param/dataClean/MonitorBaseParam.java

@@ -6,6 +6,8 @@ import io.swagger.models.auth.In;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 
+import java.util.List;
+
 /**
  * @Author: cdf
  * @CreateTime: 2025-03-26
@@ -27,6 +29,10 @@ public class MonitorBaseParam extends BaseParam {
     @ApiModelProperty(value = "预警天数阈值")
     private Integer warnDayLimit;
 
+    private List<String> monitorIds;
+
+    private String monitorId;
+
 
 
 }

pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/pojo/vo/AreaLineInfoVO.java

@@ -74,6 +74,9 @@ public class AreaLineInfoVO implements Serializable {
     @ApiModelProperty(name = "ip",value = "装置ip")
     private String ip;
 
+    @ApiModelProperty(name = "deviceName",value = "装置名称")
+    private String deviceName;
+
     @ApiModelProperty(name = "lat",value = "维度")
     private BigDecimal lat;
 
@@ -116,6 +119,16 @@ public class AreaLineInfoVO implements Serializable {
     @ApiModelProperty(name = "type",value = "冀北电网一张图类型信息")
     private Integer type;
 
-    @ApiModelProperty(name = "新能源场站信息ID")
+    @ApiModelProperty(name = "newStationId",value = "新能源场站信息ID")
+    @Deprecated
     private String newStationId;
+
+    @ApiModelProperty(name = "bigObjType",value = "检测对象大类")
+    private String bigObjType;
+
+    @ApiModelProperty(name = "smallObjType",value = "检测对象小类")
+    private String smallObjType;
+
+    @ApiModelProperty(name = "objId",value = "对象id")
+    private String objId;
 }

pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/pojo/vo/dataClean/DetailAbnormalVO.java

@@ -0,0 +1,48 @@
+package com.njcn.device.pq.pojo.vo.dataClean;
+
+import lombok.Data;
+
+/**
+ * @Author: cdf
+ * @CreateTime: 2025-03-31
+ * @Description:
+ */
+@Data
+public class DetailAbnormalVO {
+
+    private String monitorId;
+
+    private String date;
+
+    private String monitorName;
+
+    private Long timeSum;
+
+
+
+
+    @Data
+    public static class DetailAbnormalInnerVO{
+
+        //时间
+        private String time;
+
+        private String targetKey;
+
+        //指标类型
+        private String targetName;
+        //相别
+        private String phaseType;
+        //合理范围
+        private String rangeDesc;
+        //最大
+        private String max;
+        //最小
+        private String min;
+        //平均
+        private String avg;
+        //CP95
+        private String cp95;
+
+    }
+}

pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/pojo/vo/dataClean/PowerQualityIndicatorsVO.java

@@ -10,6 +10,7 @@ import lombok.Data;
 @Data
 public class PowerQualityIndicatorsVO {
 
+    private String monitorId;
     //监测点名称
     private String monitorName;
     //所属终端名称
@@ -23,8 +24,8 @@ public class PowerQualityIndicatorsVO {
     //电压等级
     private String voltageLevel;
     //异常天数
-    private String abnormalDay;
+    private Integer abnormalDay;
     //严重度
-    private Double severity;
+    private Integer severity;
 
 }

pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/pojo/vo/dataClean/VerifyMonitorVO.java

@@ -22,56 +22,11 @@ public class VerifyMonitorVO {
 
 
 
-
+    private List<VerifyTargetVO> targetList;
-
-    // 频率，范围 42.5~57.5
-    private double frequency;
-    // 频率偏差，范围 -7.5~7.5
-    private double frequencyDeviation;
-    // 相（线）电压有效值，范围 0~150%U
-    private double phaseOrLineVoltageRms;
-    // 电压偏差，范围 -20%~20%
-    private double voltageDeviation;
-    // 电流有效值，大于 CT 一次变比
-    private double currentRms;
-    // 单相功率因数，范围 -1~1
-    private double singlePhasePowerFactor;
-    // 单相基波功率因数，范围 -1~1
-    private double singlePhaseFundamentalPowerFactor;
-    // 三相功率因数，范围 -1~1
-    private double threePhasePowerFactor;
-    // 基波功率因数，范围 -1~1
-    private double fundamentalPowerFactor;
-    // 电压总谐波畸变率，范围 0~30%
-    private double voltageTotalHarmonicDistortion;
-    // 相（线）电压基波有效值，范围 0~150%U
-    private double phaseOrLineVoltageFundamentalRms;
-    // 相（线）电压基波相角，范围 -180~180
-    private double phaseOrLineVoltageFundamentalPhaseAngle;
-    // 谐波电压含有率，范围 0~30%
-    private double harmonicVoltageContentRate;
-    // 谐波电压相角，范围 -180~180
-    private double harmonicVoltagePhaseAngle;
-    // 间谐波电压含有率，范围 0~30%
-    private double interHarmonicVoltageContentRate;
-    // 正序、负序和零序电压，范围 0~150%U
-    private double positiveNegativeZeroSequenceVoltage;
-    // 负序电压不平衡度，范围 0~40%
-    private double BalanceV;
-    // 零序电压不平衡度，范围 0~40%
-    private double zeroSequenceVoltageUnbalanceDegree;
-    // 电压波动，范围 0~40%
-    private double voltageFluctuation;
-    // 短时间闪变值，范围 0~20
-    private double shortTermFlickerValue;
-    // 长时间闪变值，范围 0~20
-    private double longTermFlickerValue;
-    // 电压暂降特征幅值，范围 0~90%
-    private double voltageSagCharacteristicAmplitude;
-    // 电压暂升特征幅值
-    private double voltageSwellCharacteristicAmplitude;
-
 
     private List<Map<String,Object>> mapList;
 
+    private List<PowerQualityIndicatorsVO> monitorAlarmInfo;
+
+
 }

pqs-device/pq-device/pq-device-api/src/main/java/com/njcn/device/pq/pojo/vo/dataClean/VerifyTargetVO.java

@@ -0,0 +1,25 @@
+package com.njcn.device.pq.pojo.vo.dataClean;
+
+import lombok.Data;
+
+import java.util.List;
+import java.util.Set;
+
+/**
+ * @Author: cdf
+ * @CreateTime: 2025-03-31
+ * @Description: 指标异常详情
+ */
+@Data
+public class VerifyTargetVO {
+
+    private String key;
+
+    private String targetName;
+
+    private String rangeDesc;
+
+    private Set<String> ids;
+
+    private Integer sort;
+}

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")
+    @PostMapping("/monitorAbnormalTable")
-    @ApiOperation("获取异常监测点相关信息")
+    @ApiOperation("弹框-获取异常监测点列表")
-    public HttpResult<PowerQualityIndicatorsVO> getAbnormalTarget(@RequestBody MonitorBaseParam monitorBaseParam){
+    public HttpResult<List<DetailAbnormalVO>> monitorAbnormalTable(@RequestBody MonitorBaseParam monitorBaseParam){
-        String methodDescribe = getMethodDescribe("getAbnormalTarget");
+        String methodDescribe = getMethodDescribe("monitorAbnormalDetail");
-        PowerQualityIndicatorsVO powerQualityIndicatorsVO = iDataVerifyService.getAbnormalTarget(monitorBaseParam);
+        List<DetailAbnormalVO> page = iDataVerifyService.monitorAbnormalTable(monitorBaseParam);
-        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, powerQualityIndicatorsVO, methodDescribe);
+        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())))
+        lambdaQueryWrapper.between(DataVerify::getTime, DateUtil.beginOfDay(DateUtil.parse(monitorBaseParam.getSearchBeginTime())), DateUtil.endOfDay(DateUtil.parse(monitorBaseParam.getSearchEndTime())))
-                .in(DataVerify::getLineId,monitorIds);
+                .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()){
+        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);
+            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(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)),
-                        Collectors.mapping(DataVerify::getLineId, Collectors.collectingAndThen(Collectors.toSet(), Set::size))));
+                    Collectors.mapping(DataVerify::getLineId, Collectors.collectingAndThen(Collectors.toSet(), Set::size))));
-                for (DateTime dateTime : ranged) {
+            for (DateTime dateTime : ranged) {
-                    Map<String, Object> rangeMap = new HashMap<>();
+                Map<String, Object> rangeMap = new HashMap<>();
-                    String time = DateUtil.format(dateTime, DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN));
+                String time = DateUtil.format(dateTime, DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN));
-                    rangeMap.put("time", time);
+                rangeMap.put("time", time);
-                    rangeMap.put("val", map.getOrDefault(time, 0));
+                rangeMap.put("val", map.getOrDefault(time, 0));
-                    result.add(rangeMap);
+                result.add(rangeMap);
-                }
+            }
-        }else {
+        } else {
             //不在一个月则展示月数据
-            DateRange ranged = DateUtil.range(DateUtil.parse(monitorBaseParam.getSearchBeginTime()),DateUtil.parse(monitorBaseParam.getSearchEndTime()), DateField.MONTH);
+            DateRange ranged = DateUtil.range(DateUtil.parse(monitorBaseParam.getSearchBeginTime()), DateUtil.parse(monitorBaseParam.getSearchEndTime()), DateField.MONTH);
-            if(CollUtil.isNotEmpty(dataVerifyList)){
+            if (CollUtil.isNotEmpty(dataVerifyList)) {
-                Map<String,Integer> map = dataVerifyList.stream().collect(Collectors.groupingBy(it->it.getTime().format(DateTimeFormatter.ofPattern(DatePattern.NORM_MONTH_PATTERN)),
+                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) {
+    public List<VerifyTargetVO> getAbnormalTarget(List<DataVerify> dataVerifyList) {
-        Map<String,Set<String>> map = dataVerifyList.stream().collect(Collectors.groupingBy(it->it.getIndexCode()+"$"+it.getIndexTable(),Collectors.mapping(DataVerify::getLineId, Collectors.toSet())));
+        List<VerifyTargetVO> voList = new ArrayList<>();
-        Pattern patternPhasic = Pattern.compile("v_(2|[3-9]|[1-4][0-9]|50)\\$data_harmphasic_v");
+        Map<String, Set<String>> dataMap = dataVerifyList.stream().collect(Collectors.groupingBy(it -> it.getIndexCode() + it.getIndexTable(), Collectors.mapping(DataVerify::getLineId, Collectors.toSet())));
-        Pattern patternRate = Pattern.compile("v_(2|[3-9]|[1-4][0-9]|50)\\$data_harmrate_v");
+ /*       Pattern patternPhasic = Pattern.compile("v_(2|[3-9]|[1-4][0-9]|50)\\$DataHarmPhasicV");
-        Pattern patternInRate = Pattern.compile("v_(2|[3-9]|[1-4][0-9]|50)\\$data_inharmrate_v");
+        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<>();
+        List<VerifyTargetVO> result = new ArrayList<>();
-        map.forEach((key,num)->{
+        dataMap.forEach((key, num) -> {
-            if(patternPhasic.matcher(key).matches()){
+            if (dtoMap.containsKey(key)) {
-                key = Param.phasic_rate_$;
+                PqReasonableRangeDto desc = dtoMap.get(key);
-            }else if(patternRate.matcher(key).matches()){
+                assEmb(num, desc, result);
-                key = Param.v_rate;
+            } else {
-            }else if(patternInRate.matcher(key).matches()){
+                logger.error("存在未知异常指标: {}", key);
-                key = Param.in_v_rate;
             }
 
-            switch (key){
+
-                case freq:
+
-                    powerQualityIndicatorsVO.setFrequency(num.size());
+           /* if((DataCleanEnum.Freq.getCode()+DataCleanEnum.DataV).equals(key)){
-                    break;
+               desc =  dtoMap.get(DataCleanEnum.Freq.getCode()+DataCleanEnum.DataV);
-                case Param.freq_dev:
+               assEmb(num,desc,result);
-                    powerQualityIndicatorsVO.setFrequencyDeviation(num.size());
+            }else if((DataCleanEnum.FreqDev.getCode()+DataCleanEnum.DataV).equals(key)){
-                    break;
+                desc =  dtoMap.get(DataCleanEnum.FreqDev.getCode()+DataCleanEnum.DataV);
-                case Param.rms_v:
+                assEmb(num,desc,result);
-                case Param.rms_lvr:
+            }else if((DataCleanEnum.RmsV.getCode()+DataCleanEnum.DataV).equals(key) || (DataCleanEnum.RmsLvr.getCode()+DataCleanEnum.DataV).equals(key)){
-                    vRmsSet.addAll(num);
+                vRmsSet.addAll(num);
-                    break;
+            }else if((DataCleanEnum.VuDev.getCode()+DataCleanEnum.DataV).equals(key)){
-                case Param.vu_dev:
+                desc =  dtoMap.get(DataCleanEnum.VuDev.getCode()+DataCleanEnum.DataV);
-                    powerQualityIndicatorsVO.setVoltageDeviation(num.size());
+                assEmb(num,desc,result);
-                    break;
+            }else if((DataCleanEnum.RmsI.getCode()+DataCleanEnum.DataI).equals(key)){
-                case Param.rms_i:
+                desc =  dtoMap.get(DataCleanEnum.RmsI.getCode()+DataCleanEnum.DataI);
-                    powerQualityIndicatorsVO.setCurrentRms(num.size());
+                assEmb(num,desc,result);
-                    break;
+            }else if((DataCleanEnum.VThd.getCode()+DataCleanEnum.DataV).equals(key)){
-                case Param.v_thd:
+                desc =  dtoMap.get(DataCleanEnum.VThd.getCode()+DataCleanEnum.DataV);
-                    powerQualityIndicatorsVO.setVoltageTotalHarmonicDistortion(num.size());
+                assEmb(num,desc,result);
-                    break;
+            }else if((DataCleanEnum.V_1.getCode()+DataCleanEnum.DataV).equals(key)){
-                case Param.v_1_v:
+                desc =  dtoMap.get(DataCleanEnum.V_1.getCode()+DataCleanEnum.DataV);
-                    powerQualityIndicatorsVO.setPhaseOrLineVoltageFundamentalRms(num.size());
+                assEmb(num,desc,result);
-                    break;
+            }else if((DataCleanEnum.V_1.getCode()+DataCleanEnum.DataHarmPhasicV).equals(key)){
-                case Param.phasic_v_1:
+                desc =  dtoMap.get(DataCleanEnum.V_1.getCode()+DataCleanEnum.DataHarmPhasicV);
-                    powerQualityIndicatorsVO.setPhaseOrLineVoltageFundamentalPhaseAngle(num.size());
+                assEmb(num,desc,result);
-                    break;
+            }else if((DataCleanEnum.V.getCode()+DataCleanEnum.DataHarmPhasicV).equals(key)){
-                case Param.phasic_rate_$:
+                harmPhasicSet.addAll(num);
-                    harmPhasicSet.addAll(num);
+            }else if((DataCleanEnum.V_Rate.getCode()+DataCleanEnum.DataV).equals(key)){
-                    break;
+                harmVSet.addAll(num);
-                case Param.v_rate:
+            }else if((DataCleanEnum.V_InHarm.getCode()+DataCleanEnum.DataInHarmV).equals(key)){
-                    harmVSet.addAll(num);
+                harmVSet.addAll(num);
-                    break;
+            }else if((DataCleanEnum.VZero.getCode()+DataCleanEnum.DataV).equals(key)){
-                case Param.in_v_rate:
+                desc =  dtoMap.get(DataCleanEnum.VZero.getCode()+DataCleanEnum.DataV);
-                    inHarmVSet.addAll(num);
+                assEmb(num,desc,result);
-                    break;
+            }else if((DataCleanEnum.VPos.getCode()+DataCleanEnum.DataV).equals(key)){
-                case Param.v_zero:
+                desc =  dtoMap.get(DataCleanEnum.VPos.getCode()+DataCleanEnum.DataV);
-                case Param.v_neg:
+                assEmb(num,desc,result);
-                case Param.v_pos:
+            }else if((DataCleanEnum.VNeg.getCode()+DataCleanEnum.DataV).equals(key)){
-                    posVSet.addAll(num);
+                desc =  dtoMap.get(DataCleanEnum.VNeg.getCode()+DataCleanEnum.DataV);
-                    break;
+                assEmb(num,desc,result);
-                case Param.v_unbalance:
+            }else if((DataCleanEnum.VUnbalance.getCode()+DataCleanEnum.DataV).equals(key)){
-                    powerQualityIndicatorsVO.setBalanceV(num.size());
+                desc =  dtoMap.get(DataCleanEnum.VUnbalance.getCode()+DataCleanEnum.DataV);
-                    break;
+                assEmb(num,desc,result);
-                case Param.fluc:
+            }else if((DataCleanEnum.Fluc.getCode()+DataCleanEnum.DataFluc).equals(key)){
-                    powerQualityIndicatorsVO.setVoltageFluctuation(num.size());
+                desc =  dtoMap.get(DataCleanEnum.Fluc.getCode()+DataCleanEnum.DataFluc);
-                    break;
+                assEmb(num,desc,result);
-                case Param.plt:
+            }else if((DataCleanEnum.Plt.getCode()+DataCleanEnum.DataPlt).equals(key)){
-                    powerQualityIndicatorsVO.setShortTermFlickerValue(num.size());
+                desc =  dtoMap.get(DataCleanEnum.Plt.getCode()+DataCleanEnum.DataPlt);
-                    break;
+                assEmb(num,desc,result);
-                case Param.pst:
+            }else if((DataCleanEnum.Pst.getCode()+DataCleanEnum.DataPlt).equals(key)){
-                    powerQualityIndicatorsVO.setLongTermFlickerValue(num.size());
+                desc =  dtoMap.get(DataCleanEnum.Pst.getCode()+DataCleanEnum.DataPlt);
-                    break;
+                assEmb(num,desc,result);
-                default:
+            }else {
-                    System.out.println("存在未知指标:"+key);
+                logger.warn("存在未知异常指标: {}", key);
-                    break;
+            }*/
-            }
+
         });
-        powerQualityIndicatorsVO.setHarmonicVoltagePhaseAngle(harmPhasicSet.size());
+
-        powerQualityIndicatorsVO.setHarmonicVoltageContentRate(harmVSet.size());
+     /*   PqReasonableRangeDto desc =  dtoMap.get(DataCleanEnum.V.getCode()+DataCleanEnum.DataHarmPhasicV);
-        powerQualityIndicatorsVO.setInterHarmonicVoltageContentRate(inHarmVSet.size());
+        assEmb(harmPhasicSet,desc,result);
-        powerQualityIndicatorsVO.setPositiveNegativeZeroSequenceVoltage(posVSet.size());
+        desc =  dtoMap.get(DataCleanEnum.V_Rate.getCode()+DataCleanEnum.DataHarmRateV);
-        powerQualityIndicatorsVO.setPhaseOrLineVoltageRms(vRmsSet.size());
+        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 List<PowerQualityIndicatorsVO> getAbnormalTable(List<DataVerify> dataVerifyList, MonitorBaseParam monitorBaseParam) {
-    public void getAbnormalTable(List<DataVerify> dataVerifyList,VerifyMonitorVO powerQualityIndicatorsVO,MonitorBaseParam monitorBaseParam) {
+        List<PowerQualityIndicatorsVO> result = new ArrayList<>();
-        Map<String,List<DataVerify>> dataMap = dataVerifyList.stream().collect(Collectors.groupingBy(DataVerify::getLineId));
+        Map<String, List<DataVerify>> dataMap = dataVerifyList.stream().collect(Collectors.groupingBy(DataVerify::getLineId));
-        dataMap.forEach((key,list)->{
+        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());
+            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;
+    }
 
 }

pqs-system/system-api/src/main/java/com/njcn/system/enums/DicDataEnum.java

@@ -632,7 +632,12 @@ public enum DicDataEnum {
     No_Upload("未上送","0"),
     Has_Upload("已上送","1"),
     Reduce_Upload("取消上送","2"),
-    Return_Upload("待重新上送","3")
+    Return_Upload("待重新上送","3"),
+
+
+    //字典树类型
+    Obj_Type("监测对象类型","0"),
+    Custom_Report_Type("自定义报表类型","1")
 
 
     ;

pqs-system/system-boot/src/main/java/com/njcn/system/controller/DictTreeController.java

@@ -176,6 +176,15 @@ public class DictTreeController extends BaseController {
         return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
     }
 
+    @OperateInfo(info = LogEnum.SYSTEM_COMMON)
+    @GetMapping("/queryFirstNode")
+    @ApiOperation("查询所有大类节点")
+    public HttpResult<List<SysDicTreePO>> queryFirstNodeList() {
+        String methodDescribe = getMethodDescribe("queryFirstNodeList");
+        List<SysDicTreePO> result = sysDicTreePOService.queryFirstNodeList();
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
+    }
+
     @OperateInfo(info = LogEnum.SYSTEM_COMMON)
     @GetMapping("/queryDictType")
     @ApiOperation("获取指标类型")

pqs-system/system-boot/src/main/java/com/njcn/system/service/SysDicTreePOService.java

@@ -58,6 +58,12 @@ public interface SysDicTreePOService extends IService<SysDicTreePO> {
 
     List<SysDicTreePO> queryTree();
 
+    /**
+     * 查询所有大类节点
+     * @date 2023/12/18
+     */
+    List<SysDicTreePO> queryFirstNodeList();
+
     /**
      * 根据code查询自动树
      * @param code code

pqs-system/system-boot/src/main/java/com/njcn/system/service/impl/SysDicTreePOServiceImpl.java

@@ -20,10 +20,7 @@ import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Objects;
 import java.util.stream.Collectors;
 
 /**
@@ -168,6 +165,13 @@ public class SysDicTreePOServiceImpl extends ServiceImpl<SysDicTreePOMapper, Sys
         }).collect(Collectors.toList());
     }
 
+    @Override
+    public List<SysDicTreePO> queryFirstNodeList() {
+        LambdaQueryWrapper<SysDicTreePO> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.eq(SysDicTreePO::getPid,"0").eq(SysDicTreePO::getStatus,0);
+        return this.list(lambdaQueryWrapper);
+    }
+
     @Override
     public List<SysDicTreePO> queryByCodeList(String code) {
         List<SysDicTreePO> sysDicTreePOList = this.list(new LambdaQueryWrapper<SysDicTreePO>().eq(SysDicTreePO::getStatus, 0));