Microservice/pqs
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

算法模块删除不必要的代码，有备份，如果存疑就联系我

Browse Source
This commit is contained in:
hongawen
2024-10-29 20:26:00 +08:00
parent 8445a08a64
commit 0fcd67bd38
143 changed files with 40 additions and 10312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/device/DeviceAbnormalFeignClient.java
View File

@@ -1,21 +0,0 @@
package com.njcn.prepare.harmonic.api.device;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.device.fallback.DeviceAbnormalFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.DeviceAbnormaStatisticsParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/deviceAbnormal",//对应controller请求类
fallbackFactory = DeviceAbnormalFeignClientFallbackFactory.class//服务降级处理类
)
public interface DeviceAbnormalFeignClient {
@PostMapping("/statistics")
HttpResult<Boolean> dailyDeviceAbnormaStatistics (@RequestBody DeviceAbnormaStatisticsParam param);
}

34
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/device/fallback/DeviceAbnormalFeignClientFallbackFactory.java
View File

@@ -1,34 +0,0 @@
package com.njcn.prepare.harmonic.api.device.fallback;
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.prepare.harmonic.api.device.DeviceAbnormalFeignClient;
import com.njcn.prepare.harmonic.pojo.param.DeviceAbnormaStatisticsParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestBody;
@Slf4j
@Component
public class DeviceAbnormalFeignClientFallbackFactory implements FallbackFactory<DeviceAbnormalFeignClient> {
@Override
public DeviceAbnormalFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new DeviceAbnormalFeignClient() {
@Override
public HttpResult<Boolean> dailyDeviceAbnormaStatistics( @RequestBody DeviceAbnormaStatisticsParam param) {
log.error("{}异常，降级处理，异常为：{}", "终端异常统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

34
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/DayDataFeignClient.java
View File

@@ -1,34 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.DayDataFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* 自定义报表
* @author qijian
* @date 2022/10/20
*/
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/daydata",//对应controller请求类
fallbackFactory = DayDataFeignClientFallbackFactory.class//服务降级处理类
)
public interface DayDataFeignClient {
/**
* 批量处理报表
* @author qijian
* @date 2022/10/19
*/
@PostMapping("/dayDataHanlder")
HttpResult<Boolean> dayDataHanlder(@RequestBody LineParam jobParam);
@PostMapping("/dataToDay")
HttpResult<Boolean> dataToDayHandler(@RequestBody LineParam jobParam);
}

26
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/DistortionRateFeignClient.java
View File

@@ -1,26 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.DistortionRateFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* 谐波畸变率
* @author xiaoyao
* @version 1.0.0
* @createTime 2022/11/4 15:58
*/
@FeignClient(
value = ServerInfo.PREPARE_BOOT,
path = "/harmonicOverLimit",
fallbackFactory = DistortionRateFeignClientFallbackFactory.class)
public interface DistortionRateFeignClient {
@PostMapping("/harmonicThdDay")
HttpResult<Boolean> harmonicThdDay(@RequestBody @Validated LineParam lineParam);
}

41
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/HarmOverLimitFeignClient.java
View File

@@ -1,41 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.annotation.OperateInfo;
import com.njcn.common.pojo.constant.OperateType;
import com.njcn.common.pojo.constant.ServerInfo;
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.prepare.harmonic.api.line.fallback.HarmOverLimitFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/harmonicOverLimit",//对应controller请求类
fallbackFactory = HarmOverLimitFeignClientFallbackFactory.class//服务降级处理类
)
public interface HarmOverLimitFeignClient {
@PostMapping("/harmonicDetailDay1")
HttpResult<Boolean> harmonicDetailDay1(@RequestBody LineParam lineParam);
@PostMapping("/harmonicDetailDay2")
HttpResult<Boolean> harmonicDetailDay2(@RequestBody LineParam lineParam);
@PostMapping("/harmonicDetailMonth1")
HttpResult<Boolean> harmonicDetailMonth1(@RequestBody @Validated LineParam lineParam);
@PostMapping("/harmonicDetailMonth2")
HttpResult<Boolean> harmonicDetailMonth2(@RequestBody @Validated LineParam lineParam);
@PostMapping("/harmonicThdDay")
HttpResult<Boolean> harmonicThdDay(@RequestBody @Validated LineParam lineParam);
}

31
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/HarmonicGeneralFeignClient.java
View File

@@ -1,31 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.DistortionRateFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* 稳态综合评估
* @author xiaoyao
* @version 1.0.0
* @createTime 2022/11/7 15:11
*/
@FeignClient(
value = ServerInfo.PREPARE_BOOT,
path = "/general",
fallbackFactory = DistortionRateFeignClientFallbackFactory.class
)
public interface HarmonicGeneralFeignClient {
@PostMapping("/generalData")
HttpResult<String> generalData(@RequestBody @Validated LineParam lineParam);
@PostMapping("/generalDataToMysql")
HttpResult<String> generalDataToMysql(@RequestBody @Validated LineParam lineParam);
}

30
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/HarmonicMetricFeignClient.java
View File

@@ -1,30 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.HarmonicMetricFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* @author xiaoyao
* @version 1.0.0
* @createTime 2022/11/7 15:12
*/
@FeignClient(
value = ServerInfo.PREPARE_BOOT,
path = "/metric",
fallbackFactory = HarmonicMetricFeignClientFallbackFactory.class
)
public interface HarmonicMetricFeignClient {
@PostMapping("/metricData")
HttpResult<String> metricData(@RequestBody @Validated LineParam lineParam);
@PostMapping("/metricDataToMysql")
HttpResult<String> metricDataToMysql(@RequestBody @Validated LineParam lineParam);
}

35
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/IntegrityFeignClient.java
View File

@@ -1,35 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.IntegrityFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* 自定义报表
* @author qijian
* @date 2022/10/20
*/
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/integrity",//对应controller请求类
fallbackFactory = IntegrityFeignClientFallbackFactory.class//服务降级处理类
)
public interface IntegrityFeignClient {
/**
* 批量处理报表
* @author qijian
* @date 2022/10/19
*/
@PostMapping("/computeDataIntegrity")
HttpResult<String> computeDataIntegrity(@RequestBody @Validated LineParam lineParam);
@PostMapping("/dataIntegrity")
HttpResult<String> dataIntegrity(@RequestBody @Validated LineParam lineParam);
}

35
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/LimitTargetFeignClient.java
View File

@@ -1,35 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.LimitTargetFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* 自定义报表
* @author qijian
* @date 2022/10/20
*/
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/limitTarget",//对应controller请求类
fallbackFactory = LimitTargetFeignClientFallbackFactory.class//服务降级处理类
)
public interface LimitTargetFeignClient {
/**
* 批量处理报表
* @author qijian
* @date 2022/10/19
*/
@PostMapping("/getLimitTargetData")
HttpResult<String> getLimitTargetData(@RequestBody @Validated LineParam lineParam);
@PostMapping("/limitTargetData")
HttpResult<String> limitTargetData(@RequestBody @Validated LineParam lineParam);
}

