污区图算法编写

algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/ExecutionCenter.java

@@ -310,53 +310,53 @@ public class ExecutionCenter extends BaseController {
 //
 //    }
 //
-//    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
-//    @ApiOperation("变电站算法执行链")
+    @ApiOperation("变电站算法执行链")
-//    @PostMapping("/substationExecutor")
+    @PostMapping("/substationExecutor")
-//    @Async("asyncExecutor")
+    @Async("asyncExecutor")
-//    public void substationExecutor(@RequestBody BaseParam baseParam) {
+    public void substationExecutor(@RequestBody BaseParam baseParam) {
-//        String methodDescribe = getMethodDescribe("substationExecutor");
+        String methodDescribe = getMethodDescribe("substationExecutor");
-//        //手动判断参数是否合法,
+        //手动判断参数是否合法,
-//        CalculatedParam<String> calculatedParam = judgeExecuteParam(baseParam);
+        CalculatedParam<String> calculatedParam = judgeExecuteParam(baseParam);
-//        // 测点索引
+        // 测点索引
-//        DeptGetLineParam deptGetLineParam = new DeptGetLineParam();
+        DeptGetLineParam deptGetLineParam = new DeptGetLineParam();
-//
+
-//        if (CollectionUtils.isEmpty(calculatedParam.getIdList())) {
+        if (CollectionUtils.isEmpty(calculatedParam.getIdList())) {
-//            Dept data = deptFeignClient.getRootDept().getData();
+            Dept data = deptFeignClient.getRootDept().getData();
-//            deptGetLineParam.setDeptId(data.getId());
+            deptGetLineParam.setDeptId(data.getId());
-//            List<DeptGetSubStationDTO> data1 = commTerminalGeneralClient.deptSubStation(deptGetLineParam).getData();
+            List<DeptGetSubStationDTO> data1 = commTerminalGeneralClient.deptSubStation(deptGetLineParam).getData();
-//            List<String> stationIds = new ArrayList<>();
+            List<String> stationIds = new ArrayList<>();
-//            for (DeptGetSubStationDTO deptGetSubStationDTO : data1) {
+            for (DeptGetSubStationDTO deptGetSubStationDTO : data1) {
-//                Collection<String> union = CollectionUtils.union(Optional.ofNullable(deptGetSubStationDTO.getStationIds()).orElse(new ArrayList<String>()),
+                Collection<String> union = CollectionUtils.union(Optional.ofNullable(deptGetSubStationDTO.getStationIds()).orElse(new ArrayList<String>()),
-//                        Optional.ofNullable(deptGetSubStationDTO.getStationIds()).orElse(new ArrayList<String>()));
+                        Optional.ofNullable(deptGetSubStationDTO.getStationIds()).orElse(new ArrayList<String>()));
-//                List<String> collect = union.stream().distinct().collect(Collectors.toList());
+                List<String> collect = union.stream().distinct().collect(Collectors.toList());
-//                stationIds.addAll(collect);
+                stationIds.addAll(collect);
-//            }
+            }
-//            stationIds = stationIds.stream().distinct().collect(Collectors.toList());
+            stationIds = stationIds.stream().distinct().collect(Collectors.toList());
-//            calculatedParam.setIdList(stationIds);
+            calculatedParam.setIdList(stationIds);
-//        }
+        }
-//        LiteflowResponse liteflowResponse;
+        LiteflowResponse liteflowResponse;
-//        if (baseParam.isRepair()) {
+        if (baseParam.isRepair()) {
-//            //补招时，起始日期、截止日期必填
+            //补招时，起始日期、截止日期必填
-//            DateTime startDate = DateUtil.parse(baseParam.getBeginTime(), DatePattern.NORM_DATE_FORMAT);
+            DateTime startDate = DateUtil.parse(baseParam.getBeginTime(), DatePattern.NORM_DATE_FORMAT);
-//            DateTime endDate = DateUtil.parse(baseParam.getEndTime(), DatePattern.NORM_DATE_FORMAT);
+            DateTime endDate = DateUtil.parse(baseParam.getEndTime(), DatePattern.NORM_DATE_FORMAT);
-//            long betweenDay = DateUtil.betweenDay(startDate, endDate, true);
+            long betweenDay = DateUtil.betweenDay(startDate, endDate, true);
-//            //递增日期执行算法链
+            //递增日期执行算法链
-//            for (int i = 0; i < betweenDay; i++) {
+            for (int i = 0; i < betweenDay; i++) {
-//                if (i != 0) {
+                if (i != 0) {
-//                    startDate = DateUtil.offsetDay(startDate, 1);
+                    startDate = DateUtil.offsetDay(startDate, 1);
-//                }
+                }
-//                calculatedParam.setDataDate(DateUtil.format(startDate, DatePattern.NORM_DATE_PATTERN));
+                calculatedParam.setDataDate(DateUtil.format(startDate, DatePattern.NORM_DATE_PATTERN));
-//                liteflowResponse = flowExecutor.execute2Resp("sub_station", calculatedParam);
+                liteflowResponse = flowExecutor.execute2Resp("sub_station", calculatedParam);
-//                dealResponse(calculatedParam, liteflowResponse, methodDescribe);
+                dealResponse(calculatedParam, liteflowResponse, methodDescribe);
-//            }
+            }
-//        } else {
+        } else {
-//            //非补招
+            //非补招
-//            liteflowResponse = flowExecutor.execute2Resp("sub_station", calculatedParam);
+            liteflowResponse = flowExecutor.execute2Resp("sub_station", calculatedParam);
-//            dealResponse(calculatedParam, liteflowResponse, methodDescribe);
+            dealResponse(calculatedParam, liteflowResponse, methodDescribe);
-//        }
+        }
-//
+
-//    }
+    }
 //
 //    /**
 //     * pms dim母线，电站运行情况

algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/executor/OrgPointExecutor.java

@@ -1,7 +1,9 @@
 package com.njcn.algorithm.executor;
 
-import com.njcn.algorithm.service.line.IDataIntegrityService;
+import com.njcn.algorithm.pojo.bo.CalculatedParam;
 import com.njcn.algorithm.service.line.IDataOrgPointService;
+import com.njcn.algorithm.service.line.IPollutionService;
+import com.njcn.device.biz.pojo.dto.DeptGetChildrenMoreDTO;
 import com.yomahub.liteflow.annotation.LiteflowComponent;
 import com.yomahub.liteflow.annotation.LiteflowMethod;
 import com.yomahub.liteflow.core.NodeComponent;
@@ -26,6 +28,9 @@ public class OrgPointExecutor extends BaseExecutor{
     @Resource
     private IDataOrgPointService dataOrgPointService;
 
+    @Resource
+    private IPollutionService pollutionService;
+
 
     @LiteflowMethod(value = LiteFlowMethodEnum.IS_ACCESS, nodeId = "dataOrgIntegrity", nodeType = NodeTypeEnum.COMMON)
     public boolean dataOrgIntegrityAccess(NodeComponent bindCmp) {
@@ -36,4 +41,39 @@ public class OrgPointExecutor extends BaseExecutor{
         dataOrgPointService.dataOrgIntegrity(bindCmp.getRequestData());
     }
 
+    /**
+     * 3.4.16.	单位污区图统计（新增）
+     *
+     */
+    @LiteflowMethod(value = LiteFlowMethodEnum.IS_ACCESS, nodeId = "rStatPollutionOrg", nodeType = NodeTypeEnum.COMMON)
+    public boolean processRStatPollutionOrgAccess(NodeComponent bindCmp) {
+        return isAccess(bindCmp);
+    }
+    @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "rStatPollutionOrg", nodeType = NodeTypeEnum.COMMON)
+    public void processRStatPollutionOrgProcess(NodeComponent bindCmp) {
+        String tag = bindCmp.getTag();
+        CalculatedParam<DeptGetChildrenMoreDTO> calculatedParam = bindCmp.getRequestData();
+        if ("r_stat_pollution_org_d".equalsIgnoreCase(tag)) {
+            //日表
+            pollutionService.handleOrgDay(calculatedParam);
+        } else if ("r_stat_pollution_org_m".equalsIgnoreCase(tag)) {
+            //数据补招不执行非日表算法
+            if (!calculatedParam.isRepair()) {
+                //月表
+                pollutionService.handleOrgMonth(calculatedParam);
+            }
+        }else if ("r_stat_pollution_org_q".equalsIgnoreCase(tag)) {
+            //数据补招不执行非日表算法
+            if (!calculatedParam.isRepair()) {
+                //季表
+                pollutionService.handleOrgQtr(calculatedParam);
+            }
+        }else if ("r_stat_pollution_org_y".equalsIgnoreCase(tag)) {
+            //数据补招不执行非日表算法
+            if (!calculatedParam.isRepair()) {
+                //年表
+                pollutionService.handleOrgYear(calculatedParam);
+            }
+        }
+    }
 }

algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/executor/SubStationExecutor.java

@@ -0,0 +1,64 @@
+package com.njcn.algorithm.executor;
+
+import com.njcn.algorithm.pojo.bo.CalculatedParam;
+import com.njcn.algorithm.service.line.IPollutionService;
+import com.yomahub.liteflow.annotation.LiteflowComponent;
+import com.yomahub.liteflow.annotation.LiteflowMethod;
+import com.yomahub.liteflow.core.NodeComponent;
+import com.yomahub.liteflow.enums.LiteFlowMethodEnum;
+import com.yomahub.liteflow.enums.NodeTypeEnum;
+import lombok.RequiredArgsConstructor;
+
+import javax.annotation.Resource;
+
+/**
+ * Description:
+ * Date: 2023/11/10  10:39【需求编号】
+ *
+ * @author clam
+ * @version V1.0.0
+ */
+@LiteflowComponent
+@RequiredArgsConstructor
+public class SubStationExecutor extends BaseExecutor{
+
+    @Resource
+    private IPollutionService pollutionService;
+
+    /**
+     * 3.4.15.	变电站污区图统计（新增）
+     *
+     */
+    @LiteflowMethod(value = LiteFlowMethodEnum.IS_ACCESS, nodeId = "rStatPollutionSubstation", nodeType = NodeTypeEnum.COMMON)
+    public boolean processRStatPollutionSubstationAccess(NodeComponent bindCmp) {
+        return isAccess(bindCmp);
+    }
+    @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "rStatPollutionSubstation", nodeType = NodeTypeEnum.COMMON)
+    public void processRStatPollutionSubstationProcess(NodeComponent bindCmp) {
+        String tag = bindCmp.getTag();
+        CalculatedParam<String> calculatedParam = bindCmp.getRequestData();
+        if ("r_stat_pollution_substation_d".equalsIgnoreCase(tag)) {
+            //日表
+            pollutionService.handleSubstationDay(calculatedParam);
+        } else if ("r_stat_pollution_substation_m".equalsIgnoreCase(tag)) {
+            //数据补招不执行非日表算法
+            if (!calculatedParam.isRepair()) {
+                //月表
+                pollutionService.handleSubstationMonth(calculatedParam);
+            }
+        }else if ("r_stat_pollution_substation_q".equalsIgnoreCase(tag)) {
+            //数据补招不执行非日表算法
+            if (!calculatedParam.isRepair()) {
+                //季表
+                pollutionService.handleSubstationQtr(calculatedParam);
+            }
+        }else if ("r_stat_pollution_substation_y".equalsIgnoreCase(tag)) {
+            //数据补招不执行非日表算法
+            if (!calculatedParam.isRepair()) {
+                //年表
+                pollutionService.handleSubstationYear(calculatedParam);
+            }
+        }
+    }
+
+}

algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/serviceimpl/line/DataComAssServiceImpl.java

@@ -6,8 +6,11 @@ import com.njcn.algorithm.service.line.IDataComAssService;
 import com.njcn.dataProcess.api.DataComAssFeignClient;
 import com.njcn.dataProcess.api.DataFlickerFeignClient;
 import com.njcn.dataProcess.api.DataVFeignClient;
+import com.njcn.dataProcess.api.PqDataVerifyFeignClient;
+import com.njcn.dataProcess.enums.DataCleanEnum;
 import com.njcn.dataProcess.param.LineCountEvaluateParam;
 import com.njcn.dataProcess.pojo.dto.DataComassesDPO;
+import com.njcn.dataProcess.pojo.po.PqDataVerify;
 import com.njcn.dataProcess.util.TimeUtils;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -21,6 +24,7 @@ import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.time.LocalDateTime;
 import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * @Description:
