污区图算法编写

2025-03-20 16:22:20 +08:00
parent 0f54dc5199
commit db5ff43ea7
52 changed files with 1844 additions and 1223 deletions
--- a/data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/api/DataPollutionFeignClient.java
+++ b/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;
@@ -15,11 +16,56 @@ import java.util.List;
 * @version 1.0.0
 * @date 2022年01月05日 15:11
 */
-@FeignClient(value =  ServerInfo.PLATFORM_DATA_PROCESSING_BOOT, path = "/dataPollution", fallbackFactory = DataPollutionFeignClientFallbackFactory.class, contextId = "dataPollution")
+@FeignClient(value = ServerInfo.PLATFORM_DATA_PROCESSING_BOOT, path = "/dataPollution", fallbackFactory = DataPollutionFeignClientFallbackFactory.class, contextId = "dataPollution")
 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);
 }
--- a/data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/api/fallback/DataPollutionFeignClientFallbackFactory.java
+++ b/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.DataPollutionD;
-import com.njcn.dataProcess.pojo.dto.DataVCvtDto;
-import com.njcn.dataProcess.pojo.dto.DataVDto;
+import com.njcn.dataProcess.pojo.dto.*;
 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);
            }