32
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/LimitrateFeignClient.java
View File

@@ -1,32 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.LimitrateFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* 自定义报表
* @author qijian
* @date 2022/10/20
*/
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/limitrate",//对应controller请求类
fallbackFactory = LimitrateFeignClientFallbackFactory.class//服务降级处理类
)
public interface LimitrateFeignClient {
/**
* 越限
*/
@PostMapping("/LimitRateHanlder")
HttpResult<Boolean> limitRateHanlder(@RequestBody LineParam limitRateHanlderParam );
@PostMapping("/LimitRate")
HttpResult<Boolean> limitRate(@RequestBody LineParam limitRateHanlderParam );
}

33
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/OnlineRateFeignClient.java
View File

@@ -1,33 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.OnlineRateFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* 自定义报表
* @author qijian
* @date 2022/10/20
*/
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/onlineRate",//对应controller请求类
fallbackFactory = OnlineRateFeignClientFallbackFactory.class//服务降级处理类
)
public interface OnlineRateFeignClient {
/**
* 在线率
*/
@PostMapping("/getOnlineRateData")
HttpResult<String> getOnlineRateData(@RequestBody @Validated LineParam lineParam);
@PostMapping("/onlineRateData")
HttpResult<String> onlineRateData(@RequestBody @Validated LineParam lineParam);
}

30
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/PollutionFeignClient.java
View File

@@ -1,30 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.PollutionFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* 污区数据（日,月,年）
* @author qijian
* @date 2022/10/20
*/
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/pollution",//对应controller请求类
fallbackFactory = PollutionFeignClientFallbackFactory.class//服务降级处理类
)
public interface PollutionFeignClient {
/**
* 污区
*/
@PostMapping("/processPollutionData")
HttpResult<String> processPollutionData(@RequestBody @Validated LineParam lineParam);
}

22
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/RAlarmCountFeignClient.java
View File

@@ -1,22 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.RAlarmCountFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.api.line.fallback.RStatEventFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rAlarmCount",//对应controller请求类
fallbackFactory = RAlarmCountFeignClientFallbackFactory.class//服务降级处理类
)
public interface RAlarmCountFeignClient {
@PostMapping("/rAlarmCountHandler")
HttpResult<Boolean> rAlarmCountHandler(@RequestBody OrgParam orgParam);
}

23
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/RMpDevEvaluateDetailFeignClient.java
View File

@@ -1,23 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.RMpDevEvaluateDetailFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.api.line.fallback.RStatOrgFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.DeviceParam;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rMpDevEvaluateDetail",//对应controller请求类
fallbackFactory = RMpDevEvaluateDetailFeignClientFallbackFactory.class//服务降级处理类
)
public interface RMpDevEvaluateDetailFeignClient {
@PostMapping("/handler")
HttpResult<Boolean> handler(@RequestBody DeviceParam deviceParam);
}