@@ -43,6 +47,8 @@ public class DataComAssServiceImpl implements IDataComAssService {
     private DataFlickerFeignClient dataFlickerFeignClient;
     @Resource
     private DataComAssFeignClient dataComAssFeignClient;
+    @Resource
+    private PqDataVerifyFeignClient pqDataVerifyFeignClient;
 
     @Override
     public void dataComAssHandler(CalculatedParam calculatedParam) {
@@ -52,6 +58,7 @@ public class DataComAssServiceImpl implements IDataComAssService {
         lineParam.setStartTime(TimeUtils.getBeginOfDay(calculatedParam.getDataDate()));
         lineParam.setEndTime(TimeUtils.getEndOfDay(calculatedParam.getDataDate()));
         List<String> lineIdList = calculatedParam.getIdList();
+        getAbnormalData(lineParam);
         for (String lineId : lineIdList) {
             DataComassesDPO rStatComassesDpo = new DataComassesDPO();
             rStatComassesDpo.setTime(calculatedParam.getDataDate());
@@ -104,6 +111,26 @@ public class DataComAssServiceImpl implements IDataComAssService {
 
     }
 
+    /**
+     * @param lineParam
+     * @Description:
+     * @Author: wr
+     * @Date: 2025/3/11 9:04
+     */
+    private void getAbnormalData(LineCountEvaluateParam lineParam) {
+        lineParam.setTableName(DataCleanEnum.DataV.getCode());
+        // 获取异常数据，用于排除异常数据
+        List<PqDataVerify> pqDataVerifies = pqDataVerifyFeignClient.queryData(lineParam).getData();
+        if (CollUtil.isNotEmpty(pqDataVerifies)) {
+            Map<String, List<String>> timeMap = pqDataVerifies.stream()
+                    .collect(Collectors.groupingBy(
+                            PqDataVerify::getLineId,
+                            Collectors.mapping(item -> TimeUtils.LocalDateTimeToString(item.getTime()), Collectors.toList())
+                    ));
+            lineParam.setAbnormalTime(timeMap);
+        }
+    }
+
     private Map<String, Object> getGeneralData(LineCountEvaluateParam lineParam) {
         Map<String, Object> outMap = new HashMap<>(30);
         BigDecimal hundred = BigDecimal.valueOf(100);

algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/serviceimpl/line/PollutionServiceImpl.java

@@ -7,10 +7,14 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.njcn.algorithm.pojo.bo.CalculatedParam;
 import com.njcn.algorithm.service.line.IPollutionService;
 import com.njcn.dataProcess.api.*;
+import com.njcn.dataProcess.enums.DataCleanEnum;
 import com.njcn.dataProcess.param.LineCountEvaluateParam;
 import com.njcn.dataProcess.pojo.dto.*;
+import com.njcn.dataProcess.pojo.po.PqDataVerify;
+import com.njcn.dataProcess.util.TimeUtils;
 import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
 import com.njcn.device.biz.pojo.dto.DeptGetChildrenMoreDTO;
+import com.njcn.device.biz.pojo.dto.LineDevGetBandDTO;
 import com.njcn.device.biz.pojo.dto.LineDevGetDTO;
 import com.njcn.device.biz.pojo.po.Overlimit;
 
@@ -39,6 +43,7 @@ import java.util.stream.Stream;
 @RequiredArgsConstructor
 public class PollutionServiceImpl implements IPollutionService {
 
+    private final PqDataVerifyFeignClient pqDataVerifyFeignClient;
     private final DicDataFeignClient dicDataFeignClient;
     private final CommTerminalGeneralClient commTerminalGeneralClient;
     private final DataVFeignClient dataVFeignClient;
@@ -47,10 +52,10 @@ public class PollutionServiceImpl implements IPollutionService {
     private final DataIFeignClient dataIFeignClient;
     private final DataPollutionFeignClient dataPollutionFeignClient;
 
+
     @Override
     public void handleDay(CalculatedParam<String> calculatedParam) {
         List<DataPollutionD> pollutionList;
-
         List<DictData> dictDataList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.POLLUTION_STATIS.getCode()).getData();
         Map<String, DictData> dictData = dictDataList.stream().collect(Collectors.toMap(DictData::getId, Function.identity()));
         LocalDate local = LocalDateTimeUtil.parseDate(calculatedParam.getDataDate());
@@ -62,10 +67,9 @@ public class PollutionServiceImpl implements IPollutionService {
 
         LineCountEvaluateParam lineCountEvaluateParam = new LineCountEvaluateParam();
         lineCountEvaluateParam.setLineId(idList);
-
         lineCountEvaluateParam.setStartTime(beginDay);
         lineCountEvaluateParam.setEndTime(endDay);
-
+        getAbnormalData(lineCountEvaluateParam);
         //指标数据获取
         Map<String, DataPollutionD> harmonicVoltageList = getHarmonicVoltage(lineCountEvaluateParam, limitMap);
         Map<String, DataPollutionD> harmonicCurrentList = getHarmonicCurrent(lineCountEvaluateParam, limitMap);
@@ -88,52 +92,279 @@ public class PollutionServiceImpl implements IPollutionService {
 
     @Override
     public void handleOrgDay(CalculatedParam<DeptGetChildrenMoreDTO> calculatedParam) {
-        LocalDate local = LocalDateTimeUtil.parseDate(calculatedParam.getDataDate());
+        List<DataPollutionOrgD> info = new ArrayList<>();
-        QueryWrapper<DataPollutionD> queryWrapper = new QueryWrapper<>();
+        //远程接口获取分钟数据
-
+        LineCountEvaluateParam lineParam = new LineCountEvaluateParam();
+        lineParam.setStartTime(TimeUtils.getBeginOfDay(calculatedParam.getDataDate()));
+        lineParam.setEndTime(TimeUtils.getEndOfDay(calculatedParam.getDataDate()));
+        LocalDate localDate = LocalDateTimeUtil.parseDate(calculatedParam.getDataDate());
         for (DeptGetChildrenMoreDTO deptGetChildrenMoreDTO : calculatedParam.getIdList()) {
-            Collection<LineDevGetDTO> union = CollectionUtils.union(Optional.ofNullable(deptGetChildrenMoreDTO.getLineBaseList()).orElse(new ArrayList<>()),
+            Collection<LineDevGetDTO> union = CollectionUtils.union
+                    (Optional.ofNullable(deptGetChildrenMoreDTO.getLineBaseList()).orElse(new ArrayList<>()),
                             Optional.ofNullable(deptGetChildrenMoreDTO.getPwMonitorIds()).orElse(new ArrayList<>()));
             List<String> lineIds = union.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
-
+            if (CollUtil.isNotEmpty(lineIds)) {
+                lineParam.setLineId(lineIds);
+                List<DataPollutionD> data = dataPollutionFeignClient.getRawData(lineParam).getData();
+                Map<String, List<DataPollutionD>> pollutionMap = data.stream().collect(Collectors.groupingBy(DataPollutionD::getPollutionType));
+                pollutionMap.forEach((key, value) -> {
+                    DataPollutionOrgD orgD = new DataPollutionOrgD();
+                    orgD.setOrgId(deptGetChildrenMoreDTO.getUnitId());
+                    orgD.setDataDate(localDate);
+                    orgD.setPollutionType(key);
+                    orgD.setValue(value.stream().max(Comparator.comparing(DataPollutionD::getValue)).get().getValue());
+                    info.add(orgD);
+                });
+            }
+        }
+        if (CollUtil.isNotEmpty(info)) {
+            dataPollutionFeignClient.batchInsertionOrgD(info);
         }
     }
 
     @Override
     public void handleOrgMonth(CalculatedParam<DeptGetChildrenMoreDTO> calculatedParam) {
-
+        List<DataPollutionOrgM> info = new ArrayList<>();
+        //远程接口获取分钟数据
+        LineCountEvaluateParam lineParam = new LineCountEvaluateParam();
+        lineParam.setStartTime(TimeUtils.getBeginOfMonth(calculatedParam.getDataDate()));
+        lineParam.setEndTime(TimeUtils.getEndOfMonth(calculatedParam.getDataDate()));
+        LocalDate localDate = LocalDateTimeUtil.parseDate(lineParam.getStartTime());
+        for (DeptGetChildrenMoreDTO deptGetChildrenMoreDTO : calculatedParam.getIdList()) {
+            Collection<LineDevGetDTO> union = CollectionUtils.union
+                    (Optional.ofNullable(deptGetChildrenMoreDTO.getLineBaseList()).orElse(new ArrayList<>()),
+                            Optional.ofNullable(deptGetChildrenMoreDTO.getPwMonitorIds()).orElse(new ArrayList<>()));
+            List<String> lineIds = union.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
+            if (CollUtil.isNotEmpty(lineIds)) {
+                lineParam.setLineId(lineIds);
+                List<DataPollutionOrgD> data = dataPollutionFeignClient.getRawDataOrgD(lineParam).getData();
+                Map<String, List<DataPollutionOrgD>> pollutionMap = data.stream().collect(Collectors.groupingBy(DataPollutionOrgD::getPollutionType));
+                pollutionMap.forEach((key, value) -> {
+                    DataPollutionOrgM orgD = new DataPollutionOrgM();
+                    orgD.setOrgId(deptGetChildrenMoreDTO.getUnitId());
+                    orgD.setDataDate(localDate);
+                    orgD.setPollutionType(key);
+                    orgD.setValue(value.stream().max(Comparator.comparing(DataPollutionOrgD::getValue)).get().getValue());
+                    info.add(orgD);
+                });
+            }
+        }
+        if (CollUtil.isNotEmpty(info)) {
+            dataPollutionFeignClient.batchInsertionOrgM(info);
+        }
     }
 
     @Override
     public void handleOrgQtr(CalculatedParam<DeptGetChildrenMoreDTO> calculatedParam) {
-
+        List<DataPollutionOrgQ> info = new ArrayList<>();
+        //远程接口获取分钟数据
+        LineCountEvaluateParam lineParam = new LineCountEvaluateParam();
+        lineParam.setStartTime(TimeUtils.getBeginOfQuarter(calculatedParam.getDataDate()));
+        lineParam.setEndTime(TimeUtils.getEndOfQuarter(calculatedParam.getDataDate()));
+        LocalDate localDate = LocalDateTimeUtil.parseDate(lineParam.getStartTime());
+        for (DeptGetChildrenMoreDTO deptGetChildrenMoreDTO : calculatedParam.getIdList()) {
+            Collection<LineDevGetDTO> union = CollectionUtils.union
+                    (Optional.ofNullable(deptGetChildrenMoreDTO.getLineBaseList()).orElse(new ArrayList<>()),
+                            Optional.ofNullable(deptGetChildrenMoreDTO.getPwMonitorIds()).orElse(new ArrayList<>()));
+            List<String> lineIds = union.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
+            if (CollUtil.isNotEmpty(lineIds)) {
+                lineParam.setLineId(lineIds);
+                List<DataPollutionOrgM> data = dataPollutionFeignClient.getRawDataOrgM(lineParam).getData();
+                Map<String, List<DataPollutionOrgM>> pollutionMap = data.stream().collect(Collectors.groupingBy(DataPollutionOrgM::getPollutionType));
+                pollutionMap.forEach((key, value) -> {
+                    DataPollutionOrgQ orgD = new DataPollutionOrgQ();
+                    orgD.setOrgId(deptGetChildrenMoreDTO.getUnitId());
+                    orgD.setDataDate(localDate);
+                    orgD.setPollutionType(key);
+                    orgD.setValue(value.stream().max(Comparator.comparing(DataPollutionOrgM::getValue)).get().getValue());
+                    info.add(orgD);
+                });
+            }
+        }
+        if (CollUtil.isNotEmpty(info)) {
+            dataPollutionFeignClient.batchInsertionOrgQ(info);
+        }
     }
 
     @Override
     public void handleOrgYear(CalculatedParam<DeptGetChildrenMoreDTO> calculatedParam) {
-
+        List<DataPollutionOrgY> info = new ArrayList<>();
+        //远程接口获取分钟数据
+        LineCountEvaluateParam lineParam = new LineCountEvaluateParam();
+        lineParam.setStartTime(TimeUtils.getBeginOfYear(calculatedParam.getDataDate()));
+        lineParam.setEndTime(TimeUtils.getEndOfYear(calculatedParam.getDataDate()));
+        LocalDate localDate = LocalDateTimeUtil.parseDate(lineParam.getStartTime());
+        for (DeptGetChildrenMoreDTO deptGetChildrenMoreDTO : calculatedParam.getIdList()) {
+            Collection<LineDevGetDTO> union = CollectionUtils.union
+                    (Optional.ofNullable(deptGetChildrenMoreDTO.getLineBaseList()).orElse(new ArrayList<>()),
+                            Optional.ofNullable(deptGetChildrenMoreDTO.getPwMonitorIds()).orElse(new ArrayList<>()));
+            List<String> lineIds = union.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
+            if (CollUtil.isNotEmpty(lineIds)) {
+                lineParam.setLineId(lineIds);
+                List<DataPollutionOrgQ> data = dataPollutionFeignClient.getRawDataOrgQ(lineParam).getData();
+                Map<String, List<DataPollutionOrgQ>> pollutionMap = data.stream().collect(Collectors.groupingBy(DataPollutionOrgQ::getPollutionType));
+                pollutionMap.forEach((key, value) -> {
+                    DataPollutionOrgY orgD = new DataPollutionOrgY();
+                    orgD.setOrgId(deptGetChildrenMoreDTO.getUnitId());
+                    orgD.setDataDate(localDate);
+                    orgD.setPollutionType(key);
+                    orgD.setValue(value.stream().max(Comparator.comparing(DataPollutionOrgQ::getValue)).get().getValue());
+                    info.add(orgD);
+                });
+            }
+        }
+        if (CollUtil.isNotEmpty(info)) {
+            dataPollutionFeignClient.batchInsertionOrgY(info);
+        }
     }
 
     @Override
     public void handleSubstationDay(CalculatedParam<String> calculatedParam) {
-
+        List<DataPollutionSubstationD> info = new ArrayList<>();
+        //远程接口获取分钟数据
+        LineCountEvaluateParam lineParam = new LineCountEvaluateParam();
+        lineParam.setStartTime(TimeUtils.getBeginOfDay(calculatedParam.getDataDate()));
+        lineParam.setEndTime(TimeUtils.getEndOfDay(calculatedParam.getDataDate()));
+        LocalDate localDate = LocalDateTimeUtil.parseDate(calculatedParam.getDataDate());
+        for (String substationId : calculatedParam.getIdList()) {
+            LineDevGetBandDTO data = commTerminalGeneralClient.substationGetLine(substationId).getData();
+            Collection<LineDevGetDTO> union = CollectionUtils.union(Optional.ofNullable(data.getPwList()).orElse(new ArrayList<>()),
+                    Optional.ofNullable(data.getZwList()).orElse(new ArrayList<>()));
+            List<String> lindIds = union.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
+            if (CollUtil.isNotEmpty(lindIds)) {
+                lineParam.setLineId(lindIds);
+                List<DataPollutionD> pollutionDS = dataPollutionFeignClient.getRawData(lineParam).getData();
+                Map<String, List<DataPollutionD>> pollutionMap = pollutionDS.stream().collect(Collectors.groupingBy(DataPollutionD::getPollutionType));
+                pollutionMap.forEach((key, value) -> {
+                    DataPollutionSubstationD orgD = new DataPollutionSubstationD();
+                    orgD.setSubstationId(substationId);
+                    orgD.setDataDate(localDate);
+                    orgD.setPollutionType(key);
+                    orgD.setValue(value.stream().max(Comparator.comparing(DataPollutionD::getValue)).get().getValue());
+                    info.add(orgD);
+                });
+            }
+        }
+        if (CollUtil.isNotEmpty(info)) {
+            dataPollutionFeignClient.batchInsertionSubstationD(info);
+        }
     }
 
     @Override
     public void handleSubstationMonth(CalculatedParam<String> calculatedParam) {
-
+        List<DataPollutionSubstationM> info = new ArrayList<>();
+        //远程接口获取分钟数据
+        LineCountEvaluateParam lineParam = new LineCountEvaluateParam();
+        lineParam.setStartTime(TimeUtils.getBeginOfMonth(calculatedParam.getDataDate()));
+        lineParam.setEndTime(TimeUtils.getEndOfMonth(calculatedParam.getDataDate()));
+        LocalDate localDate = LocalDateTimeUtil.parseDate(lineParam.getStartTime());
+        for (String substationId : calculatedParam.getIdList()) {
+            LineDevGetBandDTO data = commTerminalGeneralClient.substationGetLine(substationId).getData();
+            Collection<LineDevGetDTO> union = CollectionUtils.union(Optional.ofNullable(data.getPwList()).orElse(new ArrayList<>()),
+                    Optional.ofNullable(data.getZwList()).orElse(new ArrayList<>()));
+            List<String> lindIds = union.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
+            if (CollUtil.isNotEmpty(lindIds)) {
+                lineParam.setLineId(lindIds);
+                List<DataPollutionSubstationD> pollutionDS = dataPollutionFeignClient.getRawDataSubstationD(lineParam).getData();
+                Map<String, List<DataPollutionSubstationD>> pollutionMap = pollutionDS.stream().collect(Collectors.groupingBy(DataPollutionSubstationD::getPollutionType));
+                pollutionMap.forEach((key, value) -> {
+                    DataPollutionSubstationM orgD = new DataPollutionSubstationM();
+                    orgD.setSubstationId(substationId);
+                    orgD.setDataDate(localDate);
+                    orgD.setPollutionType(key);
+                    orgD.setValue(value.stream().max(Comparator.comparing(DataPollutionSubstationD::getValue)).get().getValue());
+                    info.add(orgD);
+                });
+            }
+        }
+        if (CollUtil.isNotEmpty(info)) {
+            dataPollutionFeignClient.batchInsertionSubstationM(info);
+        }
     }
 
     @Override
     public void handleSubstationQtr(CalculatedParam<String> calculatedParam) {
-
+        List<DataPollutionSubstationQ> info = new ArrayList<>();
+        //远程接口获取分钟数据
+        LineCountEvaluateParam lineParam = new LineCountEvaluateParam();
+        lineParam.setStartTime(TimeUtils.getBeginOfQuarter(calculatedParam.getDataDate()));
+        lineParam.setEndTime(TimeUtils.getEndOfQuarter(calculatedParam.getDataDate()));
+        LocalDate localDate = LocalDateTimeUtil.parseDate(lineParam.getStartTime());
+        for (String substationId : calculatedParam.getIdList()) {
+            LineDevGetBandDTO data = commTerminalGeneralClient.substationGetLine(substationId).getData();
+            Collection<LineDevGetDTO> union = CollectionUtils.union(Optional.ofNullable(data.getPwList()).orElse(new ArrayList<>()),
+                    Optional.ofNullable(data.getZwList()).orElse(new ArrayList<>()));
+            List<String> lindIds = union.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
+            if (CollUtil.isNotEmpty(lindIds)) {
+                lineParam.setLineId(lindIds);
+                List<DataPollutionSubstationM> pollutionDS = dataPollutionFeignClient.getRawDataSubstationM(lineParam).getData();
+                Map<String, List<DataPollutionSubstationM>> pollutionMap = pollutionDS.stream().collect(Collectors.groupingBy(DataPollutionSubstationM::getPollutionType));
+                pollutionMap.forEach((key, value) -> {
+                    DataPollutionSubstationQ orgD = new DataPollutionSubstationQ();
+                    orgD.setSubstationId(substationId);
+                    orgD.setDataDate(localDate);
+                    orgD.setPollutionType(key);
+                    orgD.setValue(value.stream().max(Comparator.comparing(DataPollutionSubstationM::getValue)).get().getValue());
+                    info.add(orgD);
+                });
+            }
+        }
+        if (CollUtil.isNotEmpty(info)) {
+            dataPollutionFeignClient.batchInsertionSubstationQ(info);
+        }
     }
 
     @Override
     public void handleSubstationYear(CalculatedParam<String> calculatedParam) {
-
+        List<DataPollutionSubstationY> info = new ArrayList<>();
+        //远程接口获取分钟数据
+        LineCountEvaluateParam lineParam = new LineCountEvaluateParam();
+        lineParam.setStartTime(TimeUtils.getBeginOfYear(calculatedParam.getDataDate()));
+        lineParam.setEndTime(TimeUtils.getEndOfYear(calculatedParam.getDataDate()));
+        LocalDate localDate = LocalDateTimeUtil.parseDate(lineParam.getStartTime());
+        for (String substationId : calculatedParam.getIdList()) {
+            LineDevGetBandDTO data = commTerminalGeneralClient.substationGetLine(substationId).getData();
+            Collection<LineDevGetDTO> union = CollectionUtils.union(Optional.ofNullable(data.getPwList()).orElse(new ArrayList<>()),
+                    Optional.ofNullable(data.getZwList()).orElse(new ArrayList<>()));
+            List<String> lindIds = union.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
+            if (CollUtil.isNotEmpty(lindIds)) {
+                lineParam.setLineId(lindIds);
+                List<DataPollutionSubstationQ> pollutionDS = dataPollutionFeignClient.getRawDataSubstationQ(lineParam).getData();
+                Map<String, List<DataPollutionSubstationQ>> pollutionMap = pollutionDS.stream().collect(Collectors.groupingBy(DataPollutionSubstationQ::getPollutionType));
+                pollutionMap.forEach((key, value) -> {
+                    DataPollutionSubstationY orgD = new DataPollutionSubstationY();
+                    orgD.setSubstationId(substationId);
+                    orgD.setDataDate(localDate);
+                    orgD.setPollutionType(key);
+                    orgD.setValue(value.stream().max(Comparator.comparing(DataPollutionSubstationQ::getValue)).get().getValue());
+                    info.add(orgD);
+                });
+            }
+        }
+        if (CollUtil.isNotEmpty(info)) {
+            dataPollutionFeignClient.batchInsertionSubstationY(info);
+        }
     }
 
+    /**
+     * @param lineParam
+     * @Description:
+     * @Author: wr
+     * @Date: 2025/3/11 9:04
+     */
+    private void getAbnormalData(LineCountEvaluateParam lineParam) {
+        lineParam.setTableName(DataCleanEnum.DataV.getCode());
+        // 获取异常数据，用于排除异常数据
+        List<PqDataVerify> pqDataVerifies = pqDataVerifyFeignClient.queryData(lineParam).getData();
+        if (CollUtil.isNotEmpty(pqDataVerifies)) {
+            Map<String, List<String>> timeMap = pqDataVerifies.stream()
+                    .collect(Collectors.groupingBy(
+                            PqDataVerify::getLineId,
+                            Collectors.mapping(item -> TimeUtils.LocalDateTimeToString(item.getTime()), Collectors.toList())
+                    ));
+            lineParam.setAbnormalTime(timeMap);
+        }
+    }
 
     private void assPollution(String lineId, LocalDate local, DictData dic, Map<String, DataPollutionD> map, List<DataPollutionD> result) {
         DataPollutionD tem;

data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/api/DataPollutionFeignClient.java

@@ -3,7 +3,8 @@ package com.njcn.dataProcess.api;
 import com.njcn.common.pojo.constant.ServerInfo;
 import com.njcn.common.pojo.response.HttpResult;
 import com.njcn.dataProcess.api.fallback.DataPollutionFeignClientFallbackFactory;
-import com.njcn.dataProcess.pojo.dto.DataPollutionD;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.*;
 import org.springframework.cloud.openfeign.FeignClient;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -20,6 +21,51 @@ public interface DataPollutionFeignClient {
 
     @PostMapping("/batchInsertion")
     HttpResult<String> batchInsertion(@RequestBody List<DataPollutionD> dataIDTOList);
+    @PostMapping("/getRawData")
+    HttpResult<List<DataPollutionD>> getRawData(@RequestBody LineCountEvaluateParam lineParam);
 
 
+    @PostMapping("/batchInsertionOrgD")
+    HttpResult<String> batchInsertionOrgD(@RequestBody List<DataPollutionOrgD> dataIDTOList);
+    @PostMapping("/getRawDataOrgD")
+    HttpResult<List<DataPollutionOrgD>> getRawDataOrgD(@RequestBody LineCountEvaluateParam lineParam);
+
+    @PostMapping("/batchInsertionOrgM")
+    HttpResult<String> batchInsertionOrgM(@RequestBody List<DataPollutionOrgM> dataIDTOList);
+    @PostMapping("/getRawDataOrgM")
+    HttpResult<List<DataPollutionOrgM>> getRawDataOrgM(@RequestBody LineCountEvaluateParam lineParam);
+
+
+    @PostMapping("/batchInsertionOrgQ")
+    HttpResult<String> batchInsertionOrgQ(@RequestBody List<DataPollutionOrgQ> dataIDTOList);
+    @PostMapping("/getRawDataOrgQ")
+    HttpResult<List<DataPollutionOrgQ>> getRawDataOrgQ(@RequestBody LineCountEvaluateParam lineParam);
+
+
+    @PostMapping("/batchInsertionOrgY")
+    HttpResult<String> batchInsertionOrgY(@RequestBody List<DataPollutionOrgY> dataIDTOList);
+    @PostMapping("/getRawDataOrgY")
+    HttpResult<List<DataPollutionOrgY>> getRawDataOrgY(@RequestBody LineCountEvaluateParam lineParam);
+
+
+    @PostMapping("/batchInsertionSubstationD")
+    HttpResult<String> batchInsertionSubstationD(@RequestBody List<DataPollutionSubstationD> dataIDTOList);
+    @PostMapping("/getRawDataSubstationD")
+    HttpResult<List<DataPollutionSubstationD>> getRawDataSubstationD(@RequestBody LineCountEvaluateParam lineParam);
+
+    @PostMapping("/batchInsertionSubstationM")
+    HttpResult<String> batchInsertionSubstationM(@RequestBody List<DataPollutionSubstationM> dataIDTOList);
+    @PostMapping("/getRawDataSubstationM")
+    HttpResult<List<DataPollutionSubstationM>> getRawDataSubstationM(@RequestBody LineCountEvaluateParam lineParam);
+
+
+    @PostMapping("/batchInsertionSubstationQ")
+    HttpResult<String> batchInsertionSubstationQ(@RequestBody List<DataPollutionSubstationQ> dataIDTOList);
+    @PostMapping("/getRawDataSubstationQ")
+    HttpResult<List<DataPollutionSubstationQ>> getRawDataSubstationQ(@RequestBody LineCountEvaluateParam lineParam);
+
+    @PostMapping("/batchInsertionSubstationY")
+    HttpResult<String> batchInsertionSubstationY(@RequestBody List<DataPollutionSubstationY> dataIDTOList);
+    @PostMapping("/getRawDataSubstationY")
+    HttpResult<List<DataPollutionSubstationY>> getRawDataSubstationY(@RequestBody LineCountEvaluateParam lineParam);
 }

data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/api/fallback/DataPollutionFeignClientFallbackFactory.java

@@ -4,21 +4,13 @@ import com.njcn.common.pojo.enums.response.CommonResponseEnum;
 import com.njcn.common.pojo.exception.BusinessException;
 import com.njcn.common.pojo.response.HttpResult;
 import com.njcn.dataProcess.api.DataPollutionFeignClient;
-import com.njcn.dataProcess.api.DataVFeignClient;
-import com.njcn.dataProcess.dto.DataVDTO;
-import com.njcn.dataProcess.dto.MeasurementCountDTO;
 import com.njcn.dataProcess.param.LineCountEvaluateParam;
-import com.njcn.dataProcess.pojo.dto.CommonMinuteDto;
+import com.njcn.dataProcess.pojo.dto.*;
-import com.njcn.dataProcess.pojo.dto.DataPollutionD;
-import com.njcn.dataProcess.pojo.dto.DataVCvtDto;
-import com.njcn.dataProcess.pojo.dto.DataVDto;
 import com.njcn.dataProcess.util.DataProcessingEnumUtil;
 import feign.hystrix.FallbackFactory;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
-import org.springframework.web.bind.annotation.RequestBody;
 
-import java.time.LocalDateTime;
 import java.util.List;
 
 /**
@@ -48,7 +40,109 @@ public class DataPollutionFeignClientFallbackFactory implements FallbackFactory<
 
             @Override
             public HttpResult<String> batchInsertion(List<DataPollutionD> dataVDTOList) {
-                log.error("{}异常，降级处理，异常为：{}","批量插入数据",cause.toString());
+                log.error("{}异常，降级处理，异常为：{}","监测点批量插入",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<List<DataPollutionD>> getRawData(LineCountEvaluateParam lineParam) {
+                log.error("{}异常，降级处理，异常为：{}","获取监测点原始数据",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<String> batchInsertionOrgD(List<DataPollutionOrgD> dataIDTOList) {
+                log.error("{}异常，降级处理，异常为：{}","部门(天)批量插入",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<List<DataPollutionOrgD>> getRawDataOrgD(LineCountEvaluateParam lineParam) {
+                log.error("{}异常，降级处理，异常为：{}","获取部门(天)原始数据",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<String> batchInsertionOrgM(List<DataPollutionOrgM> dataIDTOList) {
+                log.error("{}异常，降级处理，异常为：{}","部门(月)批量插入",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<List<DataPollutionOrgM>> getRawDataOrgM(LineCountEvaluateParam lineParam) {
+                log.error("{}异常，降级处理，异常为：{}","获取部门(月)原始数据",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<String> batchInsertionOrgQ(List<DataPollutionOrgQ> dataIDTOList) {
+                log.error("{}异常，降级处理，异常为：{}","部门(季)批量插入",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<List<DataPollutionOrgQ>> getRawDataOrgQ(LineCountEvaluateParam lineParam) {
+                log.error("{}异常，降级处理，异常为：{}","获取部门(季)原始数据",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<String> batchInsertionOrgY(List<DataPollutionOrgY> dataIDTOList) {
+                log.error("{}异常，降级处理，异常为：{}","部门(年)批量插入",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<List<DataPollutionOrgY>> getRawDataOrgY(LineCountEvaluateParam lineParam) {
+                log.error("{}异常，降级处理，异常为：{}","获取部门(年)原始数据",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<String> batchInsertionSubstationD(List<DataPollutionSubstationD> dataIDTOList) {
+                log.error("{}异常，降级处理，异常为：{}","变电站(天)批量插入",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<List<DataPollutionSubstationD>> getRawDataSubstationD(LineCountEvaluateParam lineParam) {
+                log.error("{}异常，降级处理，异常为：{}","获取变电站(天)原始数据",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<String> batchInsertionSubstationM(List<DataPollutionSubstationM> dataIDTOList) {
+                log.error("{}异常，降级处理，异常为：{}","变电站(月)批量插入",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<List<DataPollutionSubstationM>> getRawDataSubstationM(LineCountEvaluateParam lineParam) {
+                log.error("{}异常，降级处理，异常为：{}","获取变电站(月)原始数据",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<String> batchInsertionSubstationQ(List<DataPollutionSubstationQ> dataIDTOList) {
+                log.error("{}异常，降级处理，异常为：{}","变电站(季)批量插入",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<List<DataPollutionSubstationQ>> getRawDataSubstationQ(LineCountEvaluateParam lineParam) {
+                log.error("{}异常，降级处理，异常为：{}","获取变电站(季)原始数据",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<String> batchInsertionSubstationY(List<DataPollutionSubstationY> dataIDTOList) {
+                log.error("{}异常，降级处理，异常为：{}","变电站(年)批量插入",cause.toString());
+                throw new BusinessException(finalExceptionEnum);
+            }
+
+            @Override
+            public HttpResult<List<DataPollutionSubstationY>> getRawDataSubstationY(LineCountEvaluateParam lineParam) {
+                log.error("{}异常，降级处理，异常为：{}","获取变电站(年)原始数据",cause.toString());
                 throw new BusinessException(finalExceptionEnum);
             }
 

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/DataPollutionController.java

@@ -8,6 +8,7 @@ import com.njcn.common.pojo.response.HttpResult;
 import com.njcn.common.utils.HttpResultUtil;
 import com.njcn.dataProcess.annotation.InsertBean;
 import com.njcn.dataProcess.annotation.QueryBean;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
 import com.njcn.dataProcess.pojo.dto.DataPollutionD;
 import com.njcn.dataProcess.service.IDataPollution;
 import com.njcn.web.controller.BaseController;
@@ -42,10 +43,9 @@ public class DataPollutionController extends BaseController {
     @InsertBean
     private IDataPollution dataPollutionInsert;
 
-
     @OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
     @PostMapping("/batchInsertion")
-    @ApiOperation("批量插入")
+    @ApiOperation("监测点批量插入")
     public HttpResult<String> batchInsertion(@RequestBody List<DataPollutionD> dataIDTOList) {
         String methodDescribe = getMethodDescribe("batchInsertion");
         dataPollutionInsert.batchInsertion(dataIDTOList);
@@ -53,6 +53,13 @@ public class DataPollutionController extends BaseController {
     }
 
 
-
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/getRawData")
+    @ApiOperation("获取监测点原始数据")
+    public HttpResult<List<DataPollutionD>> getRawData(@RequestBody LineCountEvaluateParam lineParam) {
+        String methodDescribe = getMethodDescribe("getRawData");
+        List<DataPollutionD> rawData = dataPollutionInsert.getRawData(lineParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, rawData, methodDescribe);
+    }
 
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/DataPollutionOrgDController.java

@@ -0,0 +1,65 @@
+package com.njcn.dataProcess.controller;
+
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.constant.OperateType;
+import com.njcn.common.pojo.enums.common.LogEnum;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.common.utils.HttpResultUtil;
+import com.njcn.dataProcess.annotation.InsertBean;
+import com.njcn.dataProcess.annotation.QueryBean;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgD;
+import com.njcn.dataProcess.service.IDataPollutionOrgD;
+import com.njcn.web.controller.BaseController;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Controller;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * @author hongawen
+ * @version 1.0
+ * @data 2024/11/6 19:48
+ */
+@Validated
+@Slf4j
+@Controller
+@RestController
+@RequestMapping("/dataPollution")
+@Api(tags = "污区图数据")
+public class DataPollutionOrgDController extends BaseController {
+
+    @QueryBean
+    private IDataPollutionOrgD dataPollutionOrgDQuery;
+
+    @InsertBean
+    private IDataPollutionOrgD dataPollutionOrgDInsert;
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
+    @PostMapping("/batchInsertionOrgD")
+    @ApiOperation("部门(天)批量插入")
+    public HttpResult<String> batchInsertionOrgD(@RequestBody List<DataPollutionOrgD> dataIDTOList) {
+        String methodDescribe = getMethodDescribe("batchInsertionOrgD");
+        dataPollutionOrgDInsert.batchInsertion(dataIDTOList);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+    }
+
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/getRawDataOrgD")
+    @ApiOperation("获取部门(天)原始数据")
+    public HttpResult<List<DataPollutionOrgD>> getRawDataOrgD(@RequestBody LineCountEvaluateParam lineParam) {
+        String methodDescribe = getMethodDescribe("getRawDataOrgD");
+        List<DataPollutionOrgD> rawData = dataPollutionOrgDInsert.getRawData(lineParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, rawData, methodDescribe);
+    }
+
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/DataPollutionOrgMController.java

@@ -0,0 +1,65 @@
+package com.njcn.dataProcess.controller;
+
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.constant.OperateType;
+import com.njcn.common.pojo.enums.common.LogEnum;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.common.utils.HttpResultUtil;
+import com.njcn.dataProcess.annotation.InsertBean;
+import com.njcn.dataProcess.annotation.QueryBean;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgM;
+import com.njcn.dataProcess.service.IDataPollutionOrgM;
+import com.njcn.web.controller.BaseController;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Controller;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * @author hongawen
+ * @version 1.0
+ * @data 2024/11/6 19:48
+ */
+@Validated
+@Slf4j
+@Controller
+@RestController
+@RequestMapping("/dataPollution")
+@Api(tags = "污区图数据")
+public class DataPollutionOrgMController extends BaseController {
+
+    @QueryBean
+    private IDataPollutionOrgM dataPollutionOrgMQuery;
+
+    @InsertBean
+    private IDataPollutionOrgM dataPollutionOrgMInsert;
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
+    @PostMapping("/batchInsertionOrgM")
+    @ApiOperation("部门(月)批量插入")
+    public HttpResult<String> batchInsertionOrgM(@RequestBody List<DataPollutionOrgM> dataIDTOList) {
+        String methodDescribe = getMethodDescribe("batchInsertionOrgM");
+        dataPollutionOrgMInsert.batchInsertion(dataIDTOList);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+    }
+
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/getRawDataOrgM")
+    @ApiOperation("获取部门(月)原始数据")
+    public HttpResult<List<DataPollutionOrgM>> getRawDataOrgM(@RequestBody LineCountEvaluateParam lineParam) {
+        String methodDescribe = getMethodDescribe("getRawDataOrgM");
+        List<DataPollutionOrgM> rawData = dataPollutionOrgMInsert.getRawData(lineParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, rawData, methodDescribe);
+    }
+
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/DataPollutionOrgQController.java

@@ -0,0 +1,65 @@
+package com.njcn.dataProcess.controller;
+
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.constant.OperateType;
+import com.njcn.common.pojo.enums.common.LogEnum;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.common.utils.HttpResultUtil;
+import com.njcn.dataProcess.annotation.InsertBean;
+import com.njcn.dataProcess.annotation.QueryBean;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgQ;
+import com.njcn.dataProcess.service.IDataPollutionOrgQ;
+import com.njcn.web.controller.BaseController;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Controller;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * @author hongawen
+ * @version 1.0
+ * @data 2024/11/6 19:48
+ */
+@Validated
+@Slf4j
+@Controller
+@RestController
+@RequestMapping("/dataPollution")
+@Api(tags = "污区图数据")
+public class DataPollutionOrgQController extends BaseController {
+
+    @QueryBean
+    private IDataPollutionOrgQ dataPollutionOrgQQuery;
+
+    @InsertBean
+    private IDataPollutionOrgQ dataPollutionOrgQInsert;
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
+    @PostMapping("/batchInsertionOrgQ")
+    @ApiOperation("部门(季)批量插入")
+    public HttpResult<String> batchInsertionOrgQ(@RequestBody List<DataPollutionOrgQ> dataIDTOList) {
+        String methodDescribe = getMethodDescribe("batchInsertionOrgQ");
+        dataPollutionOrgQInsert.batchInsertion(dataIDTOList);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+    }
+
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/getRawDataOrgQ")
+    @ApiOperation("获取部门(季)原始数据")
+    public HttpResult<List<DataPollutionOrgQ>> getRawDataOrgQ(@RequestBody LineCountEvaluateParam lineParam) {
+        String methodDescribe = getMethodDescribe("getRawDataOrgQ");
+        List<DataPollutionOrgQ> rawData = dataPollutionOrgQInsert.getRawData(lineParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, rawData, methodDescribe);
+    }
+
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/DataPollutionOrgYController.java

@@ -0,0 +1,65 @@
+package com.njcn.dataProcess.controller;
+
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.constant.OperateType;
+import com.njcn.common.pojo.enums.common.LogEnum;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.common.utils.HttpResultUtil;
+import com.njcn.dataProcess.annotation.InsertBean;
+import com.njcn.dataProcess.annotation.QueryBean;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgY;
+import com.njcn.dataProcess.service.IDataPollutionOrgY;
+import com.njcn.web.controller.BaseController;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Controller;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * @author hongawen
+ * @version 1.0
+ * @data 2024/11/6 19:48
+ */
+@Validated
+@Slf4j
+@Controller
+@RestController
+@RequestMapping("/dataPollution")
+@Api(tags = "污区图数据")
+public class DataPollutionOrgYController extends BaseController {
+
+    @QueryBean
+    private IDataPollutionOrgY dataPollutionOrgYQuery;
+
+    @InsertBean
+    private IDataPollutionOrgY dataPollutionOrgYInsert;
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
+    @PostMapping("/batchInsertionOrgY")
+    @ApiOperation("部门(年)批量插入")
+    public HttpResult<String> batchInsertionOrgY(@RequestBody List<DataPollutionOrgY> dataIDTOList) {
+        String methodDescribe = getMethodDescribe("batchInsertionOrgY");
+        dataPollutionOrgYInsert.batchInsertion(dataIDTOList);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+    }
+
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/getRawDataOrgY")
+    @ApiOperation("获取部门(年)原始数据")
+    public HttpResult<List<DataPollutionOrgY>> getRawDataOrgY(@RequestBody LineCountEvaluateParam lineParam) {
+        String methodDescribe = getMethodDescribe("getRawDataOrgY");
+        List<DataPollutionOrgY> rawData = dataPollutionOrgYInsert.getRawData(lineParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, rawData, methodDescribe);
+    }
+
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/DataPollutionSubstationDController.java

@@ -0,0 +1,65 @@
+package com.njcn.dataProcess.controller;
+
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.constant.OperateType;
+import com.njcn.common.pojo.enums.common.LogEnum;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.common.utils.HttpResultUtil;
+import com.njcn.dataProcess.annotation.InsertBean;
+import com.njcn.dataProcess.annotation.QueryBean;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationD;
+import com.njcn.dataProcess.service.IDataPollutionSubstationD;
+import com.njcn.web.controller.BaseController;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Controller;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * @author hongawen
+ * @version 1.0
+ * @data 2024/11/6 19:48
+ */
+@Validated
+@Slf4j
+@Controller
+@RestController
+@RequestMapping("/dataPollution")
+@Api(tags = "污区图数据")
+public class DataPollutionSubstationDController extends BaseController {
+
+    @QueryBean
+    private IDataPollutionSubstationD dataPollutionSubstationDQuery;
+
+    @InsertBean
+    private IDataPollutionSubstationD dataPollutionSubstationDInsert;
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
+    @PostMapping("/batchInsertionSubstationD")
+    @ApiOperation("变电站(天)批量插入")
+    public HttpResult<String> batchInsertionSubstationD(@RequestBody List<DataPollutionSubstationD> dataIDTOList) {
+        String methodDescribe = getMethodDescribe("batchInsertionSubstationD");
+        dataPollutionSubstationDInsert.batchInsertion(dataIDTOList);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+    }
+
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/getRawDataSubstationD")
+    @ApiOperation("获取变电站(天)原始数据")
+    public HttpResult<List<DataPollutionSubstationD>> getRawDataSubstationD(@RequestBody LineCountEvaluateParam lineParam) {
+        String methodDescribe = getMethodDescribe("getRawDataSubstationD");
+        List<DataPollutionSubstationD> rawData = dataPollutionSubstationDInsert.getRawData(lineParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, rawData, methodDescribe);
+    }
+
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/DataPollutionSubstationMController.java

@@ -0,0 +1,65 @@
+package com.njcn.dataProcess.controller;
+
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.constant.OperateType;
+import com.njcn.common.pojo.enums.common.LogEnum;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.common.utils.HttpResultUtil;
+import com.njcn.dataProcess.annotation.InsertBean;
+import com.njcn.dataProcess.annotation.QueryBean;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationM;
+import com.njcn.dataProcess.service.IDataPollutionSubstationM;
+import com.njcn.web.controller.BaseController;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Controller;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * @author hongawen
+ * @version 1.0
+ * @data 2024/11/6 19:48
+ */
+@Validated
+@Slf4j
+@Controller
+@RestController
+@RequestMapping("/dataPollution")
+@Api(tags = "污区图数据")
+public class DataPollutionSubstationMController extends BaseController {
+
+    @QueryBean
+    private IDataPollutionSubstationM dataPollutionSubstationDQuery;
+
+    @InsertBean
+    private IDataPollutionSubstationM dataPollutionSubstationDInsert;
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
+    @PostMapping("/batchInsertionSubstationM")
+    @ApiOperation("变电站(月)批量插入")
+    public HttpResult<String> batchInsertionSubstationM(@RequestBody List<DataPollutionSubstationM> dataIDTOList) {
+        String methodDescribe = getMethodDescribe("batchInsertionSubstationM");
+        dataPollutionSubstationDInsert.batchInsertion(dataIDTOList);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+    }
+
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/getRawDataSubstationM")
+    @ApiOperation("获取变电站(月)原始数据")
+    public HttpResult<List<DataPollutionSubstationM>> getRawDataSubstationM(@RequestBody LineCountEvaluateParam lineParam) {
+        String methodDescribe = getMethodDescribe("getRawDataSubstationM");
+        List<DataPollutionSubstationM> rawData = dataPollutionSubstationDInsert.getRawData(lineParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, rawData, methodDescribe);
+    }
+
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/DataPollutionSubstationQController.java

@@ -0,0 +1,65 @@
+package com.njcn.dataProcess.controller;
+
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.constant.OperateType;
+import com.njcn.common.pojo.enums.common.LogEnum;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.common.utils.HttpResultUtil;
+import com.njcn.dataProcess.annotation.InsertBean;
+import com.njcn.dataProcess.annotation.QueryBean;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationQ;
+import com.njcn.dataProcess.service.IDataPollutionSubstationQ;
+import com.njcn.web.controller.BaseController;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Controller;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * @author hongawen
+ * @version 1.0
+ * @data 2024/11/6 19:48
+ */
+@Validated
+@Slf4j
+@Controller
+@RestController
+@RequestMapping("/dataPollution")
+@Api(tags = "污区图数据")
+public class DataPollutionSubstationQController extends BaseController {
+
+    @QueryBean
+    private IDataPollutionSubstationQ dataPollutionSubstationDQuery;
+
+    @InsertBean
+    private IDataPollutionSubstationQ dataPollutionSubstationDInsert;
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
+    @PostMapping("/batchInsertionSubstationQ")
+    @ApiOperation("变电站(季)批量插入")
+    public HttpResult<String> batchInsertionSubstationQ(@RequestBody List<DataPollutionSubstationQ> dataIDTOList) {
+        String methodDescribe = getMethodDescribe("batchInsertionSubstationQ");
+        dataPollutionSubstationDInsert.batchInsertion(dataIDTOList);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+    }
+
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/getRawDataSubstationQ")
+    @ApiOperation("获取变电站(季)原始数据")
+    public HttpResult<List<DataPollutionSubstationQ>> getRawDataSubstationQ(@RequestBody LineCountEvaluateParam lineParam) {
+        String methodDescribe = getMethodDescribe("getRawDataSubstationQ");
+        List<DataPollutionSubstationQ> rawData = dataPollutionSubstationDInsert.getRawData(lineParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, rawData, methodDescribe);
+    }
+
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/DataPollutionSubstationYController.java

@@ -0,0 +1,65 @@
+package com.njcn.dataProcess.controller;
+
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.constant.OperateType;
+import com.njcn.common.pojo.enums.common.LogEnum;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.common.utils.HttpResultUtil;
+import com.njcn.dataProcess.annotation.InsertBean;
+import com.njcn.dataProcess.annotation.QueryBean;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationY;
+import com.njcn.dataProcess.service.IDataPollutionSubstationY;
+import com.njcn.web.controller.BaseController;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Controller;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * @author hongawen
+ * @version 1.0
+ * @data 2024/11/6 19:48
+ */
+@Validated
+@Slf4j
+@Controller
+@RestController
+@RequestMapping("/dataPollution")
+@Api(tags = "污区图数据")
+public class DataPollutionSubstationYController extends BaseController {
+
+    @QueryBean
+    private IDataPollutionSubstationY dataPollutionSubstationDQuery;
+
+    @InsertBean
+    private IDataPollutionSubstationY dataPollutionSubstationDInsert;
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
+    @PostMapping("/batchInsertionSubstationY")
+    @ApiOperation("变电站(年)批量插入")
+    public HttpResult<String> batchInsertionSubstationY(@RequestBody List<DataPollutionSubstationY> dataIDTOList) {
+        String methodDescribe = getMethodDescribe("batchInsertionSubstationY");
+        dataPollutionSubstationDInsert.batchInsertion(dataIDTOList);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+    }
+
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/getRawDataSubstationY")
+    @ApiOperation("获取变电站(年)原始数据")
+    public HttpResult<List<DataPollutionSubstationY>> getRawDataSubstationY(@RequestBody LineCountEvaluateParam lineParam) {
+        String methodDescribe = getMethodDescribe("getRawDataSubstationY");
+        List<DataPollutionSubstationY> rawData = dataPollutionSubstationDInsert.getRawData(lineParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, rawData, methodDescribe);
+    }
+
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/DataVController.java

@@ -153,5 +153,13 @@ public class DataVController extends BaseController {
         return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, data, methodDescribe);
     }
 
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/getDataV")
+    @ApiOperation("获取原始数据")
+    public HttpResult<List<DataVDto>> getDataV(LineCountEvaluateParam lineParam) {
+        String methodDescribe = getMethodDescribe("getMeasurementCount");
+        List<DataVDto> dataV = dataVQuery.getDataV(lineParam);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, dataV, methodDescribe);
+    }
 
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/IDataPollution.java

@@ -1,6 +1,7 @@
 package com.njcn.dataProcess.service;
 
 import com.github.jeffreyning.mybatisplus.service.IMppService;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
 import com.njcn.dataProcess.pojo.dto.DataPollutionD;
 import com.njcn.dataProcess.pojo.po.RMpPollutionD;
 
@@ -20,4 +21,9 @@ public interface IDataPollution extends IMppService<RMpPollutionD> {
      */
     void batchInsertion(List<DataPollutionD> pollutionList);
 
+    /**
+     * 获取原始数据
+     * @param lineParam
+     */
+    List<DataPollutionD> getRawData(LineCountEvaluateParam lineParam);
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/IDataPollutionOrgD.java

@@ -1,8 +1,12 @@
 package com.njcn.dataProcess.service;
 
 import com.github.jeffreyning.mybatisplus.service.IMppService;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgD;
 import com.njcn.dataProcess.pojo.po.RStatPollutionOrgD;
 
+import java.util.List;
+
 /**
  * @Description:
  * @Author: wr
@@ -10,5 +14,15 @@ import com.njcn.dataProcess.pojo.po.RStatPollutionOrgD;
  */
 public interface IDataPollutionOrgD extends IMppService<RStatPollutionOrgD> {
 
+    /**
+     * 批量插入数据
+     * @param pollutionList
+     */
+    void batchInsertion(List<DataPollutionOrgD> pollutionList);
 
+    /**
+     * 获取原始数据
+     * @param lineParam
+     */
+    List<DataPollutionOrgD> getRawData(LineCountEvaluateParam lineParam);
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/IDataPollutionOrgM.java

@@ -1,8 +1,12 @@
 package com.njcn.dataProcess.service;
 
 import com.github.jeffreyning.mybatisplus.service.IMppService;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgM;
 import com.njcn.dataProcess.pojo.po.RStatPollutionOrgM;
 
+import java.util.List;
+
 /**
  * @Description:
  * @Author: wr
@@ -10,5 +14,15 @@ import com.njcn.dataProcess.pojo.po.RStatPollutionOrgM;
  */
 public interface IDataPollutionOrgM extends IMppService<RStatPollutionOrgM> {
 
+    /**
+     * 批量插入数据
+     * @param pollutionList
+     */
+    void batchInsertion(List<DataPollutionOrgM> pollutionList);
 
+    /**
+     * 获取原始数据
+     * @param lineParam
+     */
+    List<DataPollutionOrgM> getRawData(LineCountEvaluateParam lineParam);
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/IDataPollutionOrgQ.java

@@ -1,8 +1,12 @@
 package com.njcn.dataProcess.service;
 
 import com.github.jeffreyning.mybatisplus.service.IMppService;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgQ;
 import com.njcn.dataProcess.pojo.po.RStatPollutionOrgQ;
 
+import java.util.List;
+
 /**
  * @author hongawen
  * @version 1.0
@@ -10,5 +14,15 @@ import com.njcn.dataProcess.pojo.po.RStatPollutionOrgQ;
  */
 public interface IDataPollutionOrgQ extends IMppService<RStatPollutionOrgQ> {
 
+    /**
+     * 批量插入数据
+     * @param pollutionList
+     */
+    void batchInsertion(List<DataPollutionOrgQ> pollutionList);
 
+    /**
+     * 获取原始数据
+     * @param lineParam
+     */
+    List<DataPollutionOrgQ> getRawData(LineCountEvaluateParam lineParam);
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/IDataPollutionOrgY.java

@@ -1,8 +1,12 @@
 package com.njcn.dataProcess.service;
 
 import com.github.jeffreyning.mybatisplus.service.IMppService;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgY;
 import com.njcn.dataProcess.pojo.po.RStatPollutionOrgY;
 
+import java.util.List;
+
 /**
  * @author hongawen
  * @version 1.0
@@ -10,5 +14,15 @@ import com.njcn.dataProcess.pojo.po.RStatPollutionOrgY;
  */
 public interface IDataPollutionOrgY extends IMppService<RStatPollutionOrgY> {
 
+    /**
+     * 批量插入数据
+     * @param pollutionList
+     */
+    void batchInsertion(List<DataPollutionOrgY> pollutionList);
 
+    /**
+     * 获取原始数据
+     * @param lineParam
+     */
+    List<DataPollutionOrgY> getRawData(LineCountEvaluateParam lineParam);
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/IDataPollutionSubstationD.java

@@ -1,8 +1,12 @@
 package com.njcn.dataProcess.service;
 
 import com.github.jeffreyning.mybatisplus.service.IMppService;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationD;
 import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationD;
 
+import java.util.List;
+
 /**
  * @Description:
  * @Author: wr
@@ -10,5 +14,15 @@ import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationD;
  */
 public interface IDataPollutionSubstationD extends IMppService<RStatPollutionSubstationD> {
 
+    /**
+     * 批量插入数据
+     * @param pollutionList
+     */
+    void batchInsertion(List<DataPollutionSubstationD> pollutionList);
 
+    /**
+     * 获取原始数据
+     * @param lineParam
+     */
+    List<DataPollutionSubstationD> getRawData(LineCountEvaluateParam lineParam);
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/IDataPollutionSubstationM.java

@@ -1,14 +1,28 @@
 package com.njcn.dataProcess.service;
 
 import com.github.jeffreyning.mybatisplus.service.IMppService;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationM;
 import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationM;
 
+import java.util.List;
+
 /**
  * @Description:
  * @Author: wr
  * @Date: 2025/3/19 14:41
  */
 public interface IDataPollutionSubstationM extends IMppService<RStatPollutionSubstationM> {
+    /**
+     * 批量插入数据
+     * @param pollutionList
+     */
+    void batchInsertion(List<DataPollutionSubstationM> pollutionList);
 
+    /**
+     * 获取原始数据
+     * @param lineParam
+     */
+    List<DataPollutionSubstationM> getRawData(LineCountEvaluateParam lineParam);
 
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/IDataPollutionSubstationQ.java

@@ -1,8 +1,12 @@
 package com.njcn.dataProcess.service;
 
 import com.github.jeffreyning.mybatisplus.service.IMppService;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationQ;
 import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationQ;
 
+import java.util.List;
+
 /**
  * @Description:
  * @Author: wr
@@ -10,5 +14,15 @@ import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationQ;
  */
 public interface IDataPollutionSubstationQ extends IMppService<RStatPollutionSubstationQ> {
 
+    /**
+     * 批量插入数据
+     * @param pollutionList
+     */
+    void batchInsertion(List<DataPollutionSubstationQ> pollutionList);
 
+    /**
+     * 获取原始数据
+     * @param lineParam
+     */
+    List<DataPollutionSubstationQ> getRawData(LineCountEvaluateParam lineParam);
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/IDataPollutionSubstationY.java

@@ -1,14 +1,28 @@
 package com.njcn.dataProcess.service;
 
 import com.github.jeffreyning.mybatisplus.service.IMppService;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationY;
 import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationY;
 
+import java.util.List;
+
 /**
  * @Description:
  * @Author: wr
  * @Date: 2025/3/19 14:41
  */
 public interface IDataPollutionSubstationY extends IMppService<RStatPollutionSubstationY> {
+    /**
+     * 批量插入数据
+     * @param pollutionList
+     */
+    void batchInsertion(List<DataPollutionSubstationY> pollutionList);
 
+    /**
+     * 获取原始数据
+     * @param lineParam
+     */
+    List<DataPollutionSubstationY> getRawData(LineCountEvaluateParam lineParam);
 
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/IDataV.java

@@ -71,6 +71,12 @@ public interface IDataV extends IMppService<RStatDataVD> {
 
     List<MeasurementCountDTO> getMeasurementCount(List<String> lineIndex, String startTime, String endTime);
 
-
+    /**
+     * 获取原始数据
+     * @param lineParam
+     * @return: java.util.List<com.njcn.dataProcess.pojo.dto.DataVDto>
+     * @Author: wr
+     * @Date: 2025/3/20 13:42
+     */
     List<DataVDto> getDataV(LineCountEvaluateParam lineParam);
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/influxdb/InfluxdbDataFlickerImpl.java

@@ -67,7 +67,7 @@ public class InfluxdbDataFlickerImpl extends MppServiceImpl<RStatDataFlickerRela
     @Override
     public List<DataFlickerDto> getRawData(LineCountEvaluateParam lineParam) {
         List<DataFlickerDto> result = new ArrayList<>();
-        List<DataFlicker> list = getMinuteData(lineParam.getLineId(), lineParam.getStartTime(), lineParam.getEndTime(), lineParam.getAbnormalTime());
+        List<DataFlicker> list = getMinuteData(lineParam);
         list.forEach(item -> {
             DataFlickerDto dto = new DataFlickerDto();
             BeanUtils.copyProperties(item, dto);
@@ -80,7 +80,7 @@ public class InfluxdbDataFlickerImpl extends MppServiceImpl<RStatDataFlickerRela
     @Override
     public List<CommonMinuteDto> getBaseData(LineCountEvaluateParam lineParam) {
         List<CommonMinuteDto> result = new ArrayList<>();
-        List<DataFlicker> dataIList = getMinuteData(lineParam.getLineId(), lineParam.getStartTime(), lineParam.getEndTime(), lineParam.getAbnormalTime());
+        List<DataFlicker> dataIList = getMinuteData(lineParam);
         if (CollectionUtil.isNotEmpty(dataIList)) {
             String time = TimeUtils.StringTimeToString(lineParam.getStartTime());
             //以监测点分组
@@ -128,8 +128,7 @@ public class InfluxdbDataFlickerImpl extends MppServiceImpl<RStatDataFlickerRela
     @Override
     public Integer getColumnNameCountRawData(LineCountEvaluateParam lineParam) {
         InfluxQueryWrapper influxQueryWrapper = new InfluxQueryWrapper(DataFlicker.class);
-        influxQueryWrapper
+        influxQueryWrapper.count(lineParam.getColumnName())
-                .count(lineParam.getColumnName())
                 .regular(DataFlicker::getLineId, lineParam.getLineId())
                 .groupBy("time(1m) fill(none)")
                 .eq(DataFlicker::getQualityFlag, "0")
@@ -144,33 +143,17 @@ public class InfluxdbDataFlickerImpl extends MppServiceImpl<RStatDataFlickerRela
         if (ObjectUtil.isNotEmpty(lineParam.getLt())) {
             influxQueryWrapper.lt(lineParam.getColumnName(), Double.parseDouble(lineParam.getLt()));
         }
-        List<DataFlicker> dataFlickers = dataFlickerMapper.selectByQueryWrapper(influxQueryWrapper);
+        List<DataFlicker> result = new ArrayList<>();
-        return dataFlickers.size();
+        quality(result, influxQueryWrapper, lineParam);
+        return result.size();
     }
 
-    /**
+    private void quality(List<DataFlicker> result, InfluxQueryWrapper influxQueryWrapper, LineCountEvaluateParam lineParam) {
-     * 按监测点集合、时间条件获取分钟数据
+
-     * timeMap参数来判断是否进行数据处理 timeMap为空则不进行数据处理
-     * 需要进行剔除异常数据时,这里会有三种情况判断
-     * 1.无异常数据，则直接返回集合；
-     * 2.异常数据和无异常数据参杂，剔除异常数据，只计算正常数据；
-     * 3.全是异常数据，则使用异常数据进行计算，但是日表中需要标记出来，此数据有异常
-     */
-    public List<DataFlicker> getMinuteData(List<String> lineList, String startTime, String endTime, Map<String, List<String>> timeMap) {
-        List<DataFlicker> result = new ArrayList<>();
-        InfluxQueryWrapper influxQueryWrapper = new InfluxQueryWrapper(DataFlicker.class);
-        influxQueryWrapper.regular(DataFlicker::getLineId, lineList)
-                .select(DataFlicker::getLineId)
-                .select(DataFlicker::getPhasicType)
-                .select(DataFlicker::getFluc)
-                .select(DataFlicker::getPst)
-                .select(DataFlicker::getPlt)
-                .select(DataFlicker::getQualityFlag)
-                .between(DataFlicker::getTime, startTime, endTime)
-                .eq(DataFlicker::getQualityFlag, "0");
         List<DataFlicker> list = dataFlickerMapper.selectByQueryWrapper(influxQueryWrapper);
         Map<String, List<DataFlicker>> lineMap = list.stream().collect(Collectors.groupingBy(DataFlicker::getLineId));
         //有异常数据
+        Map<String, List<String>> timeMap = lineParam.getAbnormalTime();
         if (CollectionUtil.isNotEmpty(timeMap)) {
             lineMap.forEach((k, v) -> {
                 List<String> timeList = timeMap.get(k);
@@ -197,6 +180,29 @@ public class InfluxdbDataFlickerImpl extends MppServiceImpl<RStatDataFlickerRela
         else {
             result.addAll(list);
         }
+    }
+
+    /**
+     * 按监测点集合、时间条件获取分钟数据
+     * timeMap参数来判断是否进行数据处理 timeMap为空则不进行数据处理
+     * 需要进行剔除异常数据时,这里会有三种情况判断
+     * 1.无异常数据，则直接返回集合；
+     * 2.异常数据和无异常数据参杂，剔除异常数据，只计算正常数据；
+     * 3.全是异常数据，则使用异常数据进行计算，但是日表中需要标记出来，此数据有异常
+     */
+    public List<DataFlicker> getMinuteData(LineCountEvaluateParam lineParam) {
+        List<DataFlicker> result = new ArrayList<>();
+        InfluxQueryWrapper influxQueryWrapper = new InfluxQueryWrapper(DataFlicker.class);
+        influxQueryWrapper.regular(DataFlicker::getLineId, lineParam.getLineId())
+                .select(DataFlicker::getLineId)
+                .select(DataFlicker::getPhasicType)
+                .select(DataFlicker::getFluc)
+                .select(DataFlicker::getPst)
+                .select(DataFlicker::getPlt)
+                .select(DataFlicker::getQualityFlag)
+                .between(DataFlicker::getTime, lineParam.getStartTime(), lineParam.getEndTime())
+                .eq(DataFlicker::getQualityFlag, "0");
+        quality(result, influxQueryWrapper, lineParam);
         return result;
     }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/influxdb/InfluxdbDataPollutionImpl.java

@@ -2,12 +2,15 @@ package com.njcn.dataProcess.service.impl.influxdb;
 
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RMpPollutionDMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataLimitRateDto;
 import com.njcn.dataProcess.pojo.dto.DataPollutionD;
 import com.njcn.dataProcess.pojo.po.RMpPollutionD;
 import com.njcn.dataProcess.service.IDataPollution;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
+import java.util.Collections;
 import java.util.List;
 
 
@@ -25,4 +28,9 @@ public class InfluxdbDataPollutionImpl  extends MppServiceImpl<RMpPollutionDMapp
     public void batchInsertion(List<DataPollutionD> pollutionList) {
 
     }
+
+    @Override
+    public List<DataPollutionD> getRawData(LineCountEvaluateParam lineParam) {
+        return Collections.emptyList();
+    }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/influxdb/InfluxdbDataPollutionOrgDImpl.java

@@ -2,11 +2,15 @@ package com.njcn.dataProcess.service.impl.influxdb;
 
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionOrgDMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgD;
 import com.njcn.dataProcess.pojo.po.RStatPollutionOrgD;
 import com.njcn.dataProcess.service.IDataPollutionOrgD;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
+import java.util.Collections;
+import java.util.List;
 
 
 /**
@@ -19,5 +23,13 @@ import org.springframework.stereotype.Service;
 public class InfluxdbDataPollutionOrgDImpl extends MppServiceImpl<RStatPollutionOrgDMapper, RStatPollutionOrgD> implements IDataPollutionOrgD {
 
 
+    @Override
+    public void batchInsertion(List<DataPollutionOrgD> pollutionList) {
 
     }
+
+    @Override
+    public List<DataPollutionOrgD> getRawData(LineCountEvaluateParam lineParam) {
+        return Collections.emptyList();
+    }
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/influxdb/InfluxdbDataPollutionOrgMImpl.java

@@ -2,11 +2,15 @@ package com.njcn.dataProcess.service.impl.influxdb;
 
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionOrgMMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgM;
 import com.njcn.dataProcess.pojo.po.RStatPollutionOrgM;
 import com.njcn.dataProcess.service.IDataPollutionOrgM;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
+import java.util.Collections;
+import java.util.List;
 
 
 /**
@@ -19,5 +23,13 @@ import org.springframework.stereotype.Service;
 public class InfluxdbDataPollutionOrgMImpl extends MppServiceImpl<RStatPollutionOrgMMapper, RStatPollutionOrgM> implements IDataPollutionOrgM {
 
 
+    @Override
+    public void batchInsertion(List<DataPollutionOrgM> pollutionList) {
 
     }
+
+    @Override
+    public List<DataPollutionOrgM> getRawData(LineCountEvaluateParam lineParam) {
+        return Collections.emptyList();
+    }
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/influxdb/InfluxdbDataPollutionOrgQImpl.java

@@ -2,11 +2,15 @@ package com.njcn.dataProcess.service.impl.influxdb;
 
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionOrgQMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgQ;
 import com.njcn.dataProcess.pojo.po.RStatPollutionOrgQ;
 import com.njcn.dataProcess.service.IDataPollutionOrgQ;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
+import java.util.Collections;
+import java.util.List;
 
 
 /**
@@ -19,5 +23,13 @@ import org.springframework.stereotype.Service;
 public class InfluxdbDataPollutionOrgQImpl extends MppServiceImpl<RStatPollutionOrgQMapper, RStatPollutionOrgQ> implements IDataPollutionOrgQ {
 
 
+    @Override
+    public void batchInsertion(List<DataPollutionOrgQ> pollutionList) {
 
     }
+
+    @Override
+    public List<DataPollutionOrgQ> getRawData(LineCountEvaluateParam lineParam) {
+        return Collections.emptyList();
+    }
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/influxdb/InfluxdbDataPollutionOrgYImpl.java

@@ -2,11 +2,15 @@ package com.njcn.dataProcess.service.impl.influxdb;
 
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionOrgYMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgY;
 import com.njcn.dataProcess.pojo.po.RStatPollutionOrgY;
 import com.njcn.dataProcess.service.IDataPollutionOrgY;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
+import java.util.Collections;
+import java.util.List;
 
 
 /**
@@ -19,5 +23,13 @@ import org.springframework.stereotype.Service;
 public class InfluxdbDataPollutionOrgYImpl extends MppServiceImpl<RStatPollutionOrgYMapper, RStatPollutionOrgY> implements IDataPollutionOrgY {
 
 
+    @Override
+    public void batchInsertion(List<DataPollutionOrgY> pollutionList) {
 
     }
+
+    @Override
+    public List<DataPollutionOrgY> getRawData(LineCountEvaluateParam lineParam) {
+        return Collections.emptyList();
+    }
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/influxdb/InfluxdbDataPollutionSubstationDImpl.java

@@ -2,11 +2,16 @@ package com.njcn.dataProcess.service.impl.influxdb;
 
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionSubstationDMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationD;
 import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationD;
 import com.njcn.dataProcess.service.IDataPollutionSubstationD;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
+import java.util.Collections;
+import java.util.List;
+
 
 /**
  * @Description:
@@ -18,5 +23,13 @@ import org.springframework.stereotype.Service;
 public class InfluxdbDataPollutionSubstationDImpl extends MppServiceImpl<RStatPollutionSubstationDMapper, RStatPollutionSubstationD> implements IDataPollutionSubstationD {
 
 
+    @Override
+    public void batchInsertion(List<DataPollutionSubstationD> pollutionList) {
 
     }
+
+    @Override
+    public List<DataPollutionSubstationD> getRawData(LineCountEvaluateParam lineParam) {
+        return Collections.emptyList();
+    }
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/influxdb/InfluxdbDataPollutionSubstationMImpl.java

@@ -2,11 +2,16 @@ package com.njcn.dataProcess.service.impl.influxdb;
 
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionSubstationMMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationM;
 import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationM;
 import com.njcn.dataProcess.service.IDataPollutionSubstationM;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
+import java.util.Collections;
+import java.util.List;
+
 
 /**
  * @Description:
@@ -18,5 +23,13 @@ import org.springframework.stereotype.Service;
 public class InfluxdbDataPollutionSubstationMImpl extends MppServiceImpl<RStatPollutionSubstationMMapper, RStatPollutionSubstationM> implements IDataPollutionSubstationM {
 
 
+    @Override
+    public void batchInsertion(List<DataPollutionSubstationM> pollutionList) {
 
     }
+
+    @Override
+    public List<DataPollutionSubstationM> getRawData(LineCountEvaluateParam lineParam) {
+        return Collections.emptyList();
+    }
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/influxdb/InfluxdbDataPollutionSubstationQImpl.java

@@ -2,11 +2,16 @@ package com.njcn.dataProcess.service.impl.influxdb;
 
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionSubstationQMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationQ;
 import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationQ;
 import com.njcn.dataProcess.service.IDataPollutionSubstationQ;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
+import java.util.Collections;
+import java.util.List;
+
 
 /**
  * @Description:
@@ -18,5 +23,13 @@ import org.springframework.stereotype.Service;
 public class InfluxdbDataPollutionSubstationQImpl extends MppServiceImpl<RStatPollutionSubstationQMapper, RStatPollutionSubstationQ> implements IDataPollutionSubstationQ {
 
 
+    @Override
+    public void batchInsertion(List<DataPollutionSubstationQ> pollutionList) {
 
     }
+
+    @Override
+    public List<DataPollutionSubstationQ> getRawData(LineCountEvaluateParam lineParam) {
+        return Collections.emptyList();
+    }
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/influxdb/InfluxdbDataPollutionSubstationYImpl.java

@@ -2,11 +2,16 @@ package com.njcn.dataProcess.service.impl.influxdb;
 
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionSubstationYMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationY;
 import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationY;
 import com.njcn.dataProcess.service.IDataPollutionSubstationY;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
+import java.util.Collections;
+import java.util.List;
+
 
 /**
  * @Description:
@@ -18,5 +23,13 @@ import org.springframework.stereotype.Service;
 public class InfluxdbDataPollutionSubstationYImpl extends MppServiceImpl<RStatPollutionSubstationYMapper, RStatPollutionSubstationY> implements IDataPollutionSubstationY {
 
 
+    @Override
+    public void batchInsertion(List<DataPollutionSubstationY> pollutionList) {
 
     }
+
+    @Override
+    public List<DataPollutionSubstationY> getRawData(LineCountEvaluateParam lineParam) {
+        return Collections.emptyList();
+    }
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/influxdb/InfluxdbDataVImpl.java

@@ -15,6 +15,7 @@ import com.njcn.dataProcess.dto.DataVFiveItemDTO;
 import com.njcn.dataProcess.dto.LineDataVFiveItemDTO;
 import com.njcn.dataProcess.dto.MeasurementCountDTO;
 import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.po.influx.DataFlicker;
 import com.njcn.dataProcess.po.influx.DataV;
 import com.njcn.dataProcess.pojo.dto.CommonMinuteDto;
 import com.njcn.dataProcess.pojo.dto.DataVCvtDto;
@@ -81,18 +82,8 @@ public class InfluxdbDataVImpl extends MppServiceImpl<RStatDataVRelationMapper,
                         .eq(DataV::getPhasicType, PhaseType.PHASE_A)
                         .or(DataV::getValueType, ListUtil.of(InfluxDBTableConstant.MAX, InfluxDBTableConstant.MIN));
                 List<LineDataVFiveItemDTO> lineDataVFiveItemDTOSByA = dataVMapper.queryDataValue(dataVQueryWrapper);
-
-                System.out.println(123);
-                System.out.println(123);
-                System.out.println(123);
-                System.out.println(123);
             }
-
-
         }
-
-
-        System.out.println("InfluxdbDataVImpl");
         return result;
     }
 
@@ -122,9 +113,8 @@ public class InfluxdbDataVImpl extends MppServiceImpl<RStatDataVRelationMapper,
         influxQueryWrapper.eq(DataV::getLineId, lineId).between(DataV::getTime, startTime, endTime);
 
         List<DataV> dataVS = dataVMapper.selectByQueryWrapper(influxQueryWrapper);
-        List<LocalDateTime> result = dataVS.stream().map(temp -> {
+        List<LocalDateTime> result = dataVS.stream().map(temp -> LocalDateTime.ofInstant(temp.getTime(), ZoneId.systemDefault()))
-            return LocalDateTime.ofInstant(temp.getTime(), ZoneId.systemDefault());
+                .distinct().collect(Collectors.toList());
-        }).distinct().collect(Collectors.toList());
         return result;
     }
 
@@ -191,8 +181,9 @@ public class InfluxdbDataVImpl extends MppServiceImpl<RStatDataVRelationMapper,
         if (ObjectUtil.isNotEmpty(lineParam.getLt())) {
             influxQueryWrapper.lt(lineParam.getColumnName(), Double.parseDouble(lineParam.getLt()));
         }
-        List<DataV> dataVS = dataVMapper.selectByQueryWrapper(influxQueryWrapper);
+        List<DataV> result=new ArrayList<>();
-        return dataVS.size();
+        quality(result, influxQueryWrapper,lineParam);
+        return result.size();
     }
 
     @Override
@@ -397,13 +388,19 @@ public class InfluxdbDataVImpl extends MppServiceImpl<RStatDataVRelationMapper,
         if (CollUtil.isNotEmpty(lineParam.getPhasicType())) {
             influxQueryWrapper.regular(DataV::getPhasicType, lineParam.getPhasicType());
         }
+        quality(result, influxQueryWrapper,lineParam);
+        return result;
+    }
+
+    private void quality(List<DataV> result,InfluxQueryWrapper influxQueryWrapper, LineCountEvaluateParam lineParam) {
         List<DataV> list = dataVMapper.selectByQueryWrapper(influxQueryWrapper);
         Map<String, List<DataV>> lineMap = list.stream().collect(Collectors.groupingBy(DataV::getLineId));
         //有异常数据
-        if (CollectionUtil.isNotEmpty(lineParam.getAbnormalTime())) {
+        Map<String, List<String>> timeMap = lineParam.getAbnormalTime();
+        if (CollectionUtil.isNotEmpty(timeMap)) {
             lineMap.forEach((k, v) -> {
-                List<String> timeList = lineParam.getAbnormalTime().get(k);
+                List<String> timeList = timeMap.get(k);
-                //有异常数据,是自身异常数据
+                //有异常数据,当前监测点自身的异常数据
                 if (CollectionUtil.isNotEmpty(timeList)) {
                     List<DataV> filterList = v.stream().filter(item -> !timeList.contains(DATE_TIME_FORMATTER.format(item.getTime()))).collect(Collectors.toList());
                     //1.过滤掉异常数据后还有正常数据，则用正常数据计算
@@ -426,7 +423,5 @@ public class InfluxdbDataVImpl extends MppServiceImpl<RStatDataVRelationMapper,
         else {
             result.addAll(list);
         }
-        return result;
     }
-
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataHarmRateVImpl.java

@@ -1,6 +1,7 @@
 package com.njcn.dataProcess.service.impl.relation;
 
 import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollectionUtil;
 import cn.hutool.core.date.DatePattern;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
@@ -29,6 +30,7 @@ import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 /**
@@ -116,6 +118,40 @@ public class RelationDataHarmRateVImpl extends MppServiceImpl<RStatDataHarmRateV
             dto.setTime(rStatDataHarmRateVD.getTime().format(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)));
             result.add(dto);
         }
+        return quality(result,lineParam);
+    }
+
+    private List<DataHarmDto> quality(List<DataHarmDto> list, LineCountEvaluateParam lineParam) {
+        List<DataHarmDto> result = new ArrayList<>();
+        Map<String, List<DataHarmDto>> lineMap = list.stream().collect(Collectors.groupingBy(DataHarmDto::getLineId));
+        //有异常数据
+        Map<String, List<String>> timeMap = lineParam.getAbnormalTime();
+        if (CollectionUtil.isNotEmpty(timeMap)) {
+            lineMap.forEach((k, v) -> {
+                List<String> timeList = timeMap.get(k);
+                //有异常数据,当前监测点自身的异常数据
+                if (CollectionUtil.isNotEmpty(timeList)) {
+                    List<DataHarmDto> filterList = v.stream().filter(item -> !timeList.contains(item.getTime())).collect(Collectors.toList());
+                    //1.过滤掉异常数据后还有正常数据，则用正常数据计算
+                    if (CollectionUtil.isNotEmpty(filterList)) {
+                        result.addAll(filterList);
+                    }
+                    //2.过滤掉异常数据后没有正常数据，则用所有异常数据计算，但是需要标记数据为异常的
+                    else {
+                        v.parallelStream().forEach(item -> item.setQualityFlag("1"));
+                        result.addAll(v);
+                    }
+                }
+                //没有异常数据，则使用原数据
+                else {
+                    result.addAll(v);
+                }
+            });
+        }
+        //没有异常数据，则使用原数据
+        else {
+            result.addAll(list);
+        }
         return result;
     }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataIImpl.java

@@ -1,6 +1,7 @@
 package com.njcn.dataProcess.service.impl.relation;
 
 import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollectionUtil;
 import cn.hutool.core.date.DatePattern;
 import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@@ -12,6 +13,7 @@ import com.njcn.dataProcess.dto.DataIDTO;
 import com.njcn.dataProcess.param.LineCountEvaluateParam;
 import com.njcn.dataProcess.po.relation.DataI;
 import com.njcn.dataProcess.pojo.dto.CommonMinuteDto;
+import com.njcn.dataProcess.pojo.dto.DataHarmDto;
 import com.njcn.dataProcess.pojo.dto.DataIDto;
 import com.njcn.dataProcess.pojo.po.RStatDataID;
 import com.njcn.dataProcess.service.IDataI;
@@ -24,10 +26,7 @@ import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
 import java.time.format.DateTimeFormatter;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
 import java.util.stream.Collectors;
 
 /**
@@ -117,6 +116,40 @@ public class RelationDataIImpl extends MppServiceImpl<RStatDataIRelationMapper,
             dto.setTime(rStatDataID.getTime().format(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)));
             result.add(dto);
         }
+        return quality(result,lineParam);
+    }
+
+    private List<DataIDto> quality(List<DataIDto> list, LineCountEvaluateParam lineParam) {
+        List<DataIDto> result = new ArrayList<>();
+        Map<String, List<DataIDto>> lineMap = list.stream().collect(Collectors.groupingBy(DataIDto::getLineId));
+        //有异常数据
+        Map<String, List<String>> timeMap = lineParam.getAbnormalTime();
+        if (CollectionUtil.isNotEmpty(timeMap)) {
+            lineMap.forEach((k, v) -> {
+                List<String> timeList = timeMap.get(k);
+                //有异常数据,当前监测点自身的异常数据
+                if (CollectionUtil.isNotEmpty(timeList)) {
+                    List<DataIDto> filterList = v.stream().filter(item -> !timeList.contains(item.getTime())).collect(Collectors.toList());
+                    //1.过滤掉异常数据后还有正常数据，则用正常数据计算
+                    if (CollectionUtil.isNotEmpty(filterList)) {
+                        result.addAll(filterList);
+                    }
+                    //2.过滤掉异常数据后没有正常数据，则用所有异常数据计算，但是需要标记数据为异常的
+                    else {
+                        v.parallelStream().forEach(item -> item.setQualityFlag("1"));
+                        result.addAll(v);
+                    }
+                }
+                //没有异常数据，则使用原数据
+                else {
+                    result.addAll(v);
+                }
+            });
+        }
+        //没有异常数据，则使用原数据
+        else {
+            result.addAll(list);
+        }
         return result;
     }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataPltImpl.java

@@ -1,6 +1,7 @@
 package com.njcn.dataProcess.service.impl.relation;
 
 import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollectionUtil;
 import cn.hutool.core.date.DatePattern;
 import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
@@ -12,9 +13,7 @@ import com.njcn.dataProcess.param.LineCountEvaluateParam;
 import com.njcn.dataProcess.po.relation.DataPlt;
 import com.njcn.dataProcess.pojo.dto.CommonMinuteDto;
 import com.njcn.dataProcess.pojo.dto.DataPltDto;
-import com.njcn.dataProcess.pojo.dto.DataVDto;
 import com.njcn.dataProcess.pojo.po.RStatDataPltD;
-import com.njcn.dataProcess.pojo.po.RStatDataVD;
 import com.njcn.dataProcess.service.IDataPlt;
 import com.njcn.dataProcess.util.BeanFeildUtils;
 import com.njcn.dataProcess.util.TimeUtils;
@@ -27,6 +26,7 @@ import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 /**
@@ -112,6 +112,40 @@ public class RelationDataPltImpl extends MppServiceImpl<RStatDataPltRelationMapp
             dto.setTime(rStatDataPltD.getTime().format(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)));
             result.add(dto);
         }
+        return quality(result,lineParam);
+    }
+
+    private List<DataPltDto> quality(List<DataPltDto> list, LineCountEvaluateParam lineParam) {
+        List<DataPltDto> result = new ArrayList<>();
+        Map<String, List<DataPltDto>> lineMap = list.stream().collect(Collectors.groupingBy(DataPltDto::getLineId));
+        //有异常数据
+        Map<String, List<String>> timeMap = lineParam.getAbnormalTime();
+        if (CollectionUtil.isNotEmpty(timeMap)) {
+            lineMap.forEach((k, v) -> {
+                List<String> timeList = timeMap.get(k);
+                //有异常数据,当前监测点自身的异常数据
+                if (CollectionUtil.isNotEmpty(timeList)) {
+                    List<DataPltDto> filterList = v.stream().filter(item -> !timeList.contains(item.getTime())).collect(Collectors.toList());
+                    //1.过滤掉异常数据后还有正常数据，则用正常数据计算
+                    if (CollectionUtil.isNotEmpty(filterList)) {
+                        result.addAll(filterList);
+                    }
+                    //2.过滤掉异常数据后没有正常数据，则用所有异常数据计算，但是需要标记数据为异常的
+                    else {
+                        v.parallelStream().forEach(item -> item.setQualityFlag("1"));
+                        result.addAll(v);
+                    }
+                }
+                //没有异常数据，则使用原数据
+                else {
+                    result.addAll(v);
+                }
+            });
+        }
+        //没有异常数据，则使用原数据
+        else {
+            result.addAll(list);
+        }
         return result;
     }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataPollutionImpl.java

@@ -1,10 +1,12 @@
 package com.njcn.dataProcess.service.impl.relation;
 
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RMpPollutionDMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
 import com.njcn.dataProcess.pojo.dto.DataPollutionD;
 import com.njcn.dataProcess.pojo.po.RMpPollutionD;
-import com.njcn.dataProcess.pojo.po.RStatLimitRateD;
 import com.njcn.dataProcess.service.IDataPollution;
 import lombok.RequiredArgsConstructor;
 import org.springframework.beans.BeanUtils;
@@ -34,4 +36,21 @@ public class RelationDataPollutionImpl extends MppServiceImpl<RMpPollutionDMappe
         });
         this.saveOrUpdateBatchByMultiId(result);
     }
+
+    @Override
+    public List<DataPollutionD> getRawData(LineCountEvaluateParam lineParam) {
+        List<DataPollutionD> result = new ArrayList<>();
+        LambdaQueryWrapper<RMpPollutionD> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.in(CollUtil.isNotEmpty(lineParam.getLineId()),RMpPollutionD::getLineId,lineParam.getLineId())
+                .ge(RMpPollutionD::getDataDate,lineParam.getStartTime())
+                .le(RMpPollutionD::getDataDate,lineParam.getEndTime());
+        List<RMpPollutionD> list = this.list(lambdaQueryWrapper);
+
+        list.forEach(item->{
+            DataPollutionD dto = new DataPollutionD();
+            BeanUtils.copyProperties(item,dto);
+            result.add(dto);
+        });
+        return result;
+    }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataPollutionOrgDImpl.java

@@ -1,12 +1,19 @@
 package com.njcn.dataProcess.service.impl.relation;
 
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionOrgDMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgD;
 import com.njcn.dataProcess.pojo.po.RStatPollutionOrgD;
 import com.njcn.dataProcess.service.IDataPollutionOrgD;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 
+import java.util.ArrayList;
+import java.util.List;
 
 
 /**
@@ -19,5 +26,31 @@ import org.springframework.stereotype.Service;
 public class RelationDataPollutionOrgDImpl extends MppServiceImpl<RStatPollutionOrgDMapper, RStatPollutionOrgD> implements IDataPollutionOrgD {
 
 
-
+    @Override
+    public void batchInsertion(List<DataPollutionOrgD> pollutionList) {
+        List<RStatPollutionOrgD> result = new ArrayList<>();
+        pollutionList.forEach(item->{
+            RStatPollutionOrgD limitRate = new RStatPollutionOrgD();
+            BeanUtils.copyProperties(item, limitRate);
+            result.add(limitRate);
+        });
+        this.saveOrUpdateBatchByMultiId(result);
+    }
+
+    @Override
+    public List<DataPollutionOrgD> getRawData(LineCountEvaluateParam lineParam) {
+        List<DataPollutionOrgD> result = new ArrayList<>();
+        LambdaQueryWrapper<RStatPollutionOrgD> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.in(CollUtil.isNotEmpty(lineParam.getLineId()),RStatPollutionOrgD::getOrgId,lineParam.getLineId())
+                .ge(RStatPollutionOrgD::getDataDate,lineParam.getStartTime())
+                .le(RStatPollutionOrgD::getDataDate,lineParam.getEndTime());
+        List<RStatPollutionOrgD> list = this.list(lambdaQueryWrapper);
+
+        list.forEach(item->{
+            DataPollutionOrgD dto = new DataPollutionOrgD();
+            BeanUtils.copyProperties(item,dto);
+            result.add(dto);
+        });
+        return result;
+    }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataPollutionOrgMImpl.java

@@ -1,12 +1,19 @@
 package com.njcn.dataProcess.service.impl.relation;
 
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionOrgMMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgM;
 import com.njcn.dataProcess.pojo.po.RStatPollutionOrgM;
 import com.njcn.dataProcess.service.IDataPollutionOrgM;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 
+import java.util.ArrayList;
+import java.util.List;
 
 
 /**
@@ -19,5 +26,31 @@ import org.springframework.stereotype.Service;
 public class RelationDataPollutionOrgMImpl extends MppServiceImpl<RStatPollutionOrgMMapper, RStatPollutionOrgM> implements IDataPollutionOrgM {
 
 
-
+    @Override
+    public void batchInsertion(List<DataPollutionOrgM> pollutionList) {
+        List<RStatPollutionOrgM> result = new ArrayList<>();
+        pollutionList.forEach(item->{
+            RStatPollutionOrgM limitRate = new RStatPollutionOrgM();
+            BeanUtils.copyProperties(item, limitRate);
+            result.add(limitRate);
+        });
+        this.saveOrUpdateBatchByMultiId(result);
+    }
+
+    @Override
+    public List<DataPollutionOrgM> getRawData(LineCountEvaluateParam lineParam) {
+        List<DataPollutionOrgM> result = new ArrayList<>();
+        LambdaQueryWrapper<RStatPollutionOrgM> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.in(CollUtil.isNotEmpty(lineParam.getLineId()),RStatPollutionOrgM::getOrgId,lineParam.getLineId())
+                .ge(RStatPollutionOrgM::getDataDate,lineParam.getStartTime())
+                .le(RStatPollutionOrgM::getDataDate,lineParam.getEndTime());
+        List<RStatPollutionOrgM> list = this.list(lambdaQueryWrapper);
+
+        list.forEach(item->{
+            DataPollutionOrgM dto = new DataPollutionOrgM();
+            BeanUtils.copyProperties(item,dto);
+            result.add(dto);
+        });
+        return result;
+    }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataPollutionOrgQImpl.java

@@ -1,12 +1,19 @@
 package com.njcn.dataProcess.service.impl.relation;
 
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionOrgQMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgQ;
 import com.njcn.dataProcess.pojo.po.RStatPollutionOrgQ;
 import com.njcn.dataProcess.service.IDataPollutionOrgQ;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 
+import java.util.ArrayList;
+import java.util.List;
 
 
 /**
@@ -19,5 +26,31 @@ import org.springframework.stereotype.Service;
 public class RelationDataPollutionOrgQImpl extends MppServiceImpl<RStatPollutionOrgQMapper, RStatPollutionOrgQ> implements IDataPollutionOrgQ {
 
 
-
+    @Override
+    public void batchInsertion(List<DataPollutionOrgQ> pollutionList) {
+        List<RStatPollutionOrgQ> result = new ArrayList<>();
+        pollutionList.forEach(item->{
+            RStatPollutionOrgQ limitRate = new RStatPollutionOrgQ();
+            BeanUtils.copyProperties(item, limitRate);
+            result.add(limitRate);
+        });
+        this.saveOrUpdateBatchByMultiId(result);
+    }
+
+    @Override
+    public List<DataPollutionOrgQ> getRawData(LineCountEvaluateParam lineParam) {
+        List<DataPollutionOrgQ> result = new ArrayList<>();
+        LambdaQueryWrapper<RStatPollutionOrgQ> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.in(CollUtil.isNotEmpty(lineParam.getLineId()),RStatPollutionOrgQ::getOrgId,lineParam.getLineId())
+                .ge(RStatPollutionOrgQ::getDataDate,lineParam.getStartTime())
+                .le(RStatPollutionOrgQ::getDataDate,lineParam.getEndTime());
+        List<RStatPollutionOrgQ> list = this.list(lambdaQueryWrapper);
+
+        list.forEach(item->{
+            DataPollutionOrgQ dto = new DataPollutionOrgQ();
+            BeanUtils.copyProperties(item,dto);
+            result.add(dto);
+        });
+        return result;
+    }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataPollutionOrgYImpl.java

@@ -1,12 +1,19 @@
 package com.njcn.dataProcess.service.impl.relation;
 
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionOrgYMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionOrgY;
 import com.njcn.dataProcess.pojo.po.RStatPollutionOrgY;
 import com.njcn.dataProcess.service.IDataPollutionOrgY;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 
+import java.util.ArrayList;
+import java.util.List;
 
 
 /**
@@ -19,5 +26,31 @@ import org.springframework.stereotype.Service;
 public class RelationDataPollutionOrgYImpl extends MppServiceImpl<RStatPollutionOrgYMapper, RStatPollutionOrgY> implements IDataPollutionOrgY {
 
 
-
+    @Override
+    public void batchInsertion(List<DataPollutionOrgY> pollutionList) {
+        List<RStatPollutionOrgY> result = new ArrayList<>();
+        pollutionList.forEach(item->{
+            RStatPollutionOrgY limitRate = new RStatPollutionOrgY();
+            BeanUtils.copyProperties(item, limitRate);
+            result.add(limitRate);
+        });
+        this.saveOrUpdateBatchByMultiId(result);
+    }
+
+    @Override
+    public List<DataPollutionOrgY> getRawData(LineCountEvaluateParam lineParam) {
+        List<DataPollutionOrgY> result = new ArrayList<>();
+        LambdaQueryWrapper<RStatPollutionOrgY> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.in(CollUtil.isNotEmpty(lineParam.getLineId()),RStatPollutionOrgY::getOrgId,lineParam.getLineId())
+                .ge(RStatPollutionOrgY::getDataDate,lineParam.getStartTime())
+                .le(RStatPollutionOrgY::getDataDate,lineParam.getEndTime());
+        List<RStatPollutionOrgY> list = this.list(lambdaQueryWrapper);
+
+        list.forEach(item->{
+            DataPollutionOrgY dto = new DataPollutionOrgY();
+            BeanUtils.copyProperties(item,dto);
+            result.add(dto);
+        });
+        return result;
+    }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataPollutionSubstationDImpl.java

@@ -1,12 +1,20 @@
 package com.njcn.dataProcess.service.impl.relation;
 
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionSubstationDMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationD;
 import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationD;
 import com.njcn.dataProcess.service.IDataPollutionSubstationD;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 
+import java.util.ArrayList;
+import java.util.List;
+
 
 /**
  * @Description:
@@ -18,5 +26,31 @@ import org.springframework.stereotype.Service;
 public class RelationDataPollutionSubstationDImpl extends MppServiceImpl<RStatPollutionSubstationDMapper, RStatPollutionSubstationD> implements IDataPollutionSubstationD {
 
 
-
+    @Override
+    public void batchInsertion(List<DataPollutionSubstationD> pollutionList) {
+        List<RStatPollutionSubstationD> result = new ArrayList<>();
+        pollutionList.forEach(item->{
+            RStatPollutionSubstationD limitRate = new RStatPollutionSubstationD();
+            BeanUtils.copyProperties(item, limitRate);
+            result.add(limitRate);
+        });
+        this.saveOrUpdateBatchByMultiId(result);
+    }
+
+    @Override
+    public List<DataPollutionSubstationD> getRawData(LineCountEvaluateParam lineParam) {
+        List<DataPollutionSubstationD> result = new ArrayList<>();
+        LambdaQueryWrapper<RStatPollutionSubstationD> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.in(CollUtil.isNotEmpty(lineParam.getLineId()),RStatPollutionSubstationD::getSubstationId,lineParam.getLineId())
+                .ge(RStatPollutionSubstationD::getDataDate,lineParam.getStartTime())
+                .le(RStatPollutionSubstationD::getDataDate,lineParam.getEndTime());
+        List<RStatPollutionSubstationD> list = this.list(lambdaQueryWrapper);
+
+        list.forEach(item->{
+            DataPollutionSubstationD dto = new DataPollutionSubstationD();
+            BeanUtils.copyProperties(item,dto);
+            result.add(dto);
+        });
+        return result;
+    }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataPollutionSubstationMImpl.java

@@ -1,12 +1,20 @@
 package com.njcn.dataProcess.service.impl.relation;
 
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionSubstationMMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationM;
 import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationM;
 import com.njcn.dataProcess.service.IDataPollutionSubstationM;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 
+import java.util.ArrayList;
+import java.util.List;
+
 
 /**
  * @Description:
@@ -18,5 +26,31 @@ import org.springframework.stereotype.Service;
 public class RelationDataPollutionSubstationMImpl extends MppServiceImpl<RStatPollutionSubstationMMapper, RStatPollutionSubstationM> implements IDataPollutionSubstationM {
 
 
-
+    @Override
+    public void batchInsertion(List<DataPollutionSubstationM> pollutionList) {
+        List<RStatPollutionSubstationM> result = new ArrayList<>();
+        pollutionList.forEach(item->{
+            RStatPollutionSubstationM limitRate = new RStatPollutionSubstationM();
+            BeanUtils.copyProperties(item, limitRate);
+            result.add(limitRate);
+        });
+        this.saveOrUpdateBatchByMultiId(result);
+    }
+
+    @Override
+    public List<DataPollutionSubstationM> getRawData(LineCountEvaluateParam lineParam) {
+        List<DataPollutionSubstationM> result = new ArrayList<>();
+        LambdaQueryWrapper<RStatPollutionSubstationM> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.in(CollUtil.isNotEmpty(lineParam.getLineId()),RStatPollutionSubstationM::getSubstationId,lineParam.getLineId())
+                .ge(RStatPollutionSubstationM::getDataDate,lineParam.getStartTime())
+                .le(RStatPollutionSubstationM::getDataDate,lineParam.getEndTime());
+        List<RStatPollutionSubstationM> list = this.list(lambdaQueryWrapper);
+
+        list.forEach(item->{
+            DataPollutionSubstationM dto = new DataPollutionSubstationM();
+            BeanUtils.copyProperties(item,dto);
+            result.add(dto);
+        });
+        return result;
+    }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataPollutionSubstationQImpl.java

@@ -1,12 +1,20 @@
 package com.njcn.dataProcess.service.impl.relation;
 
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionSubstationQMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationQ;
 import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationQ;
 import com.njcn.dataProcess.service.IDataPollutionSubstationQ;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 
+import java.util.ArrayList;
+import java.util.List;
+
 
 /**
  * @Description:
@@ -18,5 +26,31 @@ import org.springframework.stereotype.Service;
 public class RelationDataPollutionSubstationQImpl extends MppServiceImpl<RStatPollutionSubstationQMapper, RStatPollutionSubstationQ> implements IDataPollutionSubstationQ {
 
 
-
+    @Override
+    public void batchInsertion(List<DataPollutionSubstationQ> pollutionList) {
+        List<RStatPollutionSubstationQ> result = new ArrayList<>();
+        pollutionList.forEach(item->{
+            RStatPollutionSubstationQ limitRate = new RStatPollutionSubstationQ();
+            BeanUtils.copyProperties(item, limitRate);
+            result.add(limitRate);
+        });
+        this.saveOrUpdateBatchByMultiId(result);
+    }
+
+    @Override
+    public List<DataPollutionSubstationQ> getRawData(LineCountEvaluateParam lineParam) {
+        List<DataPollutionSubstationQ> result = new ArrayList<>();
+        LambdaQueryWrapper<RStatPollutionSubstationQ> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.in(CollUtil.isNotEmpty(lineParam.getLineId()),RStatPollutionSubstationQ::getSubstationId,lineParam.getLineId())
+                .ge(RStatPollutionSubstationQ::getDataDate,lineParam.getStartTime())
+                .le(RStatPollutionSubstationQ::getDataDate,lineParam.getEndTime());
+        List<RStatPollutionSubstationQ> list = this.list(lambdaQueryWrapper);
+
+        list.forEach(item->{
+            DataPollutionSubstationQ dto = new DataPollutionSubstationQ();
+            BeanUtils.copyProperties(item,dto);
+            result.add(dto);
+        });
+        return result;
+    }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataPollutionSubstationYImpl.java

@@ -1,12 +1,20 @@
 package com.njcn.dataProcess.service.impl.relation;
 
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
 import com.njcn.dataProcess.dao.relation.mapper.RStatPollutionSubstationYMapper;
+import com.njcn.dataProcess.param.LineCountEvaluateParam;
+import com.njcn.dataProcess.pojo.dto.DataPollutionSubstationY;
 import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationY;
 import com.njcn.dataProcess.service.IDataPollutionSubstationY;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 
+import java.util.ArrayList;
+import java.util.List;
+
 
 /**
  * @Description:
@@ -18,5 +26,31 @@ import org.springframework.stereotype.Service;
 public class RelationDataPollutionSubstationYImpl extends MppServiceImpl<RStatPollutionSubstationYMapper, RStatPollutionSubstationY> implements IDataPollutionSubstationY {
 
 
-
+    @Override
+    public void batchInsertion(List<DataPollutionSubstationY> pollutionList) {
+        List<RStatPollutionSubstationY> result = new ArrayList<>();
+        pollutionList.forEach(item->{
+            RStatPollutionSubstationY limitRate = new RStatPollutionSubstationY();
+            BeanUtils.copyProperties(item, limitRate);
+            result.add(limitRate);
+        });
+        this.saveOrUpdateBatchByMultiId(result);
+    }
+
+    @Override
+    public List<DataPollutionSubstationY> getRawData(LineCountEvaluateParam lineParam) {
+        List<DataPollutionSubstationY> result = new ArrayList<>();
+        LambdaQueryWrapper<RStatPollutionSubstationY> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+        lambdaQueryWrapper.in(CollUtil.isNotEmpty(lineParam.getLineId()),RStatPollutionSubstationY::getSubstationId,lineParam.getLineId())
+                .ge(RStatPollutionSubstationY::getDataDate,lineParam.getStartTime())
+                .le(RStatPollutionSubstationY::getDataDate,lineParam.getEndTime());
+        List<RStatPollutionSubstationY> list = this.list(lambdaQueryWrapper);
+
+        list.forEach(item->{
+            DataPollutionSubstationY dto = new DataPollutionSubstationY();
+            BeanUtils.copyProperties(item,dto);
+            result.add(dto);
+        });
+        return result;
+    }
 }

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataVImpl.java

@@ -1,14 +1,11 @@
 package com.njcn.dataProcess.service.impl.relation;
 
 import cn.hutool.core.bean.BeanUtil;
-import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.collection.CollectionUtil;
 import cn.hutool.core.date.DatePattern;
-import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.util.StrUtil;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
-import com.njcn.dataProcess.constant.InfluxDBTableConstant;
 import com.njcn.dataProcess.dao.relation.mapper.DataVRelationMapper;
 import com.njcn.dataProcess.dao.relation.mapper.RStatDataVRelationMapper;
 import com.njcn.dataProcess.dto.DataVDTO;
@@ -23,21 +20,18 @@ import com.njcn.dataProcess.pojo.po.RStatDataVD;
 import com.njcn.dataProcess.service.IDataV;
 import com.njcn.dataProcess.util.BeanFeildUtils;
 import com.njcn.dataProcess.util.TimeUtils;
-import com.njcn.influx.constant.InfluxDbSqlConstant;
-import com.njcn.influx.query.InfluxQueryWrapper;
 import lombok.RequiredArgsConstructor;
 import org.apache.commons.collections4.ListUtils;
-import org.ehcache.core.util.CollectionUtil;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
-import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.*;
 import java.util.stream.Collectors;
 
+
 /**
  * @author hongawen
  * @version 1.0
@@ -46,6 +40,7 @@ import java.util.stream.Collectors;
 @Service("RelationDataVImpl")
 @RequiredArgsConstructor
 public class RelationDataVImpl extends MppServiceImpl<RStatDataVRelationMapper, RStatDataVD> implements IDataV {
+
     @Resource
     private DataVRelationMapper dataVRelationMapper;
 
@@ -54,10 +49,6 @@ public class RelationDataVImpl extends MppServiceImpl<RStatDataVRelationMapper,
 
     @Override
     public Map<String, List<DataVFiveItemDTO>> getLineCountEvaluate(LineCountEvaluateParam lineParam) {
-
-
-
-
         return null;
     }
 
@@ -112,7 +103,6 @@ public class RelationDataVImpl extends MppServiceImpl<RStatDataVRelationMapper,
     }
 
 
-
     @Override
     public List<CommonMinuteDto> getBaseData(LineCountEvaluateParam lineParam) {
         return Collections.emptyList();
@@ -149,7 +139,7 @@ public class RelationDataVImpl extends MppServiceImpl<RStatDataVRelationMapper,
 
     @Override
     public List<DataVDto> getDataV(LineCountEvaluateParam lineParam) {
-        List<DataVDto> result = new ArrayList<>();
+        List<DataVDto> info = new ArrayList<>();
         QueryWrapper<RStatDataVD> queryWrapper = new QueryWrapper<>();
         if (StrUtil.isNotBlank(lineParam.getColumnName())) {
             queryWrapper.select(lineParam.getColumnName());
@@ -164,10 +154,42 @@ public class RelationDataVImpl extends MppServiceImpl<RStatDataVRelationMapper,
         for (RStatDataVD rStatDataVD : rStatDataVDList) {
             DataVDto dto = BeanUtil.copyProperties(rStatDataVD, DataVDto.class);
             dto.setTime(rStatDataVD.getTime().format(DateTimeFormatter.ofPattern(DatePattern.NORM_DATE_PATTERN)));
-            result.add(dto);
+            info.add(dto);
+        }
+        return quality(info,lineParam);
+    }
+
+    private List<DataVDto> quality(List<DataVDto> list, LineCountEvaluateParam lineParam) {
+        List<DataVDto> result = new ArrayList<>();
+        Map<String, List<DataVDto>> lineMap = list.stream().collect(Collectors.groupingBy(DataVDto::getLineId));
+        //有异常数据
+        Map<String, List<String>> timeMap = lineParam.getAbnormalTime();
+        if (CollectionUtil.isNotEmpty(timeMap)) {
+            lineMap.forEach((k, v) -> {
+                List<String> timeList = timeMap.get(k);
+                //有异常数据,当前监测点自身的异常数据
+                if (CollectionUtil.isNotEmpty(timeList)) {
+                    List<DataVDto> filterList = v.stream().filter(item -> !timeList.contains(item.getTime())).collect(Collectors.toList());
+                    //1.过滤掉异常数据后还有正常数据，则用正常数据计算
+                    if (CollectionUtil.isNotEmpty(filterList)) {
+                        result.addAll(filterList);
+                    }
+                    //2.过滤掉异常数据后没有正常数据，则用所有异常数据计算，但是需要标记数据为异常的
+                    else {
+                        v.parallelStream().forEach(item -> item.setQualityFlag("1"));
+                        result.addAll(v);
+                    }
+                }
+                //没有异常数据，则使用原数据
+                else {
+                    result.addAll(v);
+                }
+            });
+        }
+        //没有异常数据，则使用原数据
+        else {
+            result.addAll(list);
         }
         return result;
     }
-
-
 }