21
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/RStatEventFeignClient.java
View File

@@ -1,21 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.RStatEventFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rStartEvent",//对应controller请求类
fallbackFactory = RStatEventFeignClientFallbackFactory.class//服务降级处理类
)
public interface RStatEventFeignClient {
@PostMapping("/rStartEventHandler")
HttpResult<Boolean> rStartEventHandler(@RequestBody OrgParam orgParam);
}

21
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/RStatEventOrgFeignClient.java
View File

@@ -1,21 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.RStatEventOrgFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rStartEventOrg",//对应controller请求类
fallbackFactory = RStatEventOrgFeignClientFallbackFactory.class//服务降级处理类
)
public interface RStatEventOrgFeignClient {
@PostMapping("/rStartEventOrgHandler")
HttpResult<Boolean> rStartEventOrgHandler(@RequestBody OrgParam orgParam);
}

22
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/RStatOrgFeignClient.java
View File

@@ -1,22 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.RStatEventFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.api.line.fallback.RStatOrgFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rstatorg",//对应controller请求类
fallbackFactory = RStatOrgFeignClientFallbackFactory.class//服务降级处理类
)
public interface RStatOrgFeignClient {
@PostMapping("/Handler")
HttpResult<Boolean> handler(@RequestBody OrgParam orgParam);
}

21
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/RStatSubstationFeignClient.java
View File

@@ -1,21 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.RStatEventFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rStartSubstation",//对应controller请求类
fallbackFactory = RStatEventFeignClientFallbackFactory.class//服务降级处理类
)
public interface RStatSubstationFeignClient {
@PostMapping("/rStartSubstationHandler")
HttpResult<Boolean> rStartSubstationHandler(@RequestBody OrgParam orgParam);
}

28
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/TargetWarnFeignClient.java
View File

@@ -1,28 +0,0 @@
package com.njcn.prepare.harmonic.api.line;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.line.fallback.TargetWarnFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/alarmDetail",//对应controller请求类
fallbackFactory = TargetWarnFeignClientFallbackFactory.class//服务降级处理类
)
public interface TargetWarnFeignClient {
@PostMapping("/targetDiff")
HttpResult<Boolean> targetDiff(@RequestBody @Validated LineParam lineParam);
@PostMapping("/alarmDay")
HttpResult<Boolean> alarmDay(@RequestBody @Validated LineParam lineParam);
@PostMapping("/alarmMonth")
HttpResult<Boolean> alarmMonth(@RequestBody @Validated LineParam lineParam);
}

48
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/DayDataFeignClientFallbackFactory.java
View File

@@ -1,48 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.DayDataFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestBody;
/**
* ReportFeignClientFallbackFactory
*
* @author qijian
* @version 1.0.0
* @createTime 2022/10/24 - 9:52
*/
@Slf4j
@Component
public class DayDataFeignClientFallbackFactory implements FallbackFactory<DayDataFeignClient> {
@Override
public DayDataFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new DayDataFeignClient() {
@Override
public HttpResult<Boolean> dayDataHanlder(@RequestBody LineParam jobParam){
log.error("{}异常，降级处理，异常为：{}", "Date数据转Day数据: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<Boolean> dataToDayHandler(LineParam jobParam) {
log.error("{}异常，降级处理，异常为：{}", "Date数据转Day数据: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

41
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/DistortionRateFeignClientFallbackFactory.java
View File

@@ -1,41 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.DistortionRateFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
/**
* @author xiaoyao
* @version 1.0.0
* @createTime 2022/11/7 14:37
*/
@Slf4j
@Component
public class DistortionRateFeignClientFallbackFactory implements FallbackFactory<DistortionRateFeignClient> {
@Override
public DistortionRateFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new DistortionRateFeignClient() {
@Override
public HttpResult<Boolean> harmonicThdDay(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "谐波畸变率日表:", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

63
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/HarmOverLimitFeignClientFallbackFactory.java
View File

@@ -1,63 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.HarmOverLimitFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @author xuyang
*/
@Slf4j
@Component
public class HarmOverLimitFeignClientFallbackFactory implements FallbackFactory<HarmOverLimitFeignClient> {
@Override
public HarmOverLimitFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new HarmOverLimitFeignClient() {
@Override
public HttpResult<Boolean> harmonicDetailDay1(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点稳态指标超标明细日表1: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<Boolean> harmonicDetailDay2(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点稳态指标超标明细日表2: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<Boolean> harmonicDetailMonth1(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点稳态指标超标明细月表1: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<Boolean> harmonicDetailMonth2(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点稳态指标超标明细月表1: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<Boolean> harmonicThdDay(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "谐波畸变率日表: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

47
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/HarmonicGeneralFeignClientFallbackFactory.java
View File

@@ -1,47 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.HarmonicGeneralFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
/**
* @author xiaoyao
* @version 1.0.0
* @createTime 2022/11/7 15:17
*/
@Slf4j
@Component
public class HarmonicGeneralFeignClientFallbackFactory implements FallbackFactory<HarmonicGeneralFeignClient> {
@Override
public HarmonicGeneralFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new HarmonicGeneralFeignClient() {
@Override
public HttpResult<String> generalData(@RequestBody @Validated LineParam lineParam){
log.error("{}异常，降级处理，异常为：{}", "稳态综合评估: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<String> generalDataToMysql(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "稳态综合评估: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

47
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/HarmonicMetricFeignClientFallbackFactory.java
View File

@@ -1,47 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.HarmonicMetricFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
/**
* @author xiaoyao
* @version 1.0.0
* @createTime 2022/11/7 15:14
*/
@Slf4j
@Component
public class HarmonicMetricFeignClientFallbackFactory implements FallbackFactory<HarmonicMetricFeignClient> {
@Override
public HarmonicMetricFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new HarmonicMetricFeignClient() {
@Override
public HttpResult<String> metricData(@RequestBody @Validated LineParam lineParam){
log.error("{}异常，降级处理，异常为：{}", "稳态指标评估: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<String> metricDataToMysql(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "稳态指标评估: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

46
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/IntegrityFeignClientFallbackFactory.java
View File

@@ -1,46 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.IntegrityFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
/**
* IntegrityFeignClientFallbackFactory
*/
@Slf4j
@Component
public class IntegrityFeignClientFallbackFactory implements FallbackFactory<IntegrityFeignClient> {
@Override
public IntegrityFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new IntegrityFeignClient() {
@Override
public HttpResult<String> computeDataIntegrity(@RequestBody @Validated LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "数据完整性处理: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<String> dataIntegrity(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "数据完整性处理: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

50
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/LimitTargetFeignClientFallbackFactory.java
View File

@@ -1,50 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.LimitTargetFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
/**
* ReportFeignClientFallbackFactory
*
* @author qijian
* @version 1.0.0
* @createTime 2022/10/24 - 9:52
*/
@Slf4j
@Component
public class LimitTargetFeignClientFallbackFactory implements FallbackFactory<LimitTargetFeignClient> {
@Override
public LimitTargetFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new LimitTargetFeignClient() {
@Override
public HttpResult<String> getLimitTargetData(@RequestBody @Validated LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "越限数据: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<String> limitTargetData(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "越限数据: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

49
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/LimitrateFeignClientFallbackFactory.java
View File

@@ -1,49 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.LimitrateFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestBody;
/**
* ReportFeignClientFallbackFactory
*
* @author qijian
* @version 1.0.0
* @createTime 2022/10/24 - 9:52
*/
@Slf4j
@Component
public class LimitrateFeignClientFallbackFactory implements FallbackFactory<LimitrateFeignClient> {
@Override
public LimitrateFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new LimitrateFeignClient() {
@Override
public HttpResult<Boolean> limitRateHanlder(@RequestBody LineParam limitRateHanlderParam ){
log.error("{}异常，降级处理，异常为：{}", "越限数据处理: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<Boolean> limitRate(LineParam limitRateHanlderParam) {
log.error("{}异常，降级处理，异常为：{}", "越限数据处理: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

46
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/OnlineRateFeignClientFallbackFactory.java
View File

@@ -1,46 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.OnlineRateFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
/**
* OnlineRateFeignClientFallbackFactory
*/
@Slf4j
@Component
public class OnlineRateFeignClientFallbackFactory implements FallbackFactory<OnlineRateFeignClient> {
@Override
public OnlineRateFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new OnlineRateFeignClient() {
@Override
public HttpResult<String> getOnlineRateData(@RequestBody @Validated LineParam lineParam){
log.error("{}异常，降级处理，异常为：{}", "在线率: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<String> onlineRateData(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "在线率: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

41
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/PollutionFeignClientFallbackFactory.java
View File

@@ -1,41 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.PollutionFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
/**
* PollutionFeignClientFallbackFactory
*
*/
@Slf4j
@Component
public class PollutionFeignClientFallbackFactory implements FallbackFactory<PollutionFeignClient> {
@Override
public PollutionFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new PollutionFeignClient() {
@Override
public HttpResult<String> processPollutionData(@RequestBody @Validated LineParam lineParam){
log.error("{}异常，降级处理，异常为：{}", "污区数据: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

41
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/RAlarmCountFeignClientFallbackFactory.java
View File

@@ -1,41 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.RAlarmCountFeignClient;
import com.njcn.prepare.harmonic.api.line.RStatEventFeignClient;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @author zbj
*/
@Slf4j
@Component
public class RAlarmCountFeignClientFallbackFactory implements FallbackFactory<RAlarmCountFeignClient> {
@Override
public RAlarmCountFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RAlarmCountFeignClient() {
@Override
public HttpResult<Boolean> rAlarmCountHandler(OrgParam orgParam) {
log.error("{}异常，降级处理，异常为：{}", "指标告警统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

42
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/RMpDevEvaluateDetailFeignClientFallbackFactory.java
View File

@@ -1,42 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.RMpDevEvaluateDetailFeignClient;
import com.njcn.prepare.harmonic.api.line.RStatOrgFeignClient;
import com.njcn.prepare.harmonic.pojo.param.DeviceParam;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @author zbj
*/
@Slf4j
@Component
public class RMpDevEvaluateDetailFeignClientFallbackFactory implements FallbackFactory<RMpDevEvaluateDetailFeignClient> {
@Override
public RMpDevEvaluateDetailFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RMpDevEvaluateDetailFeignClient() {
@Override
public HttpResult<Boolean> handler(DeviceParam deviceParam) {
log.error("{}异常，降级处理，异常为：{}", "终端数据评价_日统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

42
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/RStatEventFeignClientFallbackFactory.java
View File

@@ -1,42 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.HarmOverLimitFeignClient;
import com.njcn.prepare.harmonic.api.line.RStatEventFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @author zbj
*/
@Slf4j
@Component
public class RStatEventFeignClientFallbackFactory implements FallbackFactory<RStatEventFeignClient> {
@Override
public RStatEventFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RStatEventFeignClient() {
@Override
public HttpResult<Boolean> rStartEventHandler(OrgParam orgParam) {
log.error("{}异常，降级处理，异常为：{}", "暂态指标统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

41
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/RStatEventOrgFeignClientFallbackFactory.java
View File

@@ -1,41 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.RStatEventFeignClient;
import com.njcn.prepare.harmonic.api.line.RStatEventOrgFeignClient;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @author zbj
*/
@Slf4j
@Component
public class RStatEventOrgFeignClientFallbackFactory implements FallbackFactory<RStatEventOrgFeignClient> {
@Override
public RStatEventOrgFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RStatEventOrgFeignClient() {
@Override
public HttpResult<Boolean> rStartEventOrgHandler(OrgParam orgParam) {
log.error("{}异常，降级处理，异常为：{}", "单位暂态指标统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

41
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/RStatOrgFeignClientFallbackFactory.java
View File

@@ -1,41 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.RStatEventFeignClient;
import com.njcn.prepare.harmonic.api.line.RStatOrgFeignClient;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @author zbj
*/
@Slf4j
@Component
public class RStatOrgFeignClientFallbackFactory implements FallbackFactory<RStatOrgFeignClient> {
@Override
public RStatOrgFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RStatOrgFeignClient() {
@Override
public HttpResult<Boolean> handler(OrgParam orgParam) {
log.error("{}异常，降级处理，异常为：{}", "区域分类统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

41
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/RStatSubstationFeignClientFallbackFactory.java
View File

@@ -1,41 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.RStatEventFeignClient;
import com.njcn.prepare.harmonic.api.line.RStatSubstationFeignClient;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @author zbj
*/
@Slf4j
@Component
public class RStatSubstationFeignClientFallbackFactory implements FallbackFactory<RStatSubstationFeignClient> {
@Override
public RStatSubstationFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RStatSubstationFeignClient() {
@Override
public HttpResult<Boolean> rStartSubstationHandler(OrgParam orgParam) {
log.error("{}异常，降级处理，异常为：{}", "变电站指标统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

52
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/TargetWarnFeignClientFallbackFactory.java
View File

@@ -1,52 +0,0 @@
package com.njcn.prepare.harmonic.api.line.fallback;
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.prepare.harmonic.api.line.HarmOverLimitFeignClient;
import com.njcn.prepare.harmonic.api.line.TargetWarnFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @author xuyang
*/
@Slf4j
@Component
public class TargetWarnFeignClientFallbackFactory implements FallbackFactory<TargetWarnFeignClient> {
@Override
public TargetWarnFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new TargetWarnFeignClient() {
@Override
public HttpResult<Boolean> targetDiff(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点稳态指标差值日统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<Boolean> alarmDay(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点指标告警日统计(新): ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<Boolean> alarmMonth(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点指标告警月统计(新): ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

40
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/line/fallback/ThsSuperviseClientFallbackFactory.java
View File

@@ -1,40 +0,0 @@
//package com.njcn.prepare.harmonic.api.line.fallback;
//
//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.prepare.harmonic.api.line.ThsSuperviseClient;
//import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
//import feign.hystrix.FallbackFactory;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.stereotype.Component;
//import org.springframework.validation.annotation.Validated;
//import org.springframework.web.bind.annotation.RequestBody;
//
//@Slf4j
//@Component
//public class ThsSuperviseClientFallbackFactory implements FallbackFactory<ThsSuperviseClient> {
// @Override
// public ThsSuperviseClient create(Throwable throwable) {
// Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
// if (throwable.getCause() instanceof BusinessException) {
// BusinessException businessException = (BusinessException) throwable.getCause();
// exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
// }
// Enum<?> finalExceptionEnum = exceptionEnum;
// return new ThsSuperviseClient() {
// @Override
// public HttpResult<String> initSupervise(@RequestBody @Validated SuperviseParam superviseParam) {
// log.error("{}异常，降级处理，异常为：{}", "预警/告警事务的初始化: ", throwable.toString());
// throw new BusinessException(finalExceptionEnum);
// }
//
// @Override
// public HttpResult<String> creatSupervise(SuperviseParam superviseParam) {
// log.error("{}异常，降级处理，异常为：{}", "预警/告警事务的生成: ", throwable.toString());
// throw new BusinessException(finalExceptionEnum);
// }
// };
// }
//}

1
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/PmsStatisticsSpecialMonitorFeignClient.java
View File

@@ -3,7 +3,6 @@ package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RStatAbnormalFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.PostMapping;

4
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/RMpEmissionFeignClient.java
View File

@@ -3,7 +3,7 @@ package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.rMpEmissionFallbackFactory;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RMpEmissionFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
@@ -12,7 +12,7 @@ import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,
path = "/rMpEmissionM",
fallbackFactory = rMpEmissionFallbackFactory.class
fallbackFactory = RMpEmissionFallbackFactory.class
)
public interface RMpEmissionFeignClient {

24
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/RMpEventDetailFeignClient.java
View File

@@ -1,24 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RMpEventDetailFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rmpeventdetail",//对应controller请求类
fallbackFactory = RMpEventDetailFeignClientFallbackFactory.class//服务降级处理类
)
public interface RMpEventDetailFeignClient {
@PostMapping("/eventdetailHandler")
@ApiOperation("监测点暂态指标处理")
HttpResult<String> eventdetailHandler(@RequestBody @Validated LineParam lineParam);
}

4
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/RMpInfluenceFeignClient.java
View File

@@ -3,7 +3,7 @@ package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.rMpInfluenceFallbackFactory;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RMpInfluenceFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.cloud.openfeign.FeignClient;
@@ -13,7 +13,7 @@ import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,
path = "/rMpInfluenceM",
fallbackFactory = rMpInfluenceFallbackFactory.class
fallbackFactory = RMpInfluenceFallbackFactory.class
)
public interface RMpInfluenceFeignClient {

23
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/RMpMonitorEvaluateFeignClient.java
View File

@@ -1,23 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RMpMonitorEvaluateFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rmpmonitorevaluate",//对应controller请求类
fallbackFactory = RMpMonitorEvaluateFeignClientFallbackFactory.class//服务降级处理类
)
public interface RMpMonitorEvaluateFeignClient {
@ApiOperation("监测点评价_日统计(MySQL库)")
@PostMapping("handlerMonitorEvaluate")
HttpResult<Boolean> handlerMonitorEvaluate(@RequestBody LineParam jobParam );
}

25
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/RMpPassrateFeignClient.java
View File

@@ -1,25 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RMpPassrateFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rmppassrate",//对应controller请求类
fallbackFactory = RMpPassrateFeignClientFallbackFactory.class//服务降级处理类
)
public interface RMpPassrateFeignClient {
@PostMapping("/passRateHandler")
@ApiOperation("监测点稳态指标合格率统计")
HttpResult<String> passRateHandler(@RequestBody @Validated LineParam lineParam);
}

5
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/ROperatingIndexFeignClient.java
View File

@@ -1,9 +1,8 @@
package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.ROperatingMonitorFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.ROperatingIndexFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.PrimaryGridDataIntegrityParam;
import com.njcn.prepare.harmonic.pojo.param.PrimaryGridParam;
import org.springframework.cloud.openfeign.FeignClient;
@@ -13,7 +12,7 @@ import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/primaryGridData",//对应controller请求类
fallbackFactory = ROperatingMonitorFeignClientFallbackFactory.class//服务降级处理类
fallbackFactory = ROperatingIndexFeignClientFallbackFactory.class//服务降级处理类
)
public interface ROperatingIndexFeignClient {

24
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/ROperatingMonitorFeignClient.java
View File

@@ -1,24 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.ROperatingMonitorFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/roperatingmonitor",//对应controller请求类
fallbackFactory = ROperatingMonitorFeignClientFallbackFactory.class//服务降级处理类
)
public interface ROperatingMonitorFeignClient {
@PostMapping("handlerMonitorOperatingD")
HttpResult<Boolean> handlerMonitorOperatingD(@RequestBody LineParam jobParam );
@PostMapping("handlerMonitorOperatingM")
HttpResult<Boolean> handlerMonitorOperatingM(@RequestBody LineParam jobParam );
}

4
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/RQualityParameterMFeignClient.java
View File

@@ -3,7 +3,7 @@ package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RStatAbnormalFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RQualityParameterMFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.PostMapping;
@@ -12,7 +12,7 @@ import org.springframework.web.bind.annotation.RequestBody;
@org.springframework.cloud.openfeign.FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rQualityParameterM",//对应controller请求类
fallbackFactory = RStatAbnormalFeignClientFallbackFactory.class//服务降级处理类
fallbackFactory = RQualityParameterMFeignClientFallbackFactory.class//服务降级处理类
)
public interface RQualityParameterMFeignClient {

23
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/RStatAbnormalFeignClient.java
View File

@@ -1,23 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RStatAbnormalFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rmstatabnormal",//对应controller请求类
fallbackFactory = RStatAbnormalFeignClientFallbackFactory.class//服务降级处理类
)
public interface RStatAbnormalFeignClient {
@ApiOperation("监测点异常_日统计(MySQL库)")
@PostMapping("handlerMonitorAbnormal")
HttpResult<Boolean> handlerMonitorAbnormal(@RequestBody LineParam jobParam );
}

22
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/RStatDevSignalFeignClient.java
View File

@@ -1,22 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RStatAbnormalFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.DeviceParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rstatdevsignal",//对应controller请求类
fallbackFactory = RStatAbnormalFeignClientFallbackFactory.class//服务降级处理类
)
public interface RStatDevSignalFeignClient {
@PostMapping("/rstatdevsignalHandler")
HttpResult<String> rstatdevsignalHandler(@RequestBody @Validated DeviceParam deviceParam);
}

21
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/RStatHarmonicFeignClient.java
View File

@@ -1,21 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RStatHarmonicFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rstatharmonic",//对应controller请求类
fallbackFactory = RStatHarmonicFeignClientFallbackFactory.class//服务降级处理类
)
public interface RStatHarmonicFeignClient {
@PostMapping("/Handler")
HttpResult<String> handler(@RequestBody OrgParam orgParam);
}

22
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/RStatHarmonicOrgFeignClient.java
View File

@@ -1,22 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RStatHarmonicFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RStatHarmonicOrgFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
@FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rstatharmonicorg",//对应controller请求类
fallbackFactory = RStatHarmonicOrgFeignClientFallbackFactory.class//服务降级处理类
)
public interface RStatHarmonicOrgFeignClient {
@PostMapping("/Handler")
HttpResult<String> handler(@RequestBody OrgParam orgParam);
}

2
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/fallback/rMpEmissionFallbackFactory.java → pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/fallback/RMpEmissionFallbackFactory.java
View File

@@ -12,7 +12,7 @@ import org.springframework.stereotype.Component;
@Slf4j
@Component
public class rMpEmissionFallbackFactory implements FallbackFactory<RMpEmissionFeignClient> {
public class RMpEmissionFallbackFactory implements FallbackFactory<RMpEmissionFeignClient> {
@Override
public RMpEmissionFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;

34
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/fallback/RMpEventDetailFeignClientFallbackFactory.java
View File

@@ -1,34 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm.fallback;
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.prepare.harmonic.api.newalgorithm.RMpEventDetailFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class RMpEventDetailFeignClientFallbackFactory implements FallbackFactory<RMpEventDetailFeignClient> {
@Override
public RMpEventDetailFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RMpEventDetailFeignClient() {
@Override
public HttpResult<String> eventdetailHandler(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点暂态指标处理: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

13
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/fallback/RMpPassrateFeignClientFallbackFactory.java → pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/fallback/RMpInfluenceFallbackFactory.java
View File

@@ -3,8 +3,7 @@ package com.njcn.prepare.harmonic.api.newalgorithm.fallback;
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.prepare.harmonic.api.newalgorithm.RMpPassrateFeignClient;
import com.njcn.prepare.harmonic.api.newalgorithm.RMpInfluenceFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
@@ -13,9 +12,9 @@ import org.springframework.stereotype.Component;
@Slf4j
@Component
public class RMpPassrateFeignClientFallbackFactory implements FallbackFactory<RMpPassrateFeignClient> {
public class rMpInfluenceFallbackFactory implements FallbackFactory<RMpInfluenceFeignClient> {
@Override
public RMpPassrateFeignClient create(Throwable throwable) {
public RMpInfluenceFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
@@ -23,10 +22,10 @@ public class RMpPassrateFeignClientFallbackFactory implements FallbackFactory<RM
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RMpPassrateFeignClient() {
return new RMpInfluenceFeignClient() {
@Override
public HttpResult<String> passRateHandler(LineParam lineParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点稳态指标合格率统计: ", throwable.toString());
public HttpResult<Boolean> rMpInfluenceMHandler(LineParam jobParam) {
log.error("{}异常，降级处理，异常为：{}", "影响特性: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};

34
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/fallback/RMpMonitorEvaluateFeignClientFallbackFactory.java
View File

@@ -1,34 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm.fallback;
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.prepare.harmonic.api.newalgorithm.RMpMonitorEvaluateFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class RMpMonitorEvaluateFeignClientFallbackFactory implements FallbackFactory<RMpMonitorEvaluateFeignClient> {
@Override
public RMpMonitorEvaluateFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RMpMonitorEvaluateFeignClient() {
@Override
public HttpResult<Boolean> handlerMonitorEvaluate(LineParam jobParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点评价_日统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

39
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/fallback/ROperatingMonitorFeignClientFallbackFactory.java
View File

@@ -1,39 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm.fallback;
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.prepare.harmonic.api.newalgorithm.ROperatingMonitorFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class ROperatingMonitorFeignClientFallbackFactory implements FallbackFactory<ROperatingMonitorFeignClient> {
@Override
public ROperatingMonitorFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new ROperatingMonitorFeignClient() {
@Override
public HttpResult<Boolean> handlerMonitorOperatingD(LineParam jobParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点数据质量_日统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<Boolean> handlerMonitorOperatingM(LineParam jobParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点数据质量_月统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

34
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/fallback/RStatAbnormalFeignClientFallbackFactory.java
View File

@@ -1,34 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm.fallback;
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.prepare.harmonic.api.newalgorithm.RStatAbnormalFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class RStatAbnormalFeignClientFallbackFactory implements FallbackFactory<RStatAbnormalFeignClient> {
@Override
public RStatAbnormalFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RStatAbnormalFeignClient() {
@Override
public HttpResult<Boolean> handlerMonitorAbnormal(LineParam jobParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点异常_日统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

34
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/fallback/RStatDevSignalClientFallbackFactory.java
View File

@@ -1,34 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm.fallback;
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.prepare.harmonic.api.newalgorithm.RStatDevSignalFeignClient;
import com.njcn.prepare.harmonic.pojo.param.DeviceParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class RStatDevSignalClientFallbackFactory implements FallbackFactory<RStatDevSignalFeignClient> {
@Override
public RStatDevSignalFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException) throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RStatDevSignalFeignClient() {
@Override
public HttpResult<String> rstatdevsignalHandler(DeviceParam deviceParam) {
log.error("{}异常，降级处理，异常为：{}", "终端通信管理_日统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

34
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/fallback/RStatHarmonicFeignClientFallbackFactory.java
View File

@@ -1,34 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm.fallback;
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.prepare.harmonic.api.newalgorithm.RStatHarmonicFeignClient;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class RStatHarmonicFeignClientFallbackFactory implements FallbackFactory<RStatHarmonicFeignClient> {
@Override
public RStatHarmonicFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RStatHarmonicFeignClient() {
@Override
public HttpResult<String> handler(OrgParam orgParam) {
log.error("{}异常，降级处理，异常为：{}", "单位监测点稳态指标统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

35
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/fallback/RStatHarmonicOrgFeignClientFallbackFactory.java
View File

@@ -1,35 +0,0 @@
package com.njcn.prepare.harmonic.api.newalgorithm.fallback;
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.prepare.harmonic.api.newalgorithm.RStatHarmonicFeignClient;
import com.njcn.prepare.harmonic.api.newalgorithm.RStatHarmonicOrgFeignClient;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
@Component
public class RStatHarmonicOrgFeignClientFallbackFactory implements FallbackFactory<RStatHarmonicOrgFeignClient> {
@Override
public RStatHarmonicOrgFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause();
exceptionEnum = PrepareEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RStatHarmonicOrgFeignClient() {
@Override
public HttpResult<String> handler(OrgParam orgParam) {
log.error("{}异常，降级处理，异常为：{}", "单位监测点稳态指标统计: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

2
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/newalgorithm/fallback/rMpInfluenceFallbackFactory.java
View File

@@ -12,7 +12,7 @@ import org.springframework.stereotype.Component;
@Slf4j
@Component
public class rMpInfluenceFallbackFactory implements FallbackFactory<RMpInfluenceFeignClient> {
public class RMpInfluenceFallbackFactory implements FallbackFactory<RMpInfluenceFeignClient> {
@Override
public RMpInfluenceFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;

3
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/specialanalysis/SpecialAnalysisFeignClient.java
View File

@@ -1,10 +1,7 @@
package com.njcn.prepare.harmonic.api.specialanalysis;
import com.njcn.common.pojo.annotation.OperateInfo;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.enums.common.LogEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.fallback.RStatHarmonicFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.api.specialanalysis.fallback.SpecialAnalysisFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient;

3
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/specialanalysis/fallback/SpecialAnalysisFeignClientFallbackFactory.java
View File

@@ -3,11 +3,8 @@ package com.njcn.prepare.harmonic.api.specialanalysis.fallback;
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.prepare.harmonic.api.newalgorithm.PmsStatisticsSpecialMonitorFeignClient;
import com.njcn.prepare.harmonic.api.newalgorithm.RStatHarmonicOrgFeignClient;
import com.njcn.prepare.harmonic.api.specialanalysis.SpecialAnalysisFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;

10
pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/api/voltage/VoltageFeignClient.java
View File

@@ -1,10 +0,0 @@
package com.njcn.prepare.harmonic.api.voltage;
/**
* @author qijian
* @version 1.0.0
* @date 2022年10月24日 20:13
*/
public interface VoltageFeignClient {
}