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

5
pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatLimitServiceImpl.java
View File

@@ -3,10 +3,8 @@ package com.njcn.harmonic.service.majornetwork.impl;
import cn.hutool.core.bean.BeanUtil; import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil; import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DatePattern; import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.DateUnit;
import cn.hutool.core.date.DateUtil; import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.LocalDateTimeUtil; import cn.hutool.core.date.LocalDateTimeUtil;
import cn.hutool.core.lang.func.Func;
import cn.hutool.core.util.NumberUtil; import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.ObjectUtil; import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil; import cn.hutool.core.util.StrUtil;
@@ -31,7 +29,6 @@ import com.njcn.device.pq.pojo.vo.RStatOnlinerateVO;
import com.njcn.harmonic.mapper.RStatLimitRateDMapper; import com.njcn.harmonic.mapper.RStatLimitRateDMapper;
import com.njcn.harmonic.mapper.RStatLimitTargetDMapper; import com.njcn.harmonic.mapper.RStatLimitTargetDMapper;
import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam; import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
import com.njcn.harmonic.pojo.po.RMpVThd;
import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO; import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
import com.njcn.harmonic.pojo.po.day.RStatLimitTargetDPO; import com.njcn.harmonic.pojo.po.day.RStatLimitTargetDPO;
import com.njcn.harmonic.pojo.vo.MonitorLimitRateVO; import com.njcn.harmonic.pojo.vo.MonitorLimitRateVO;
@@ -39,7 +36,6 @@ import com.njcn.harmonic.pojo.vo.PwLimitDataVO;
import com.njcn.harmonic.pojo.vo.RStatLimitTargetVO; import com.njcn.harmonic.pojo.vo.RStatLimitTargetVO;
import com.njcn.harmonic.service.IRStatLimitTargetDService; import com.njcn.harmonic.service.IRStatLimitTargetDService;
import com.njcn.harmonic.service.majornetwork.RStatLimitService; import com.njcn.harmonic.service.majornetwork.RStatLimitService;
import com.njcn.prepare.harmonic.api.line.LimitrateFeignClient;
import com.njcn.system.pojo.enums.StatisticsEnum; import com.njcn.system.pojo.enums.StatisticsEnum;
import com.njcn.web.factory.PageFactory; import com.njcn.web.factory.PageFactory;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
@@ -74,7 +70,6 @@ public class RStatLimitServiceImpl implements RStatLimitService {
private final CommTerminalGeneralClient commTerminalGeneralClient; private final CommTerminalGeneralClient commTerminalGeneralClient;
private final DistributionMonitorClient distributionMonitorClient; private final DistributionMonitorClient distributionMonitorClient;
private final LimitrateFeignClient limitrateFeignClient;
@Override @Override

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.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult; 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 com.njcn.prepare.harmonic.pojo.param.LineParam;
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.PostMapping; 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.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult; 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 com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient; import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PostMapping;
@@ -12,7 +12,7 @@ import org.springframework.web.bind.annotation.RequestBody;
@FeignClient( @FeignClient(
value = ServerInfo.PREPARE_BOOT, value = ServerInfo.PREPARE_BOOT,
path = "/rMpEmissionM", path = "/rMpEmissionM",
fallbackFactory = rMpEmissionFallbackFactory.class fallbackFactory = RMpEmissionFallbackFactory.class
) )
public interface RMpEmissionFeignClient { 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.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult; 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 com.njcn.prepare.harmonic.pojo.param.LineParam;
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
import org.springframework.cloud.openfeign.FeignClient; import org.springframework.cloud.openfeign.FeignClient;
@@ -13,7 +13,7 @@ import org.springframework.web.bind.annotation.RequestBody;
@FeignClient( @FeignClient(
value = ServerInfo.PREPARE_BOOT, value = ServerInfo.PREPARE_BOOT,
path = "/rMpInfluenceM", path = "/rMpInfluenceM",
fallbackFactory = rMpInfluenceFallbackFactory.class fallbackFactory = RMpInfluenceFallbackFactory.class
) )
public interface RMpInfluenceFeignClient { 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; package com.njcn.prepare.harmonic.api.newalgorithm;
import com.njcn.common.pojo.constant.ServerInfo; import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult; 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.PrimaryGridDataIntegrityParam;
import com.njcn.prepare.harmonic.pojo.param.PrimaryGridParam; import com.njcn.prepare.harmonic.pojo.param.PrimaryGridParam;
import org.springframework.cloud.openfeign.FeignClient; import org.springframework.cloud.openfeign.FeignClient;
@@ -13,7 +12,7 @@ import org.springframework.web.bind.annotation.RequestBody;
@FeignClient( @FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名 value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/primaryGridData",//对应controller请求类 path = "/primaryGridData",//对应controller请求类
fallbackFactory = ROperatingMonitorFeignClientFallbackFactory.class//服务降级处理类 fallbackFactory = ROperatingIndexFeignClientFallbackFactory.class//服务降级处理类
) )
public interface ROperatingIndexFeignClient { 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.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult; 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 com.njcn.prepare.harmonic.pojo.param.LineParam;
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PostMapping;
@@ -12,7 +12,7 @@ import org.springframework.web.bind.annotation.RequestBody;
@org.springframework.cloud.openfeign.FeignClient( @org.springframework.cloud.openfeign.FeignClient(
value = ServerInfo.PREPARE_BOOT,//对应模块名 value = ServerInfo.PREPARE_BOOT,//对应模块名
path = "/rQualityParameterM",//对应controller请求类 path = "/rQualityParameterM",//对应controller请求类
fallbackFactory = RStatAbnormalFeignClientFallbackFactory.class//服务降级处理类 fallbackFactory = RQualityParameterMFeignClientFallbackFactory.class//服务降级处理类
) )
public interface RQualityParameterMFeignClient { 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 @Slf4j
@Component @Component
public class rMpEmissionFallbackFactory implements FallbackFactory<RMpEmissionFeignClient> { public class RMpEmissionFallbackFactory implements FallbackFactory<RMpEmissionFeignClient> {
@Override @Override
public RMpEmissionFeignClient create(Throwable throwable) { public RMpEmissionFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK; 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.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.exception.BusinessException; import com.njcn.common.pojo.exception.BusinessException;
import com.njcn.common.pojo.response.HttpResult; import com.njcn.common.pojo.response.HttpResult;
import com.njcn.prepare.harmonic.api.newalgorithm.RMpInfluenceFeignClient;
import com.njcn.prepare.harmonic.api.newalgorithm.RMpPassrateFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam; import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil; import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory; import feign.hystrix.FallbackFactory;
@@ -13,9 +12,9 @@ import org.springframework.stereotype.Component;
@Slf4j @Slf4j
@Component @Component
public class RMpPassrateFeignClientFallbackFactory implements FallbackFactory<RMpPassrateFeignClient> { public class rMpInfluenceFallbackFactory implements FallbackFactory<RMpInfluenceFeignClient> {
@Override @Override
public RMpPassrateFeignClient create(Throwable throwable) { public RMpInfluenceFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK; Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) { if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException)throwable.getCause(); BusinessException businessException = (BusinessException)throwable.getCause();
@@ -23,10 +22,10 @@ public class RMpPassrateFeignClientFallbackFactory implements FallbackFactory<RM
} }
Enum<?> finalExceptionEnum = exceptionEnum; Enum<?> finalExceptionEnum = exceptionEnum;
return new RMpPassrateFeignClient() { return new RMpInfluenceFeignClient() {
@Override @Override
public HttpResult<String> passRateHandler(LineParam lineParam) { public HttpResult<Boolean> rMpInfluenceMHandler(LineParam jobParam) {
log.error("{}异常，降级处理，异常为：{}", "监测点稳态指标合格率统计: ", throwable.toString()); log.error("{}异常，降级处理，异常为：{}", "影响特性: ", throwable.toString());
throw new BusinessException(finalExceptionEnum); 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 @Slf4j
@Component @Component
public class rMpInfluenceFallbackFactory implements FallbackFactory<RMpInfluenceFeignClient> { public class RMpInfluenceFallbackFactory implements FallbackFactory<RMpInfluenceFeignClient> {
@Override @Override
public RMpInfluenceFeignClient create(Throwable throwable) { public RMpInfluenceFeignClient create(Throwable throwable) {
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK; 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; 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.constant.ServerInfo;
import com.njcn.common.pojo.enums.common.LogEnum;
import com.njcn.common.pojo.response.HttpResult; 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.api.specialanalysis.fallback.SpecialAnalysisFeignClientFallbackFactory;
import com.njcn.prepare.harmonic.pojo.param.LineParam; import com.njcn.prepare.harmonic.pojo.param.LineParam;
import org.springframework.cloud.openfeign.FeignClient; 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.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.exception.BusinessException; import com.njcn.common.pojo.exception.BusinessException;
import com.njcn.common.pojo.response.HttpResult; 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.api.specialanalysis.SpecialAnalysisFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam; import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.utils.PrepareEnumUtil; import com.njcn.prepare.harmonic.utils.PrepareEnumUtil;
import feign.hystrix.FallbackFactory; import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j; 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 {
}

2
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/executor/MeasurementExecutor.java
View File

@@ -40,8 +40,8 @@ public class MeasurementExecutor extends BaseExecutor {
private final RMpEventDetailService rMpEventDetailService; private final RMpEventDetailService rMpEventDetailService;
private final RMpEventDetailDService rMpEventDetailDService; private final RMpEventDetailDService rMpEventDetailDService;
private final RMpEventDetailQService rMpEventDetailQService; private final RMpEventDetailQService rMpEventDetailQService;
private final RMpEventDetailYService rMpEventDetailYService; private final RMpEventDetailYService rMpEventDetailYService;
private final DayDataService dayDataService; private final DayDataService dayDataService;
private final RStatAbnormalDService rStatAbnormalDService; private final RStatAbnormalDService rStatAbnormalDService;
private final ROperatingMonitorService rOperatingMonitorService; private final ROperatingMonitorService rOperatingMonitorService;

48
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/device/DeviceAbnormalController.java
View File

@@ -1,48 +0,0 @@
package com.njcn.prepare.harmonic.controller.device;
import com.njcn.common.pojo.annotation.OperateInfo;
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.pojo.param.DeviceAbnormaStatisticsParam;
import com.njcn.prepare.harmonic.service.mysql.device.DeviceAbnormalStatisticsService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import java.text.ParseException;
@Slf4j
@Api(tags = "终端异常统计")
@RestController
@RequestMapping("/deviceAbnormal")
@RequiredArgsConstructor
public class DeviceAbnormalController extends BaseController {
private final DeviceAbnormalStatisticsService deviceAbnormaStatisticsService;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/statistics")
@ApiOperation("终端异常统计")
@ApiImplicitParam(name = "param", value = "参数", required = true)
public HttpResult<Boolean> dailyDeviceAbnormaStatistics(@RequestBody DeviceAbnormaStatisticsParam param) {
String methodDescribe = getMethodDescribe("dailyDeviceAbnormaStatistics");
boolean res = deviceAbnormaStatisticsService.dailyDeviceAbnormaStatistics(param);
if(res){
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}else {
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.FAIL, null, methodDescribe);
}
}
}

86
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/line/AlarmDetailController.java
View File

@@ -1,86 +0,0 @@
package com.njcn.prepare.harmonic.controller.line;
import com.njcn.common.pojo.annotation.OperateInfo;
import com.njcn.common.pojo.constant.OperateType;
import com.njcn.common.pojo.enums.common.LogEnum;
import com.njcn.common.pojo.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.area.IRMpMonitorAlarmCountMService;
import com.njcn.prepare.harmonic.service.mysql.area.RMpTargetWarnDService;
import com.njcn.prepare.harmonic.service.mysql.line.AlarmDetailService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @author qijian
* @date 2022/12/28
* 监测点指标告警明细
*/
@Validated
@Slf4j
@RestController
@RequestMapping("/alarmDetail")
@Api(tags = "监测点指标告警明细")
@AllArgsConstructor
public class AlarmDetailController extends BaseController {
private final AlarmDetailService alarmDetailService;
private final RMpTargetWarnDService rMpTargetWarnDService;
private final IRMpMonitorAlarmCountMService rMpMonitorAlarmCountMService;
/* @OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
@PostMapping("/alarmDetailAlarm")
@ApiOperation("监测点指标告警日统计")
@ApiImplicitParam(name = "lineParam", value = "算法通用查询参数", required = true)
public HttpResult<Boolean> alarmDetailAlarm(@RequestBody @Validated LineParam lineParam) {
String methodDescribe = getMethodDescribe("alarmDetailAlarm");
alarmDetailService.alarmDetailAlarm(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}*/
/**
* @author xuyang
*/
@OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
@PostMapping("/targetDiff")
@ApiOperation("监测点稳态指标差值日统计")
@ApiImplicitParam(name = "lineParam", value = "算法通用查询参数", required = true)
public HttpResult<Boolean> targetDiff(@RequestBody @Validated LineParam lineParam) {
String methodDescribe = getMethodDescribe("targetDiff");
// alarmDetailService.targetDiff(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
@PostMapping("/alarmDay")
@ApiOperation("监测点指标告警日统计(新)")
@ApiImplicitParam(name = "lineParam", value = "算法通用查询参数", required = true)
public HttpResult<Boolean> alarmDay(@RequestBody @Validated LineParam lineParam) {
String methodDescribe = getMethodDescribe("alarmDay");
// rMpTargetWarnDService.alarmDay(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
@PostMapping("/alarmMonth")
@ApiOperation("监测点指标告警月统计(新)")
@ApiImplicitParam(name = "lineParam", value = "算法通用查询参数", required = true)
public HttpResult<Boolean> alarmMonth(@RequestBody @Validated LineParam lineParam) {
String methodDescribe = getMethodDescribe("alarmMonth");
// rMpMonitorAlarmCountMService.alarmMonth(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

117
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/line/DayDataController.java
View File

@@ -1,117 +0,0 @@
package com.njcn.prepare.harmonic.controller.line;
import cn.hutool.core.date.DateUtil;
import com.njcn.common.pojo.annotation.OperateInfo;
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.common.utils.NjcnDateUtils;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.pq.api.GeneralDeviceInfoClient;
import com.njcn.device.pq.api.LineFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.line.DayDataService;
import com.njcn.prepare.harmonic.utils.PublicUtil;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.*;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2022/10/24 9:26【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@Api(tags = "日表数据处理")
@RestController
@RequestMapping("daydata")
@RequiredArgsConstructor
public class DayDataController extends BaseController {
private final LineFeignClient lineFeignClient;
private final DayDataService dayDataService;
private final CommTerminalGeneralClient commTerminalGeneralClient;
/* @Deprecated
@ApiOperation("day表定时任务")
@ApiImplicitParam(value = "jobParam",name = "jobParam",required = true)
@PostMapping("dayDataHanlder")
@OperateInfo(info = LogEnum.BUSINESS_MEDIUM)
public HttpResult<Boolean> dayDataHanlder(@RequestBody LineParam jobParam ){
log.info(LocalDateTime.now()+"dayDataHanlder开始执行");
String methodDescribe = getMethodDescribe("dayDataHanlder");
Boolean result = true;
List<String> indexLists = new ArrayList<> ();
if(CollectionUtils.isEmpty (jobParam.getLineIds ())){
indexLists = lineFeignClient.getLineList ( ).getData ( );
}else{
indexLists = jobParam.getLineIds ();
}
String startTime = jobParam.getDataDate ()+" "+"00:00:00";
String endTime = jobParam.getDataDate ()+" "+"23:59:59";
dayDataService.dayDataJobHandler (indexLists,startTime,endTime);
if (result){
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, true, methodDescribe);
} else {
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.FAIL, false, methodDescribe);
}
}*/
@ApiOperation("day表定时任务(MySQL库)")
@ApiImplicitParam(value = "jobParam",name = "jobParam",required = true)
@PostMapping("dataToDay")
@OperateInfo(info = LogEnum.BUSINESS_MEDIUM)
public HttpResult<Boolean> dataToDayHandler(@RequestBody LineParam jobParam ){
//特殊处理后面需要删除
if(Objects.isNull(jobParam.getLineType())){
jobParam.setLineType(2);
}
String startTime,endTime;
log.info(LocalDateTime.now()+"dataToDayHandler开始执行,开始时间-结束时间"+jobParam.getBeginTime()+"___"+jobParam.getEndTime());
String methodDescribe = getMethodDescribe("dataToDayHandler");
List<String> indexLists = new ArrayList<> ();
if(CollectionUtils.isEmpty (jobParam.getLineIds())){
indexLists = commTerminalGeneralClient.getRunMonitorIds().getData();
} else{
indexLists = jobParam.getLineIds();
}
if (Objects.nonNull(jobParam.getRepairFlag()) && jobParam.getRepairFlag()){
List<String> timeRange = NjcnDateUtils.findEveryDay(jobParam.getBeginTime(),jobParam.getEndTime());
for (String item : timeRange) {
log.info(item+"-->开始执行");
startTime = item+" "+"00:00:00";
endTime = item+" "+"23:59:59";
// dayDataService.dataToDayHandler(indexLists,startTime,endTime,jobParam.getLineType());
}
} else {
// dayDataService.dataToDayHandler(indexLists,jobParam.getBeginTime(),jobParam.getEndTime(),jobParam.getLineType());
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, true, methodDescribe);
}
}

71
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/line/HarmonicGeneralController.java
View File

@@ -1,71 +0,0 @@
package com.njcn.prepare.harmonic.controller.line;
import com.njcn.common.pojo.annotation.OperateInfo;
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.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.line.HarmonicGeneralService;
import com.njcn.prepare.harmonic.utils.PublicUtil;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
/**
* @author xiaoyao
* @version 1.0.0
* @createTime 2022/11/3 9:00
*/
@Slf4j
@Api(tags = "稳态综合评估")
@RestController
@RequestMapping("/general")
@RequiredArgsConstructor
public class HarmonicGeneralController extends BaseController {
private final HarmonicGeneralService harmonicGeneralService;
@Deprecated
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/generalData")
@ApiOperation("稳态综合评估日数据计算")
@ApiImplicitParam(name = "lineParam", value = "参数", required = true)
public HttpResult<String> generalData(@RequestBody @Validated LineParam lineParam){
String methodDescribe = getMethodDescribe("generalData");
harmonicGeneralService.generalData(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/generalDataToMysql")
@ApiOperation("稳态综合评估日数据计算(MySQL入库)")
@ApiImplicitParam(name = "lineParam", value = "参数", required = true)
public HttpResult<String> generalDataToMysql(@RequestBody @Validated LineParam lineParam){
log.info(LocalDateTime.now()+"generalDataToMysql开始执行");
String methodDescribe = getMethodDescribe("generalDataToMysql");
if (lineParam.getType() == 3){
int year = Integer.parseInt(lineParam.getDataDate().split("-")[0]);
int month = Integer.parseInt(lineParam.getDataDate().split("-")[1]);
List<String> dayList = PublicUtil.getDayByMonth(year,month);
for (String item : dayList) {
log.info(item+"-->开始执行");
harmonicGeneralService.generalDataToMysql(lineParam,item);
}
} else {
harmonicGeneralService.generalDataToMysql(lineParam,lineParam.getDataDate());
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

72
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/line/HarmonicMetricController.java
View File

@@ -1,72 +0,0 @@
package com.njcn.prepare.harmonic.controller.line;
import com.njcn.common.pojo.annotation.OperateInfo;
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.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.line.HarmonicMetricService;
import com.njcn.prepare.harmonic.utils.PublicUtil;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
/**
* @author xiaoyao
* @version 1.0.0
* @createTime 2022/11/3 8:59
*/
@Slf4j
@Api(tags = "稳态指标评估")
@RestController
@RequestMapping("/metric")
@RequiredArgsConstructor
public class HarmonicMetricController extends BaseController {
private final HarmonicMetricService harmonicMetricService;
@Deprecated
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/metricData")
@ApiOperation("稳态指标评估日数据计算")
@ApiImplicitParam(name = "lineParam", value = "参数", required = true)
public HttpResult<String> metricData(@RequestBody @Validated LineParam lineParam){
String methodDescribe = getMethodDescribe("metricData");
harmonicMetricService.metricData(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/metricDataToMysql")
@ApiOperation("稳态指标评估日数据计算(MySQL入库)")
@ApiImplicitParam(name = "lineParam", value = "参数", required = true)
public HttpResult<String> metricDataToMysql(@RequestBody @Validated LineParam lineParam){
log.info(LocalDateTime.now()+"metricDataToMysql开始执行");
String methodDescribe = getMethodDescribe("metricDataToMysql");
if (lineParam.getType() == 3){
int year = Integer.parseInt(lineParam.getDataDate().split("-")[0]);
int month = Integer.parseInt(lineParam.getDataDate().split("-")[1]);
List<String> dayList = PublicUtil.getDayByMonth(year,month);
for (String item : dayList) {
log.info(item+"-->开始执行");
harmonicMetricService.metricDataToMysql(lineParam,item);
}
} else {
harmonicMetricService.metricDataToMysql(lineParam,lineParam.getDataDate());
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

98
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/line/HarmonicOverLimitController.java
View File

@@ -1,98 +0,0 @@
package com.njcn.prepare.harmonic.controller.line;
import com.njcn.common.pojo.annotation.OperateInfo;
import com.njcn.common.pojo.constant.OperateType;
import com.njcn.common.pojo.enums.common.LogEnum;
import com.njcn.common.pojo.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.line.*;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 类的介绍：
*
* @author xuyang
* @version 1.0.0
* @createTime 2023/4/20 16:05
*/
@Validated
@Slf4j
@RestController
@RequestMapping("/harmonicOverLimit")
@Api(tags = "监测点稳态指标统计")
@AllArgsConstructor
public class HarmonicOverLimitController extends BaseController {
private final IRMpPartHarmonicDetailDService mpPartHarmonicDetailDService;
private final IRMpSurplusHarmonicDetailDService mpSurplusHarmonicDetailDService;
private final IRMpPartHarmonicDetailMService mpPartHarmonicDetailMService;
private final IRMpSurplusHarmonicDetailMService mpSurplusHarmonicDetailMService;
private final IRMpVThdService mpVThdService;
@OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
@PostMapping("/harmonicDetailDay1")
@ApiOperation("监测点稳态指标超标明细日表1")
@ApiImplicitParam(name = "lineParam", value = "算法通用查询参数", required = true)
public HttpResult<Boolean> harmonicDetailDay1(@RequestBody @Validated LineParam lineParam) {
String methodDescribe = getMethodDescribe("harmonicDetailDay1");
// mpPartHarmonicDetailDService.insertHarmonicDetailDayOne(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
@PostMapping("/harmonicDetailDay2")
@ApiOperation("监测点稳态指标超标明细日表2")
@ApiImplicitParam(name = "lineParam", value = "算法通用查询参数", required = true)
public HttpResult<Boolean> harmonicDetailDay2(@RequestBody @Validated LineParam lineParam) {
String methodDescribe = getMethodDescribe("harmonicDetailDay2");
// mpSurplusHarmonicDetailDService.insertHarmonicDetailDayTwo(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
@PostMapping("/harmonicDetailMonth1")
@ApiOperation("监测点稳态指标超标明细月表1")
@ApiImplicitParam(name = "lineParam", value = "算法通用查询参数", required = true)
public HttpResult<Boolean> harmonicDetailMonth1(@RequestBody @Validated LineParam lineParam) {
String methodDescribe = getMethodDescribe("harmonicDetailMonth1");
// mpPartHarmonicDetailMService.insertHarmonicDetailMonthOne(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
@PostMapping("/harmonicDetailMonth2")
@ApiOperation("监测点稳态指标超标明细月表2")
@ApiImplicitParam(name = "lineParam", value = "算法通用查询参数", required = true)
public HttpResult<Boolean> harmonicDetailMonth2(@RequestBody @Validated LineParam lineParam) {
String methodDescribe = getMethodDescribe("harmonicDetailMonth2");
// mpSurplusHarmonicDetailMService.insertHarmonicDetailMonthTwo(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
@PostMapping("/harmonicThdDay")
@ApiOperation("谐波畸变率日表")
@ApiImplicitParam(name = "lineParam", value = "算法通用查询参数", required = true)
public HttpResult<Boolean> harmonicThdDay(@RequestBody @Validated LineParam lineParam) {
String methodDescribe = getMethodDescribe("harmonicThdDay");
// mpVThdService.insertHarmonicVThdDay(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

66
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/line/IntegrityController.java
View File

@@ -1,66 +0,0 @@
package com.njcn.prepare.harmonic.controller.line;
import com.njcn.common.pojo.annotation.OperateInfo;
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.common.utils.NjcnDateUtils;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.line.IntegrityService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Objects;
/**
* @author xiaoyao
* @version 1.0.0
* @createTime 2022/10/24 20:03
*/
@Slf4j
@Api(tags = "数据完整性统计")
@RestController
@RequestMapping("/integrity")
@RequiredArgsConstructor
public class IntegrityController extends BaseController {
private final IntegrityService integrityService;
private final CommTerminalGeneralClient commTerminalGeneralClient;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/dataIntegrity")
@ApiOperation("数据完整性统计(MySQL库)")
@ApiImplicitParam(name = "lineParam", value = "参数", required = true)
public HttpResult<String> dataIntegrity(@RequestBody @Validated LineParam lineParam){
log.info(LocalDateTime.now()+"dataIntegrity开始执行");
String methodDescribe = getMethodDescribe("dataIntegrity");
String startTime,endTime;
if (Objects.nonNull(lineParam.getRepairFlag()) && lineParam.getRepairFlag()){
List<String> timeRange = NjcnDateUtils.findEveryDay(lineParam.getBeginTime(),lineParam.getEndTime());
for (String item : timeRange) {
log.info(item+"-->开始执行");
startTime = item+" "+"00:00:00";
endTime = item+" "+"23:59:59";
integrityService.dataIntegrity(lineParam,startTime,endTime);
}
} else {
integrityService.dataIntegrity(lineParam,lineParam.getBeginTime(),lineParam.getEndTime());
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, CommonResponseEnum.SUCCESS.getMessage(), methodDescribe);
}
}

82
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/line/LimitTargetController.java
View File

@@ -1,82 +0,0 @@
package com.njcn.prepare.harmonic.controller.line;
import com.njcn.common.pojo.annotation.OperateInfo;
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.common.utils.NjcnDateUtils;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.line.LimitTargetService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
/**
* @author xiaoyao
* @version 1.0.0
* @createTime 2022/10/26 13:32
*/
@Slf4j
@Api(tags = "监测点T相数据超限处理")
@RestController
@RequestMapping("/limitTarget")
@RequiredArgsConstructor
public class LimitTargetController extends BaseController {
private final LimitTargetService limitTargetService;
private final CommTerminalGeneralClient commTerminalGeneralClient;
@Deprecated
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/getLimitTargetData")
@ApiOperation("生成limit_target表")
@ApiImplicitParam(name = "lineParam", value = "参数", required = true)
public HttpResult<String> getLimitTargetData(@RequestBody @Validated LineParam lineParam){
String methodDescribe = getMethodDescribe("getLimitTargetData");
limitTargetService.getLimitTargetData(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/limitTargetData")
@ApiOperation("生成limit_target表(MySQL入库)")
@ApiImplicitParam(name = "jobParam", value = "参数", required = true)
public HttpResult<String> limitTargetData(@RequestBody LineParam jobParam){
log.info(LocalDateTime.now()+"limitTargetData开始执行");
String methodDescribe = getMethodDescribe("limitTargetData");
String startTime,endTime;
List<String> indexLists;
if(CollectionUtils.isEmpty (jobParam.getLineIds ())){
indexLists = commTerminalGeneralClient.getRunMonitorIds ().getData ( );
}else{
indexLists = jobParam.getLineIds ();
}
if (jobParam.getRepairFlag()){
List<String> timeRange = NjcnDateUtils.findEveryDay(jobParam.getBeginTime(),jobParam.getEndTime());
for (String item : timeRange) {
log.info(item+"-->开始执行");
startTime = item+" "+"00:00:00";
endTime = item+" "+"23:59:59";
limitTargetService.limitTargetData(indexLists,startTime,endTime);
}
} else {
limitTargetService.limitTargetData(indexLists,jobParam.getBeginTime(), jobParam.getEndTime());
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

100
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/line/LimitrateController.java
View File

@@ -1,100 +0,0 @@
package com.njcn.prepare.harmonic.controller.line;
import com.njcn.common.pojo.annotation.OperateInfo;
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.common.utils.NjcnDateUtils;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.Impl.line.LimitRateServiceImpl;
import com.njcn.prepare.harmonic.service.mysql.line.LimitRateService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2022/10/19 9:58【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@Api(tags = "监测点数据超限处理limitRate")
@RestController
@RequestMapping("limitrate")
@RequiredArgsConstructor
public class LimitrateController extends BaseController {
private final LimitRateService limitRateService;
private final CommTerminalGeneralClient commTerminalGeneralClient;
/* @Deprecated
@ApiOperation("limitrate表定时任务")
@ApiImplicitParam(value = "limitRateHanlderParam",name = "limitRateHanlderParam",required = true)
@PostMapping("LimitRateHanlder")
@OperateInfo(info = LogEnum.BUSINESS_MEDIUM)
public HttpResult<Boolean> limitRateHanlder(@RequestBody LineParam limitRateHanlderParam ){
String methodDescribe = getMethodDescribe("limitRateHanlder");
Boolean result = true;
List<String> indexLists = new ArrayList<> ();
if(CollectionUtils.isEmpty (limitRateHanlderParam.getLineIds ())){
indexLists = lineFeignClient.getLineList ( ).getData ( );
}else{
indexLists = limitRateHanlderParam.getLineIds ();
}
String startTime = limitRateHanlderParam.getDataDate ()+" "+"00:00:00";
String endTime = limitRateHanlderParam.getDataDate ()+" "+"23:59:59";
limitRateService.limitRateJobHandler (indexLists,startTime,endTime);
if (result){
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, true, methodDescribe);
} else {
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.FAIL, false, methodDescribe);
}
}*/
@ApiOperation("生成limitRate表(MySQL入库)")
@ApiImplicitParam(value = "jobParam",name = "jobParam",required = true)
@PostMapping("LimitRate")
@OperateInfo(info = LogEnum.BUSINESS_MEDIUM)
public HttpResult<Boolean> limitRate(@RequestBody LineParam jobParam){
log.info(LocalDateTime.now()+"limitRate开始执行");
String startTime,endTime;
String methodDescribe = getMethodDescribe("limitRate");
List<String> indexLists;
if(CollectionUtils.isEmpty (jobParam.getLineIds ())){
indexLists = commTerminalGeneralClient.getRunMonitorIds ().getData ( );
}else{
indexLists = jobParam.getLineIds ();
}
if (jobParam.getRepairFlag()){
List<String> timeRange = NjcnDateUtils.findEveryDay(jobParam.getBeginTime(),jobParam.getEndTime());
for (String item : timeRange) {
log.info(item+"-->开始执行");
startTime = item+" "+"00:00:00";
endTime = item+" "+"23:59:59";
// limitRateService.limitRate(indexLists,startTime,endTime);
}
} else {
// limitRateService.limitRate(indexLists,jobParam.getBeginTime(),jobParam.getEndTime());
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, true, methodDescribe);
}
}

75
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/line/OnlineRateController.java
View File

@@ -1,75 +0,0 @@
package com.njcn.prepare.harmonic.controller.line;
import com.njcn.common.pojo.annotation.OperateInfo;
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.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.line.OnlineRateService;
import com.njcn.prepare.harmonic.utils.PublicUtil;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
/**
* 生成在线率数据表
*
* @author xiaoyao
* @version 1.0.0
* @createTime 2022/10/27 9:17
*/
@Slf4j
@Api(tags = "生成在线率数据表")
@RestController
@RequestMapping("/onlineRate")
@RequiredArgsConstructor
public class OnlineRateController extends BaseController {
private final OnlineRateService onlineRateService;
@Deprecated
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/getOnlineRateData")
@ApiOperation("生成在线率数据")
@ApiImplicitParam(name = "lineParam", value = "参数", required = true)
public HttpResult<String> getOnlineRateData(@RequestBody @Validated LineParam lineParam){
String methodDescribe = getMethodDescribe("getOnlineRateData");
onlineRateService.getOnlineRateData(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/onlineRateData")
@ApiOperation("生成在线率数据(MySQL入库)")
@ApiImplicitParam(name = "lineParam", value = "参数", required = true)
public HttpResult<String> onlineRateData(@RequestBody @Validated LineParam lineParam){
log.info(LocalDateTime.now()+"onlineRateData开始执行");
String methodDescribe = getMethodDescribe("onlineRateData");
if (lineParam.getType() == 3){
int year = Integer.parseInt(lineParam.getDataDate().split("-")[0]);
int month = Integer.parseInt(lineParam.getDataDate().split("-")[1]);
List<String> dayList = PublicUtil.getDayByMonth(year,month);
for (String item : dayList) {
log.info(item+"-->开始执行");
onlineRateService.onlineRateData(lineParam,item);
}
} else {
onlineRateService.onlineRateData(lineParam,lineParam.getDataDate());
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

66
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/line/PollutionController.java
View File

@@ -1,66 +0,0 @@
package com.njcn.prepare.harmonic.controller.line;
import com.njcn.common.pojo.annotation.OperateInfo;
import com.njcn.common.pojo.constant.BizParamConstant;
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.common.utils.NjcnDateUtils;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.line.PollutionService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* 监测点污染指标
*
* @author xiaoyao
* @version 1.0.0
* @createTime 2022/10/18 8:54
*/
@Slf4j
@Api(tags = "监测点污染指标")
@RestController
@RequestMapping("/pollution")
@RequiredArgsConstructor
@Deprecated
public class PollutionController extends BaseController {
private final PollutionService pollutionService;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/processPollutionData")
@ApiOperation("处理监测点污染指标")
@ApiImplicitParam(name = "jobParam", value = "参数", required = true)
public HttpResult<String> processPollutionData(@RequestBody @Validated LineParam jobParam){
String methodDescribe = getMethodDescribe("processPollutionData");
if (jobParam.getRepairFlag()&&Integer.valueOf(BizParamConstant.STAT_BIZ_DAY).equals(jobParam.getType())){
List<String> timeRange = NjcnDateUtils.findEveryDay(jobParam.getBeginTime(),jobParam.getEndTime());
for (String item : timeRange) {
log.info(item+"-->开始执行");
jobParam.setBeginTime(item+" "+"00:00:00");
jobParam.setEndTime(item+" "+"23:59:59");
System.out.println(jobParam);
pollutionService.processPollutionData(jobParam);
}
} else {
pollutionService.processPollutionData(jobParam);
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

79
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/RAlarmCountController.java
View File

@@ -1,79 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
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.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.DeptGetChildrenMoreDTO;
import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.service.mysql.newalgorithm.RAlarmCountService;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2022/12/28 13:47【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@Api(tags = "指标告警统计")
@RestController
@RequestMapping("/rAlarmCount")
@RequiredArgsConstructor
public class RAlarmCountController extends BaseController {
private final RAlarmCountService rAlarmCountService;
private final CommTerminalGeneralClient commTerminalGeneralClient;
private final DeptFeignClient deptFeignClient;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/rAlarmCountHandler")
@ApiOperation("指标告警统计")
@ApiImplicitParam(name = "orgParam", value = "参数", required = true)
public HttpResult<String> rAlarmCountHandler(@RequestBody @Validated OrgParam orgParam) {
log.info(LocalDateTime.now() + "rAlarmCountHandler开始执行");
String methodDescribe = getMethodDescribe("rAlarmCountHandler");
/**
* 支持补录
*/
DeptGetLineParam deptGetLineParam = new DeptGetLineParam();
if (StringUtils.isEmpty(orgParam.getOrgId())) {
Dept data = deptFeignClient.getRootDept().getData();
deptGetLineParam.setDeptId(data.getId());
} else {
deptGetLineParam.setDeptId(orgParam.getOrgId());
}
deptGetLineParam.setServerName(ServerInfo.PREPARE_BOOT);
List<DeptGetChildrenMoreDTO> data = commTerminalGeneralClient.deptGetLine(deptGetLineParam).getData();
rAlarmCountService.handler(data,orgParam.getDataDate(),orgParam.getType());
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

71
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/RMStatAbnormalDController.java
View File

@@ -1,71 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
import com.njcn.common.pojo.annotation.OperateInfo;
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.common.utils.NjcnDateUtils;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.pq.api.LineFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.line.RStatAbnormalDService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2023/4/19 15:45【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@RestController
@RequestMapping("/rmstatabnormal")
@Api(tags = "监测点异常_日统计")
@AllArgsConstructor
public class RMStatAbnormalDController extends BaseController {
private final CommTerminalGeneralClient commTerminalGeneralClient;
private final RStatAbnormalDService rStatAbnormalDService;
@ApiOperation("监测点异常_日统计(MySQL库)")
@ApiImplicitParam(value = "jobParam",name = "jobParam",required = true)
@PostMapping("handlerMonitorAbnormal")
@OperateInfo(info = LogEnum.BUSINESS_MEDIUM)
public HttpResult<Boolean> handlerMonitorAbnormal(@RequestBody LineParam jobParam ){
log.info(LocalDateTime.now()+"handlerMonitorAbnormal开始执行");
String methodDescribe = getMethodDescribe("handlerMonitorAbnormal");
List<String> indexLists;
if (CollectionUtils.isEmpty(jobParam.getLineIds())) {
indexLists = commTerminalGeneralClient.getRunMonitorIds().getData();
} else {
indexLists = jobParam.getLineIds();
}
if (jobParam.getRepairFlag()){
List<String> timeRange = NjcnDateUtils.findEveryDay(jobParam.getBeginTime(),jobParam.getEndTime());
for (String item : timeRange) {
log.info(item+"-->开始执行");
rStatAbnormalDService.handlerMonitorAbnormal(indexLists,item);
}
} else {
rStatAbnormalDService.handlerMonitorAbnormal (indexLists,jobParam.getBeginTime());
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, true, methodDescribe);
}
}

107
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/RMpDevEvaluateDetailController.java
View File

@@ -1,107 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
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.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.common.utils.NjcnDateUtils;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.DeptGetDeviceDTO;
import com.njcn.device.biz.pojo.dto.LineDevGetDTO;
import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.prepare.harmonic.pojo.param.DeviceParam;
import com.njcn.prepare.harmonic.service.mysql.area.RMpDevEvaluateDetailPOService;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2022/12/28 13:47【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@Api(tags = "终端数据评价")
@RestController
@RequestMapping("/rMpDevEvaluateDetail")
@RequiredArgsConstructor
public class RMpDevEvaluateDetailController extends BaseController {
private final RMpDevEvaluateDetailPOService rMpDevEvaluateDetailPOService;
private final DeptFeignClient deptFeignClient;
private final CommTerminalGeneralClient commTerminalGeneralClient;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/handler")
@ApiOperation("终端数据评价_日统计")
@ApiImplicitParam(name = "deviceParam", value = "参数", required = true)
public HttpResult<String> handler(@RequestBody @Validated DeviceParam deviceParam) {
log.info(LocalDateTime.now() + "handler始执行");
String methodDescribe = getMethodDescribe("handler");
/**
* 支持补录
*/
if (CollectionUtils.isEmpty(deviceParam.getDetailList())) {
List<DeviceParam.DeviceDetail> list = new ArrayList<>();
Dept data = deptFeignClient.getRootDept().getData();
DeptGetLineParam deptGetLineParam = new DeptGetLineParam();
deptGetLineParam.setDeptId(data.getId());
deptGetLineParam.setServerName(ServerInfo.PREPARE_BOOT);
List<DeptGetDeviceDTO> data1 = commTerminalGeneralClient.deptGetDeviceAndMonitor(deptGetLineParam).getData();
List<LineDevGetDTO> info = new ArrayList<>();
/*主网*/
List<LineDevGetDTO> collect = data1.stream().map(DeptGetDeviceDTO::getDeviceList).flatMap(Collection::stream).collect(Collectors.toList());
/*配网*/
List<LineDevGetDTO> collect2 = data1.stream().map(DeptGetDeviceDTO::getPwDeviceList).flatMap(Collection::stream).collect(Collectors.toList());
info.addAll(collect);
info.addAll(collect2);
List<LineDevGetDTO> collect1 = info.stream().distinct().collect(Collectors.toList());
collect1.forEach(temp -> {
DeviceParam.DeviceDetail deviceDetail = new DeviceParam.DeviceDetail();
deviceDetail.setDevId(temp.getDevId());
deviceDetail.setLineIds(temp.getMonitorIds());
deviceDetail.setUpdateTime(temp.getUpdateTime() + "");
deviceDetail.setDeviceStatus(temp.getComFlag() + "");
list.add(deviceDetail);
});
deviceParam.setDetailList(list);
}
if (deviceParam.getRepairFlag()) {
List<String> timeRange = NjcnDateUtils.findEveryDay(deviceParam.getBeginTime(), deviceParam.getEndTime());
for (String item : timeRange) {
log.info(item + "-->开始执行");
deviceParam.setDataDate(item);
deviceParam.setBeginTime(item + " " + "00:00:00");
deviceParam.setEndTime(item + " " + "23:59:59");
// rMpDevEvaluateDetailPOService.handler(deviceParam);
}
} else {
// rMpDevEvaluateDetailPOService.handler(deviceParam);
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

72
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/RMpEventdetailController.java
View File

@@ -1,72 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
import com.njcn.common.pojo.annotation.OperateInfo;
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.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.pq.api.LineFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.line.RMpEventDetailService;
import com.njcn.web.controller.BaseController;
import com.yomahub.liteflow.annotation.LiteflowComponent;
import com.yomahub.liteflow.core.FlowExecutor;
import com.yomahub.liteflow.flow.LiteflowResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2022/12/28 13:47【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@Api(tags = "监测点暂态指标超标明细")
@RestController
@RequestMapping("/rmpeventdetail")
@RequiredArgsConstructor
public class RMpEventdetailController extends BaseController {
private final CommTerminalGeneralClient commTerminalGeneralClient;
private final RMpEventDetailService rMpEventDetailService;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/eventdetailHandler")
@ApiOperation("监测点暂态指标处理")
@ApiImplicitParam(name = "lineParam", value = "参数", required = true)
public HttpResult<String> eventdetailHandler(@RequestBody @Validated LineParam lineParam) {
log.info(LocalDateTime.now() + "eventdetailHandler始执行");
String methodDescribe = getMethodDescribe("eventdetailHandler");
List<String> indexLists;
if (CollectionUtils.isEmpty(lineParam.getLineIds())) {
indexLists = commTerminalGeneralClient.getRunMonitorIds().getData();
} else {
indexLists = lineParam.getLineIds();
}
lineParam.setLineIds(indexLists);
rMpEventDetailService.eventdetailHandler(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

73
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/RMpMonitorEvaluateDController.java
View File

@@ -1,73 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
import com.njcn.common.pojo.annotation.OperateInfo;
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.common.utils.NjcnDateUtils;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.line.RMpMonitorEvaluateDService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2023/4/19 15:45【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@RestController
@RequestMapping("/rmpmonitorevaluate")
@Api(tags = "监测点评价_日统计")
@AllArgsConstructor
public class RMpMonitorEvaluateDController extends BaseController {
private final CommTerminalGeneralClient commTerminalGeneralClient;
private final RMpMonitorEvaluateDService rMpMonitorEvaluateDService;
@ApiOperation("监测点评价_日统计(MySQL库)")
@ApiImplicitParam(value = "jobParam", name = "jobParam", required = true)
@PostMapping("handlerMonitorEvaluate")
@OperateInfo(info = LogEnum.BUSINESS_MEDIUM)
public HttpResult<Boolean> handlerMonitorEvaluate(@RequestBody LineParam jobParam) {
log.info(LocalDateTime.now() + "handlerMonitorEvaluate开始执行");
String methodDescribe = getMethodDescribe("handlerMonitorEvaluate");
String startTime,endTime;
List<String> indexLists;
if (CollectionUtils.isEmpty(jobParam.getLineIds())) {
indexLists = commTerminalGeneralClient.getRunMonitorIds().getData();
} else {
indexLists = jobParam.getLineIds();
}
if (jobParam.getRepairFlag()){
List<String> timeRange = NjcnDateUtils.findEveryDay(jobParam.getBeginTime(),jobParam.getEndTime());
for (String item : timeRange) {
log.info(item+"-->开始执行");
startTime = item+" "+"00:00:00";
endTime = item+" "+"23:59:59";
rMpMonitorEvaluateDService.dayDataJobHandler(indexLists,startTime, endTime);
}
} else {
rMpMonitorEvaluateDService.dayDataJobHandler(indexLists, jobParam.getBeginTime(), jobParam.getEndTime());
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, true, methodDescribe);
}
}

67
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/RMpPassRateController.java
View File

@@ -1,67 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
import com.njcn.common.pojo.annotation.OperateInfo;
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.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.pq.api.LineFeignClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.line.RMpPassRateDService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2022/12/28 13:47【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@Api(tags = "监测点稳态指标合格率统计")
@RestController
@RequestMapping("/rmppassrate")
@RequiredArgsConstructor
public class RMpPassRateController extends BaseController {
private final LineFeignClient lineFeignClient;
private final RMpPassRateDService rMpPassRateDService;
private final CommTerminalGeneralClient commTerminalGeneralClient;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/passRateHandler")
@ApiOperation("监测点稳态指标合格率统计")
@ApiImplicitParam(name = "lineParam", value = "参数", required = true)
public HttpResult<String> passRateHandler(@RequestBody @Validated LineParam lineParam){
log.info(LocalDateTime.now()+"passRateHandler始执行");
String methodDescribe = getMethodDescribe("passRateHandler");
List<String> indexLists = new ArrayList<> ();
if(CollectionUtils.isEmpty (lineParam.getLineIds ())){
indexLists = commTerminalGeneralClient.getRunMonitorIds ().getData ();
}else{
indexLists = lineParam.getLineIds ();
}
lineParam.setLineIds (indexLists);
rMpPassRateDService.passRateHandler(lineParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

88
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/ROperatingMonitorController.java
View File

@@ -1,88 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
import com.njcn.common.pojo.annotation.OperateInfo;
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.common.utils.NjcnDateUtils;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.prepare.harmonic.pojo.param.LineParam;
import com.njcn.prepare.harmonic.service.mysql.line.ROperatingMonitorMService;
import com.njcn.prepare.harmonic.service.mysql.line.ROperatingMonitorService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2023/4/19 15:45【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@RestController
@RequestMapping("/roperatingmonitor")
@Api(tags = "监测点数据质量")
@AllArgsConstructor
public class ROperatingMonitorController extends BaseController {
private final CommTerminalGeneralClient commTerminalGeneralClient;
private final ROperatingMonitorService rOperatingMonitorService;
private final ROperatingMonitorMService rOperatingMonitorMService;
@ApiOperation("监测点数据质量_日统计(MySQL库)")
@ApiImplicitParam(value = "jobParam", name = "jobParam", required = true)
@PostMapping("handlerMonitorOperatingD")
@OperateInfo(info = LogEnum.BUSINESS_MEDIUM)
public HttpResult<Boolean> handlerMonitorOperatingD(@RequestBody LineParam jobParam) {
log.info(LocalDateTime.now() + "handlerMonitorOperatingD开始执行");
String methodDescribe = getMethodDescribe("handlerMonitorOperatingD");
List<String> indexLists;
if (CollectionUtils.isEmpty(jobParam.getLineIds())) {
indexLists = commTerminalGeneralClient.getRunMonitorIds().getData();
} else {
indexLists = jobParam.getLineIds();
}
if (jobParam.getRepairFlag()) {
List<String> timeRange = NjcnDateUtils.findEveryDay(jobParam.getBeginTime(), jobParam.getEndTime());
for (String item : timeRange) {
log.info(item + "-->开始执行");
rOperatingMonitorService.handlerMonitorOperatingD(indexLists, item);
}
} else {
rOperatingMonitorService.handlerMonitorOperatingD(indexLists, jobParam.getDataDate());
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, true, methodDescribe);
}
@ApiOperation("监测点数据质量_月统计(MySQL库)")
@ApiImplicitParam(value = "jobParam", name = "jobParam", required = true)
@PostMapping("handlerMonitorOperatingM")
@OperateInfo(info = LogEnum.BUSINESS_MEDIUM)
public HttpResult<Boolean> handlerMonitorOperatingM(@RequestBody LineParam jobParam) {
log.info(LocalDateTime.now() + "handlerMonitorOperatingM开始执行");
String methodDescribe = getMethodDescribe("handlerMonitorOperatingM");
List<String> indexLists;
if (CollectionUtils.isEmpty(jobParam.getLineIds())) {
indexLists = commTerminalGeneralClient.getRunMonitorIds().getData();
} else {
indexLists = jobParam.getLineIds();
}
rOperatingMonitorMService.handlerMonitorOperatingM(indexLists,jobParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, true, methodDescribe);
}
}

108
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/RStatDevSignalController.java
View File

@@ -1,108 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
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.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.common.utils.NjcnDateUtils;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.DeptGetDeviceDTO;
import com.njcn.device.biz.pojo.dto.LineDevGetDTO;
import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.prepare.harmonic.pojo.param.DeviceParam;
import com.njcn.prepare.harmonic.service.mysql.device.RStatDevSignalDPOService;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2022/12/28 13:47【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@Api(tags = "终端通信管理")
@RestController
@RequestMapping("/rstatdevsignal")
@RequiredArgsConstructor
public class RStatDevSignalController extends BaseController {
private final RStatDevSignalDPOService rStatDevSignalDPOService;
private final CommTerminalGeneralClient commTerminalGeneralClient;
private final DeptFeignClient deptFeignClient;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/rstatdevsignalHandler")
@ApiOperation("终端通信管理_日统计")
@ApiImplicitParam(name = "deviceParam", value = "参数", required = true)
public HttpResult<String> rstatdevsignalHandler(@RequestBody @Validated DeviceParam deviceParam) {
log.info(LocalDateTime.now() + "rstatdevsignalHandler始执行");
String methodDescribe = getMethodDescribe("rstatdevsignalHandler");
/**
* 支持补录
*/
if (CollectionUtils.isEmpty(deviceParam.getDetailList())) {
List<DeviceParam.DeviceDetail> list = new ArrayList<>();
Dept data = deptFeignClient.getRootDept().getData();
DeptGetLineParam deptGetLineParam = new DeptGetLineParam();
deptGetLineParam.setDeptId(data.getId());
deptGetLineParam.setServerName(ServerInfo.PREPARE_BOOT);
List<DeptGetDeviceDTO> data1 = commTerminalGeneralClient.deptGetDeviceAndMonitor(deptGetLineParam).getData();
List<LineDevGetDTO> info=new ArrayList<>();
/*主网*/
List<LineDevGetDTO> collect = data1.stream().map(DeptGetDeviceDTO::getDeviceList).flatMap(Collection::stream).collect(Collectors.toList());
/*配网*/
List<LineDevGetDTO> collect2 = data1.stream().map(DeptGetDeviceDTO::getPwDeviceList).flatMap(Collection::stream).collect(Collectors.toList());
info.addAll(collect);
info.addAll(collect2);
List<LineDevGetDTO> collect1 = info.stream().distinct().collect(Collectors.toList());
collect1.forEach(temp -> {
DeviceParam.DeviceDetail deviceDetail = new DeviceParam.DeviceDetail();
deviceDetail.setDevId(temp.getDevId());
deviceDetail.setLineIds(temp.getMonitorIds());
deviceDetail.setUpdateTime(temp.getUpdateTime() + "");
deviceDetail.setDeviceStatus(temp.getComFlag()+ "");
list.add(deviceDetail);
});
deviceParam.setDetailList(list);
}
if (deviceParam.getRepairFlag()) {
List<String> timeRange = NjcnDateUtils.findEveryDay(deviceParam.getBeginTime(), deviceParam.getEndTime());
for (String item : timeRange) {
log.info(item + "-->开始执行");
deviceParam.setDataDate(item);
deviceParam.setBeginTime(item + " " + "00:00:00");
deviceParam.setEndTime(item + " " + "23:59:59");
// rStatDevSignalDPOService.eventdetailHandler(deviceParam);
}
} else {
// rStatDevSignalDPOService.eventdetailHandler(deviceParam);
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

79
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/RStatEventController.java
View File

@@ -1,79 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
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.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.DeptGetChildrenMoreDTO;
import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.service.mysql.newalgorithm.RStatEventService;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2022/12/28 13:47【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@Api(tags = "暂态指标统计")
@RestController
@RequestMapping("/rStartEvent")
@RequiredArgsConstructor
public class RStatEventController extends BaseController {
private final RStatEventService rStatEventDService;
private final CommTerminalGeneralClient commTerminalGeneralClient;
private final DeptFeignClient deptFeignClient;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/rStartEventHandler")
@ApiOperation("暂态指标统计")
@ApiImplicitParam(name = "orgParam", value = "参数", required = true)
public HttpResult<String> rStartEventHandler(@RequestBody @Validated OrgParam orgParam) {
log.info(LocalDateTime.now() + "rStartEventHandler开始执行");
String methodDescribe = getMethodDescribe("rStartEventHandler");
/**
* 支持补录
*/
DeptGetLineParam deptGetLineParam = new DeptGetLineParam();
if (StringUtils.isEmpty(orgParam.getOrgId())) {
Dept data = deptFeignClient.getRootDept().getData();
deptGetLineParam.setDeptId(data.getId());
} else {
deptGetLineParam.setDeptId(orgParam.getOrgId());
}
deptGetLineParam.setServerName(ServerInfo.PREPARE_BOOT);
List<DeptGetChildrenMoreDTO> data = commTerminalGeneralClient.deptGetLine(deptGetLineParam).getData();
rStatEventDService.handler(data,orgParam.getDataDate(),orgParam.getType());
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

79
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/RStatEventOrgController.java
View File

@@ -1,79 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
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.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.DeptGetChildrenMoreDTO;
import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.service.mysql.newalgorithm.RStatEventOrgService;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2022/12/28 13:47【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@Api(tags = "单位暂态指标数据统计")
@RestController
@RequestMapping("/rStartEventOrg")
@RequiredArgsConstructor
public class RStatEventOrgController extends BaseController {
private final RStatEventOrgService rStatEventOrgService;
private final CommTerminalGeneralClient commTerminalGeneralClient;
private final DeptFeignClient deptFeignClient;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/rStartEventOrgHandler")
@ApiOperation("单位暂态指标数据统计")
@ApiImplicitParam(name = "orgParam", value = "参数", required = true)
public HttpResult<String> rStartEventOrgHandler(@RequestBody @Validated OrgParam orgParam) {
log.info(LocalDateTime.now() + "rStartEventOrgHandler开始执行");
String methodDescribe = getMethodDescribe("rStartEventOrgHandler");
/**
* 支持补录
*/
DeptGetLineParam deptGetLineParam = new DeptGetLineParam();
if (StringUtils.isEmpty(orgParam.getOrgId())) {
Dept data = deptFeignClient.getRootDept().getData();
deptGetLineParam.setDeptId(data.getId());
} else {
deptGetLineParam.setDeptId(orgParam.getOrgId());
}
deptGetLineParam.setServerName(ServerInfo.PREPARE_BOOT);
List<DeptGetChildrenMoreDTO> data = commTerminalGeneralClient.deptGetLine(deptGetLineParam).getData();
rStatEventOrgService.handler(data,orgParam.getDataDate(),orgParam.getType());
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

75
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/RStatHarmonicController.java
View File

@@ -1,75 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
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.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.DeptGetChildrenMoreDTO;
import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.service.mysql.area.RStatHarmonicService;
import com.njcn.prepare.harmonic.service.mysql.area.RStatOrgService;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2022/12/28 13:47【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@Api(tags = "单位监测点稳态指标统计")
@RestController
@RequestMapping("/rstatharmonic")
@RequiredArgsConstructor
public class RStatHarmonicController extends BaseController {
private final RStatHarmonicService service;
private final CommTerminalGeneralClient commTerminalGeneralClient;
private final DeptFeignClient deptFeignClient;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/Handler")
@ApiOperation("单位监测点稳态指标统计")
@ApiImplicitParam(name = "orgParam", value = "参数", required = true)
public HttpResult<String> handler(@RequestBody @Validated OrgParam orgParam ){
log.info(LocalDateTime.now()+"dayHandler始执行");
String methodDescribe = getMethodDescribe("dayHandler");
/**
* 支持补录
*/
DeptGetLineParam deptGetLineParam = new DeptGetLineParam();
if(StringUtils.isEmpty(orgParam.getOrgId())){
Dept data = deptFeignClient.getRootDept().getData();
deptGetLineParam.setDeptId(data.getId());
}else {
deptGetLineParam.setDeptId(orgParam.getOrgId());
}
deptGetLineParam.setServerName(ServerInfo.PREPARE_BOOT);
List<DeptGetChildrenMoreDTO> data = commTerminalGeneralClient.deptGetLine(deptGetLineParam).getData();
service.handler (data,orgParam.getDataDate(),orgParam.getType());
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

72
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/RStatHarmonicOrgController.java
View File

@@ -1,72 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
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.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.DeptGetChildrenMoreDTO;
import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.service.mysql.area.RStatHarmonicOrgService;
import com.njcn.prepare.harmonic.service.mysql.area.RStatHarmonicService;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept;
import com.njcn.user.pojo.vo.PvTerminalTreeVO;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2022/12/28 13:47【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@Api(tags = "单位稳态指标数据统计(xy)")
@RestController
@RequestMapping("/rstatharmonicorg")
@RequiredArgsConstructor
public class RStatHarmonicOrgController extends BaseController {
private final RStatHarmonicOrgService service;
private final DeptFeignClient deptFeignClient;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/Handler")
@ApiOperation("单位监测点稳态指标统计")
@ApiImplicitParam(name = "orgParam", value = "参数", required = true)
public HttpResult<String> handler(@RequestBody @Validated OrgParam orgParam ){
log.info(LocalDateTime.now()+"dayHandler始执行");
String methodDescribe = getMethodDescribe("dayHandler");
/**
* 支持补录
*/
DeptGetLineParam deptGetLineParam = new DeptGetLineParam();
if(StringUtils.isEmpty(orgParam.getOrgId())){
Dept data = deptFeignClient.getRootDept().getData();
orgParam.setOrgId(data.getId());
}
service.handler(orgParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

83
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/RStatOrgController.java
View File

@@ -1,83 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
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.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.DeptGetChildrenMoreDTO;
import com.njcn.device.biz.pojo.dto.DeptGetDeviceDTO;
import com.njcn.device.biz.pojo.dto.LineDevGetDTO;
import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.prepare.harmonic.pojo.param.DeviceParam;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.service.mysql.area.RStatOrgService;
import com.njcn.prepare.harmonic.service.mysql.device.RStatDevSignalDPOService;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2022/12/28 13:47【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@Api(tags = "单位监测点统计")
@RestController
@RequestMapping("/rstatorg")
@RequiredArgsConstructor
public class RStatOrgController extends BaseController {
private final RStatOrgService rStatOrgService;
private final CommTerminalGeneralClient commTerminalGeneralClient;
private final DeptFeignClient deptFeignClient;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/Handler")
@ApiOperation("单位监测点_统计")
@ApiImplicitParam(name = "orgParam", value = "参数", required = true)
public HttpResult<String> handler(@RequestBody @Validated OrgParam orgParam ){
log.info(LocalDateTime.now()+"dayHandler始执行");
String methodDescribe = getMethodDescribe("handler");
/**
* 支持补录
*/
DeptGetLineParam deptGetLineParam = new DeptGetLineParam();
if(StringUtils.isEmpty(orgParam.getOrgId())){
Dept data = deptFeignClient.getRootDept().getData();
deptGetLineParam.setDeptId(data.getId());
}else {
deptGetLineParam.setDeptId(orgParam.getOrgId());
}
deptGetLineParam.setServerName(ServerInfo.PREPARE_BOOT);
List<DeptGetChildrenMoreDTO> data = commTerminalGeneralClient.deptGetLine(deptGetLineParam).getData();
rStatOrgService.handler (data,orgParam.getDataDate(),orgParam.getType());
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

84
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/newalgorithm/RStatSubstationController.java
View File

@@ -1,84 +0,0 @@
package com.njcn.prepare.harmonic.controller.newalgorithm;
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.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.DeptGetChildrenMoreDTO;
import com.njcn.device.biz.pojo.dto.DeptGetSubStationDTO;
import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.service.mysql.newalgorithm.RStatEventOrgService;
import com.njcn.prepare.harmonic.service.mysql.newalgorithm.RStatSubstationService;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.util.List;
/**
* Description:
* 接口文档访问地址：http://serverIP:port/swagger-ui.html
* Date: 2022/12/28 13:47【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Slf4j
@Api(tags = "变电站指标统计")
@RestController
@RequestMapping("/rStartSubstation")
@RequiredArgsConstructor
public class RStatSubstationController extends BaseController {
private final RStatSubstationService rStatSubstationService;
private final CommTerminalGeneralClient commTerminalGeneralClient;
private final DeptFeignClient deptFeignClient;
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/rStartSubstationHandler")
@ApiOperation("变电站指标统计")
@ApiImplicitParam(name = "orgParam", value = "参数", required = true)
public HttpResult<String> rStartSubstationHandler(@RequestBody @Validated OrgParam orgParam) {
log.info(LocalDateTime.now() + "rStartSubstationHandler开始执行");
String methodDescribe = getMethodDescribe("rStartSubstationHandler");
/**
* 支持补录
*/
DeptGetLineParam deptGetLineParam = new DeptGetLineParam();
if (StringUtils.isEmpty(orgParam.getOrgId())) {
Dept data = deptFeignClient.getRootDept().getData();
deptGetLineParam.setDeptId(data.getId());
} else {
deptGetLineParam.setDeptId(orgParam.getOrgId());
}
deptGetLineParam.setServerName(ServerInfo.PREPARE_BOOT);
List<DeptGetSubStationDTO> data = commTerminalGeneralClient.deptSubStation(deptGetLineParam).getData();
long start = System.currentTimeMillis();
// rStatSubstationService.handler(data,orgParam.getDataDate(),orgParam.getType());
long end = System.currentTimeMillis();
System.out.println("该方法总耗时为 ---> "+(end-start));
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

2
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/area/PrimaryGridDataServiceImpl.java
View File

@@ -5,7 +5,6 @@ import cn.hutool.core.date.LocalDateTimeUtil;
import cn.hutool.core.util.StrUtil; import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.njcn.common.pojo.exception.BusinessException; import com.njcn.common.pojo.exception.BusinessException;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.LineDevGetDTO; import com.njcn.device.biz.pojo.dto.LineDevGetDTO;
import com.njcn.device.pms.pojo.po.Monitor; import com.njcn.device.pms.pojo.po.Monitor;
import com.njcn.harmonic.pojo.po.*; import com.njcn.harmonic.pojo.po.*;
@@ -79,7 +78,6 @@ public class PrimaryGridDataServiceImpl implements PrimaryGridDataService {
private final RedisUtil redisUtil; private final RedisUtil redisUtil;
private final CommTerminalGeneralClient commTerminalGeneralClient;

56
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/area/RMpDevEvaluateDetailPOServiceImpl.java
View File

@@ -10,7 +10,6 @@ import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.LineDevGetDTO; import com.njcn.device.biz.pojo.dto.LineDevGetDTO;
import com.njcn.harmonic.pojo.po.RMpDevEvaluateDetailPO; import com.njcn.harmonic.pojo.po.RMpDevEvaluateDetailPO;
import com.njcn.prepare.harmonic.mapper.mysql.area.RMpDevEvaluateDetailPOMapper; import com.njcn.prepare.harmonic.mapper.mysql.area.RMpDevEvaluateDetailPOMapper;
import com.njcn.prepare.harmonic.mapper.mysql.line.RMpMonitorEvaluateDMapper;
import com.njcn.prepare.harmonic.mapper.mysql.line.ROperatingMonitorDMapper; import com.njcn.prepare.harmonic.mapper.mysql.line.ROperatingMonitorDMapper;
import com.njcn.prepare.harmonic.pojo.bo.CalculatedParam; import com.njcn.prepare.harmonic.pojo.bo.CalculatedParam;
import com.njcn.prepare.harmonic.pojo.mysql.ROperatingMonitorDPO; import com.njcn.prepare.harmonic.pojo.mysql.ROperatingMonitorDPO;
@@ -18,15 +17,12 @@ import com.njcn.prepare.harmonic.pojo.po.RMpDevSolveDetailPO;
import com.njcn.prepare.harmonic.service.mysql.area.RMpDevEvaluateDetailPOService; import com.njcn.prepare.harmonic.service.mysql.area.RMpDevEvaluateDetailPOService;
import com.njcn.prepare.harmonic.service.mysql.device.RMpDevSolveDetailPOService; import com.njcn.prepare.harmonic.service.mysql.device.RMpDevSolveDetailPOService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.ListUtils; import org.apache.commons.collections4.ListUtils;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
@@ -50,60 +46,8 @@ public class RMpDevEvaluateDetailPOServiceImpl extends MppServiceImpl<RMpDevEval
private final ROperatingMonitorDMapper rOperatingMonitorDMapper; private final ROperatingMonitorDMapper rOperatingMonitorDMapper;
private final RMpDevSolveDetailPOService rMpDevSolveDetailPOService; private final RMpDevSolveDetailPOService rMpDevSolveDetailPOService;
private final DecimalFormat df = new DecimalFormat("#.00");
private final RMpMonitorEvaluateDMapper revaluateDMapper;
private final CommTerminalGeneralClient commTerminalGeneralClient; private final CommTerminalGeneralClient commTerminalGeneralClient;
// @Override
// @Transactional(rollbackFor = {Exception.class})
// @Async("asyncExecutor")
// @SneakyThrows
// public void handler(DeviceParam deviceParam) {
//
// List<RMpDevEvaluateDetailPO> rMpDevEvaluateDetailPOList = new ArrayList<>();
// Date date = DateUtil.parse(deviceParam.getDataDate());
// QueryWrapper<ROperatingMonitorDPO> wrapper = new QueryWrapper<>();
// QueryWrapper<RMpDevSolveDetailPO> wrapper1 = new QueryWrapper<>();
//
// deviceParam.getDetailList().forEach(temp -> {
//
// RMpDevEvaluateDetailPO rMpDevEvaluateDetailPO = new RMpDevEvaluateDetailPO();
// rMpDevEvaluateDetailPO.setDeviceId(temp.getDevId());
// rMpDevEvaluateDetailPO.setDataDate(date);
//
// wrapper.clear();
// wrapper1.clear();
// wrapper1.select(RMpDevSolveDetailPO.COL_DEFECT_SEVERITY).
// eq(RMpDevSolveDetailPO.COL_DEVICE_ID,temp.getDevId()).
// eq("DATE_FORMAT( data_date ,'%Y-%m-%d')",deviceParam.getDataDate());
// RMpDevSolveDetailPO one = rMpDevSolveDetailPOService.getOne(wrapper1);
// Double defectSeverity = PubUtils.getDefectSeverity(one.getDefectSeverity());
// rMpDevEvaluateDetailPO.setDevScore(Double.valueOf(df.format(defectSeverity/3)));
//
// List<ROperatingMonitorDPO> rOperatingMonitorDPOS = new ArrayList<>();
//
// List<String> lineIds = temp.getLineIds();
// if(CollUtil.isNotEmpty(lineIds)){
// wrapper.in("measurement_point_id", lineIds);
// rOperatingMonitorDPOS = rOperatingMonitorDMapper.selectList(wrapper);
// }
// double asDouble1=0.00 ,asDouble2=0.00,aDouble=0.00;
// if(rOperatingMonitorDPOS.size()>0){
// asDouble1= rOperatingMonitorDPOS.stream().mapToDouble(po -> po.getDataIntegrityRate().doubleValue()).average().getAsDouble();
// asDouble2 = rOperatingMonitorDPOS.stream().mapToDouble(po -> po.getIndexIntegrityRate().doubleValue()).average().getAsDouble();
// long count = rOperatingMonitorDPOS.stream().filter(po -> po.getIsUnusual() == 1 && po.getDataIntegrityRate().compareTo(new BigDecimal(0.95)) == 1).count();
// aDouble = Double.valueOf(count) / rOperatingMonitorDPOS.size();
// }
// rMpDevEvaluateDetailPO.setDevDataRate(Double.valueOf(df.format(asDouble1)));
// rMpDevEvaluateDetailPO.setDevTargetRate(Double.valueOf(df.format(asDouble2)));
// rMpDevEvaluateDetailPO.setDevEffectiveRate(Double.valueOf(df.format(aDouble)));
// rMpDevEvaluateDetailPOList.add(rMpDevEvaluateDetailPO);
//
// });
// this.saveOrUpdateBatchByMultiId(rMpDevEvaluateDetailPOList,500);
// }
@Override @Override
@Transactional(rollbackFor = {Exception.class}) @Transactional(rollbackFor = {Exception.class})

63
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/area/RMpMonitorAlarmCountMServiceImpl.java
View File

@@ -10,12 +10,10 @@ import com.njcn.prepare.harmonic.mapper.mysql.area.RMpMonitorAlarmCountMMapper;
import com.njcn.prepare.harmonic.mapper.mysql.area.RMpTargetWarnDMapper; import com.njcn.prepare.harmonic.mapper.mysql.area.RMpTargetWarnDMapper;
import com.njcn.prepare.harmonic.pojo.bo.CalculatedParam; import com.njcn.prepare.harmonic.pojo.bo.CalculatedParam;
import com.njcn.prepare.harmonic.service.mysql.area.IRMpMonitorAlarmCountMService; import com.njcn.prepare.harmonic.service.mysql.area.IRMpMonitorAlarmCountMService;
import com.njcn.prepare.harmonic.service.mysql.area.RMpTargetWarnDService;
import lombok.AllArgsConstructor; import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.ListUtils; import org.apache.commons.collections4.ListUtils;
import org.springframework.beans.BeanUtils; import org.springframework.beans.BeanUtils;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils; import org.springframework.util.CollectionUtils;
@@ -38,69 +36,8 @@ import java.util.stream.Collectors;
@Slf4j @Slf4j
public class RMpMonitorAlarmCountMServiceImpl extends MppServiceImpl<RMpMonitorAlarmCountMMapper, RMpMonitorAlarmCountMPO> implements IRMpMonitorAlarmCountMService { public class RMpMonitorAlarmCountMServiceImpl extends MppServiceImpl<RMpMonitorAlarmCountMMapper, RMpMonitorAlarmCountMPO> implements IRMpMonitorAlarmCountMService {
private final RMpTargetWarnDService rMpTargetWarnDService;
private final RMpTargetWarnDMapper rMpTargetWarnDMapper; private final RMpTargetWarnDMapper rMpTargetWarnDMapper;
// @Override
// public void alarmMonth(LineParam lineParam) {
// List<RMpMonitorAlarmCountMDTO> monthList = rMpTargetWarnDService.getDate(lineParam);
// if (!CollectionUtils.isEmpty(monthList)){
// List<RMpMonitorAlarmCountMPO> result = new ArrayList<>();
// List<RMpMonitorAlarmCountMDTO> harmonicList = new ArrayList<>(),eventList = new ArrayList<>();
// //判断稳态指标评级结果-根据稳态指标严重度之和排序(去除严重度为0的数据在作比较)
// List<RMpMonitorAlarmCountMDTO> list1 = monthList.stream().filter(item->item.getHarmonicTypeGradeTotal()>0).collect(Collectors.toList());
// List<RMpMonitorAlarmCountMDTO> list2 = monthList.stream().filter(item->item.getHarmonicTypeGradeTotal()<=0).collect(Collectors.toList());
// if (!CollectionUtils.isEmpty(list1)){
// for (int i = 0; i < list1.size(); i++) {
// if (i < list1.size()*0.3){
// list1.get(i).setHarmonicTypeGrade(0);
// } else if (i >= list1.size()*0.3 && i < list1.size()*0.7){
// list1.get(i).setHarmonicTypeGrade(1);
// } else {
// list1.get(i).setHarmonicTypeGrade(2);
// }
// harmonicList.add(list1.get(i));
// }
// }
// if (!CollectionUtils.isEmpty(list2)){
// list2.forEach(item->{
// item.setHarmonicTypeGrade(2);
// harmonicList.add(item);
// });
// }
// //判断暂态指标评级结果-根据暂态指标严重度之和排序(去除严重度为0的数据在作比较)
// List<RMpMonitorAlarmCountMDTO> list3 = harmonicList.stream().filter(item->item.getEventTypeGradeTotal()>0).collect(Collectors.toList());
// List<RMpMonitorAlarmCountMDTO> list4 = harmonicList.stream().filter(item->item.getEventTypeGradeTotal()<=0).collect(Collectors.toList());
// if (!CollectionUtils.isEmpty(list3)){
// for (int i = 0; i < list3.size(); i++) {
// if (i < list3.size()*0.3){
// list3.get(i).setEventTypeGrade(0);
// } else if (i >= list3.size()*0.3 && i < list3.size()*0.7){
// list3.get(i).setEventTypeGrade(1);
// } else {
// list3.get(i).setEventTypeGrade(2);
// }
// eventList.add(list3.get(i));
// }
// }
// if (!CollectionUtils.isEmpty(list4)){
// list4.forEach(item->{
// item.setEventTypeGrade(2);
// eventList.add(item);
// });
// }
// if (!CollectionUtils.isEmpty(eventList)){
// eventList.forEach(item->{
// RMpMonitorAlarmCountMPO rMpMonitorAlarmCountMpo = new RMpMonitorAlarmCountMPO();
// BeanUtils.copyProperties(item,rMpMonitorAlarmCountMpo);
// result.add(rMpMonitorAlarmCountMpo);
// });
// this.saveOrUpdateBatchByMultiId(result,50);
// }
// }
// }
@Override @Override
@Transactional(rollbackFor = {Exception.class}) @Transactional(rollbackFor = {Exception.class})
public void alarmMonth(CalculatedParam calculatedParam) { public void alarmMonth(CalculatedParam calculatedParam) {

66
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/area/RMpTargetWarnDServiceImpl.java
View File

@@ -2,9 +2,7 @@ package com.njcn.prepare.harmonic.service.mysql.Impl.area;
import cn.hutool.core.collection.CollectionUtil; import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.dynamic.datasource.annotation.DS; import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.jeffreyning.mybatisplus.service.MppServiceImpl; import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
import com.njcn.device.pq.api.LineFeignClient;
import com.njcn.harmonic.pojo.po.RMpTargetWarnDPO; import com.njcn.harmonic.pojo.po.RMpTargetWarnDPO;
import com.njcn.prepare.harmonic.mapper.mysql.area.RMpTargetWarnDMapper; import com.njcn.prepare.harmonic.mapper.mysql.area.RMpTargetWarnDMapper;
import com.njcn.prepare.harmonic.mapper.mysql.day.RStatDataVDMapper; import com.njcn.prepare.harmonic.mapper.mysql.day.RStatDataVDMapper;
@@ -17,8 +15,6 @@ import com.njcn.prepare.harmonic.utils.PublicUtil;
import lombok.AllArgsConstructor; import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.ListUtils; import org.apache.commons.collections4.ListUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils; import org.springframework.util.CollectionUtils;
@@ -42,41 +38,11 @@ import java.util.stream.Collectors;
public class RMpTargetWarnDServiceImpl extends MppServiceImpl<RMpTargetWarnDMapper, RMpTargetWarnDPO> implements RMpTargetWarnDService { public class RMpTargetWarnDServiceImpl extends MppServiceImpl<RMpTargetWarnDMapper, RMpTargetWarnDPO> implements RMpTargetWarnDService {
private @Autowired
RMpTargetWarnDMapper rMpTargetWarnDMapper;
private final AlarmDetailService alarmDetailService; private final AlarmDetailService alarmDetailService;
private final RStatDataVDMapper rStatDataVDMapper; private final RStatDataVDMapper rStatDataVDMapper;
private final LineFeignClient lineFeignClient;
/**
* @param monitorIdList
* @param dataDate
* @Description: 计算出当前机构累计稳态超标监测点数（当月）
* @Param: [monitorIdList, dataDate]
* @return: java.lang.Integer
* @Author: clam
* @Date: 2022/12/15
*/
@Override
public Integer queryHarmonicMeasurementAccrued(List<String> monitorIdList, String dataDate) {
Integer result = 0;
QueryWrapper<RMpTargetWarnDPO> wrapper = new QueryWrapper ( );
if(CollectionUtils.isEmpty (monitorIdList)){
return result;
}
wrapper.select ("distinct measurement_point_id ").
in ("measurement_point_id",monitorIdList).
eq("DATE_FORMAT( data_date ,'%Y-%m')",dataDate.substring (0, 7)).
eq ("is_harmonic",1);
result = rMpTargetWarnDMapper.selectCount (wrapper);
return result;
}
/*******************************************新算法***********************************************************************/
@Override @Override
@Transactional(rollbackFor = {Exception.class}) @Transactional(rollbackFor = {Exception.class})
public void alarmDay(CalculatedParam calculatedParam) { public void alarmDay(CalculatedParam calculatedParam) {
@@ -247,37 +213,5 @@ public class RMpTargetWarnDServiceImpl extends MppServiceImpl<RMpTargetWarnDMapp
return result; return result;
} }
/*******************************************新算法结束***********************************************************************/
// @Override
// public void alarmDay(LineParam lineParam) {
// List<RMpTargetWarnDPO> list = new ArrayList<>();
// //月处理
// if (Objects.equals(true,lineParam.getRepairFlag())){
//
// List<String> dayList = NjcnDateUtils.findEveryDay(lineParam.getBeginTime(),lineParam.getEndTime());
// for (String item : dayList) {
// log.info(item+"-->开始执行");
// List<RMpTargetWarnDPO> day = getData(item,lineParam.getLineIds());
// if (!CollectionUtils.isEmpty(day)){
// list.addAll(day);
// }
// }
// }
// //日处理
// else {
// list = getData(lineParam.getDataDate(),lineParam.getLineIds());
// }
// if (!CollectionUtils.isEmpty(list)){
// this.saveOrUpdateBatchByMultiId(list,50);
// }
// }
// @Override
// public List<RMpMonitorAlarmCountMDTO> getDate(LineParam lineParam) {
// return this.baseMapper.getDate(lineParam.getBeginTime(),lineParam.getEndTime(),lineParam.getLineIds());
// }
} }

394
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/area/RStatHarmonicOrgServiceImpl.java
View File

@@ -15,25 +15,18 @@ import com.njcn.prepare.harmonic.pojo.mysql.po.RStatHarmonicMPO;
import com.njcn.prepare.harmonic.pojo.mysql.po.RStatOrgQPO; import com.njcn.prepare.harmonic.pojo.mysql.po.RStatOrgQPO;
import com.njcn.prepare.harmonic.pojo.mysql.po.RStatOrgYPO; import com.njcn.prepare.harmonic.pojo.mysql.po.RStatOrgYPO;
import com.njcn.prepare.harmonic.pojo.param.OrgParam;
import com.njcn.prepare.harmonic.pojo.po.*; import com.njcn.prepare.harmonic.pojo.po.*;
import com.njcn.prepare.harmonic.service.mysql.area.RStatHarmonicOrgService; import com.njcn.prepare.harmonic.service.mysql.area.RStatHarmonicOrgService;
import com.njcn.prepare.harmonic.service.mysql.newalgorithm.RStatHarmonicOrgDPOService; import com.njcn.prepare.harmonic.service.mysql.newalgorithm.RStatHarmonicOrgDPOService;
import com.njcn.prepare.harmonic.service.mysql.newalgorithm.RStatHarmonicOrgMPOService; import com.njcn.prepare.harmonic.service.mysql.newalgorithm.RStatHarmonicOrgMPOService;
import com.njcn.prepare.harmonic.service.mysql.newalgorithm.RStatHarmonicOrgQPOService; import com.njcn.prepare.harmonic.service.mysql.newalgorithm.RStatHarmonicOrgQPOService;
import com.njcn.prepare.harmonic.service.mysql.newalgorithm.RStatHarmonicOrgYPOService; import com.njcn.prepare.harmonic.service.mysql.newalgorithm.RStatHarmonicOrgYPOService;
import com.njcn.prepare.harmonic.utils.PublicUtil;
import com.njcn.system.api.DicDataFeignClient; import com.njcn.system.api.DicDataFeignClient;
import com.njcn.system.enums.DicDataEnum; import com.njcn.system.enums.DicDataEnum;
import com.njcn.system.enums.DicDataTypeEnum; import com.njcn.system.enums.DicDataTypeEnum;
import com.njcn.system.pojo.po.DictData; import com.njcn.system.pojo.po.DictData;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils; import org.springframework.util.CollectionUtils;
import java.text.DecimalFormat; import java.text.DecimalFormat;
@@ -55,8 +48,6 @@ public class RStatHarmonicOrgServiceImpl implements RStatHarmonicOrgService {
private final private final
DicDataFeignClient dicDataFeignClient; DicDataFeignClient dicDataFeignClient;
private final DeptFeignClient deptFeignClient;
private final RStatOrgDMapper rStatOrgDMapper; private final RStatOrgDMapper rStatOrgDMapper;
private final RStatOrgQMapper rStatOrgQMapper; private final RStatOrgQMapper rStatOrgQMapper;
private final RStatOrgYMapper rStatOrgYMapper; private final RStatOrgYMapper rStatOrgYMapper;
@@ -428,390 +419,5 @@ public class RStatHarmonicOrgServiceImpl implements RStatHarmonicOrgService {
} }
} }
/**------------------------------------------------------------------------------------------------------------**/
@Override
public void handler(OrgParam orgParam) {
switch (orgParam.getType()) {
case 1:
this.hanlderYear (orgParam);
break;
case 2:
this.hanlderQtr (orgParam);
break;
case 3:
this.hanlderM (orgParam);
break;
case 5:
this.hanlderDay ( orgParam);
break;
default:
break;
}
}
@Transactional
@Async("asyncExecutor")
@SneakyThrows
private void hanlderYear(OrgParam orgParam) {
List<RStatHarmonicOrgYPO> rStatHarmonicOrgYPOList = new ArrayList<>();
List<String> data = deptFeignClient.getDepSonIdtByDeptId(orgParam.getOrgId()).getData();
Date date = DateUtil.parse(orgParam.getDataDate());
LocalDate localDate = LocalDateTimeUtil.parseDate(orgParam.getDataDate(), DatePattern.NORM_DATE_PATTERN);
QueryWrapper<RStatHarmonicMPO> queryWrapper = new QueryWrapper<>();
QueryWrapper<RStatOrgMPO> rStatOrgMPOQueryWrapper = new QueryWrapper<>();
/*获取稳态统计指标*/
List<DictData> steadyStatis = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
/*获取数据类型*/
List<DictData> dataTypeList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.DATA_TYPE.getCode()).getData();
Map<String, DictData> dataTypeMap = dataTypeList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
;
/*获取监测点类型类型*/
List<DictData> lineSortList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.LINE_SORT.getCode()).getData();
Map<String, DictData> lineSortMap = lineSortList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
data.stream().forEach(temp->{
int sumEffectiveMeasurement =0;
rStatOrgMPOQueryWrapper.clear();
rStatOrgMPOQueryWrapper.select("effective_measurement_accrued").
eq("org_no",temp).
eq("YEAR( data_date)", orgParam.getDataDate().substring(0,4));
List<RStatOrgMPO> rStatOrgMPOS = rStatOrgMMapper.selectList(rStatOrgMPOQueryWrapper);
if(CollectionUtils.isEmpty(rStatOrgMPOS)){
sumEffectiveMeasurement=0;
}else {
sumEffectiveMeasurement = rStatOrgMPOS.stream().mapToInt(RStatOrgMPO::getEffectiveMeasurementAccrued).sum();
}
int finalSumEffectiveMeasurement = sumEffectiveMeasurement;
dataTypeMap.forEach((k, v)->{
steadyStatis.forEach(dictData -> {
if (Objects.equals(dictData.getCode(), DicDataEnum.TOTAL_INDICATOR.getCode())) {
return;
}
queryWrapper.clear();
queryWrapper.eq("org_no",temp).
eq("harmonic_type",dictData.getId()).
eq("data_type",v.getId()).
eq("YEAR( data_date)", orgParam.getDataDate().substring(0,4));
List<RStatHarmonicMPO> rStatHarmonicMPOS = rStatHarmonicMPOMapper.selectList(queryWrapper);
Double overLimitMeasurementAverage =0.00;
int overDay =0;
int overLimitMeasurementAccrued=0;
Double averageOverDay =0.00;
Double overLimitMeasurementRatioAverage=0.00;
Double overLimitMeasurementRatioAccrued=0.00;
if(!CollectionUtils.isEmpty(rStatHarmonicMPOS)){
overDay = rStatHarmonicMPOS.stream().mapToInt(RStatHarmonicMPO::getOverDay).sum();
overLimitMeasurementAccrued = rStatHarmonicMPOS.stream().mapToInt(RStatHarmonicMPO::getOverLimitMeasurementAccrued).sum();
double asDouble = rStatHarmonicMPOS.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementAverage).average().getAsDouble();
overLimitMeasurementAverage = Double.parseDouble(df.format(asDouble));
double asDouble1 = rStatHarmonicMPOS.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementRatioAverage).average().getAsDouble();
overLimitMeasurementRatioAverage = Double.parseDouble(df.format(asDouble1));
if(finalSumEffectiveMeasurement ==0){
overLimitMeasurementRatioAccrued=0.00;
}else {
overLimitMeasurementRatioAccrued=Double.parseDouble(df.format((float)overLimitMeasurementAccrued / finalSumEffectiveMeasurement));
}
if(!(overLimitMeasurementAccrued==0)){
averageOverDay = Double.parseDouble(df.format((float)overDay / overLimitMeasurementAccrued));
}
}
RStatHarmonicOrgYPO rStatHarmonicOrgYPO = new RStatHarmonicOrgYPO();
rStatHarmonicOrgYPO.setOrgNo(temp);
rStatHarmonicOrgYPO.setDataDate(localDate);
rStatHarmonicOrgYPO.setHarmonicType(dictData.getId());
rStatHarmonicOrgYPO.setDataType(v.getId());
rStatHarmonicOrgYPO.setAverageOverDay(averageOverDay);
rStatHarmonicOrgYPO.setOverLimitMeasurementAccrued(overLimitMeasurementAccrued);
rStatHarmonicOrgYPO.setOverLimitMeasurementAverage(overLimitMeasurementAverage);
rStatHarmonicOrgYPO.setOverLimitMeasurementRatioAccrued(overLimitMeasurementRatioAccrued);
rStatHarmonicOrgYPO.setOverLimitMeasurementRatioAverage(overLimitMeasurementRatioAverage);
rStatHarmonicOrgYPOList.add(rStatHarmonicOrgYPO);
});
});
});
if(!CollectionUtils.isEmpty(rStatHarmonicOrgYPOList)){
rStatHarmonicYPOService.saveOrUpdateBatchByMultiId(rStatHarmonicOrgYPOList,500);
}
}
@Transactional
@Async("asyncExecutor")
@SneakyThrows
private void hanlderQtr(OrgParam orgParam) {
List<RStatHarmonicOrgQPO> rStatHarmonicOrgQPOList = new ArrayList<>();
List<String> data = deptFeignClient.getDepSonIdtByDeptId(orgParam.getOrgId()).getData();
Date date = DateUtil.parse(orgParam.getDataDate());
LocalDate localDate = LocalDateTimeUtil.parseDate(orgParam.getDataDate(), DatePattern.NORM_DATE_PATTERN);
QueryWrapper<RStatHarmonicMPO> queryWrapper = new QueryWrapper<>();
QueryWrapper<RStatOrgMPO> rStatOrgMPOQueryWrapper = new QueryWrapper<>();
/*获取稳态统计指标*/
List<DictData> steadyStatis = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
/*获取数据类型*/
List<DictData> dataTypeList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.DATA_TYPE.getCode()).getData();
Map<String, DictData> dataTypeMap = dataTypeList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
;
/*获取监测点类型类型*/
List<DictData> lineSortList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.LINE_SORT.getCode()).getData();
Map<String, DictData> lineSortMap = lineSortList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
data.stream().forEach(temp->{
int sumEffectiveMeasurement =0;
rStatOrgMPOQueryWrapper.clear();
rStatOrgMPOQueryWrapper.select("effective_measurement_accrued").
eq("org_no",temp).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (orgParam.getDataDate()));
List<RStatOrgMPO> rStatOrgMPOS = rStatOrgMMapper.selectList(rStatOrgMPOQueryWrapper);
if(CollectionUtils.isEmpty(rStatOrgMPOS)){
sumEffectiveMeasurement=0;
}else {
sumEffectiveMeasurement = rStatOrgMPOS.stream().mapToInt(RStatOrgMPO::getEffectiveMeasurementAccrued).sum();
}
int finalSumEffectiveMeasurement = sumEffectiveMeasurement;
dataTypeMap.forEach((k, v)->{
steadyStatis.forEach(dictData -> {
if (Objects.equals(dictData.getCode(), DicDataEnum.TOTAL_INDICATOR.getCode())) {
return;
}
queryWrapper.clear();
queryWrapper.eq("org_no",temp).
eq("harmonic_type",dictData.getId()).
eq("data_type",v.getId()).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (orgParam.getDataDate()));
List<RStatHarmonicMPO> rStatHarmonicMPOS = rStatHarmonicMPOMapper.selectList(queryWrapper);
Double overLimitMeasurementAverage =0.00;
int overDay =0;
int overLimitMeasurementAccrued=0;
Double averageOverDay =0.00;
Double overLimitMeasurementRatioAverage=0.00;
Double overLimitMeasurementRatioAccrued=0.00;
if(!CollectionUtils.isEmpty(rStatHarmonicMPOS)){
overDay = rStatHarmonicMPOS.stream().mapToInt(RStatHarmonicMPO::getOverDay).sum();
overLimitMeasurementAccrued = rStatHarmonicMPOS.stream().mapToInt(RStatHarmonicMPO::getOverLimitMeasurementAccrued).sum();
double asDouble = rStatHarmonicMPOS.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementAverage).average().getAsDouble();
overLimitMeasurementAverage = Double.parseDouble(df.format(asDouble));
double asDouble1 = rStatHarmonicMPOS.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementRatioAverage).average().getAsDouble();
overLimitMeasurementRatioAverage = Double.parseDouble(df.format(asDouble1));
if(finalSumEffectiveMeasurement ==0){
overLimitMeasurementRatioAccrued=0.00;
}else {
overLimitMeasurementRatioAccrued=Double.parseDouble(df.format((float)overLimitMeasurementAccrued / finalSumEffectiveMeasurement));
}
if(!(overLimitMeasurementAccrued==0)){
averageOverDay = Double.parseDouble(df.format((float)overDay / overLimitMeasurementAccrued));
}
}
RStatHarmonicOrgQPO rStatHarmonicOrgQPO = new RStatHarmonicOrgQPO();
rStatHarmonicOrgQPO.setOrgNo(temp);
rStatHarmonicOrgQPO.setDataDate(localDate);
rStatHarmonicOrgQPO.setHarmonicType(dictData.getId());
rStatHarmonicOrgQPO.setDataType(v.getId());
rStatHarmonicOrgQPO.setAverageOverDay(averageOverDay);
rStatHarmonicOrgQPO.setOverLimitMeasurementAccrued(overLimitMeasurementAccrued);
rStatHarmonicOrgQPO.setOverLimitMeasurementAverage(overLimitMeasurementAverage);
rStatHarmonicOrgQPO.setOverLimitMeasurementRatioAccrued(overLimitMeasurementRatioAccrued);
rStatHarmonicOrgQPO.setOverLimitMeasurementRatioAverage(overLimitMeasurementRatioAverage);
rStatHarmonicOrgQPOList.add(rStatHarmonicOrgQPO);
});
});
});
if(!CollectionUtils.isEmpty(rStatHarmonicOrgQPOList)){
rStatHarmonicQPOService.saveOrUpdateBatchByMultiId(rStatHarmonicOrgQPOList,500);
}
}
@Transactional
@Async("asyncExecutor")
@SneakyThrows
private void hanlderM(OrgParam orgParam) {
List<RStatHarmonicOrgMPO> rStatHarmonicOrgMPOList = new ArrayList<>();
List<String> data = deptFeignClient.getDepSonIdtByDeptId(orgParam.getOrgId()).getData();
Date date = DateUtil.parse(orgParam.getDataDate());
LocalDate localDate = LocalDateTimeUtil.parseDate(orgParam.getDataDate(), DatePattern.NORM_DATE_PATTERN);
QueryWrapper<RStatHarmonicMPO> queryWrapper = new QueryWrapper<>();
QueryWrapper<RStatOrgMPO> rStatOrgMPOQueryWrapper = new QueryWrapper<>();
/*获取稳态统计指标*/
List<DictData> steadyStatis = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
/*获取数据类型*/
List<DictData> dataTypeList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.DATA_TYPE.getCode()).getData();
Map<String, DictData> dataTypeMap = dataTypeList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
;
/*获取监测点类型类型*/
List<DictData> lineSortList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.LINE_SORT.getCode()).getData();
Map<String, DictData> lineSortMap = lineSortList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
data.stream().forEach(temp->{
int sumEffectiveMeasurement =0;
rStatOrgMPOQueryWrapper.clear();
rStatOrgMPOQueryWrapper.select("effective_measurement_accrued").
eq("org_no",temp).
eq("DATE_FORMAT( data_date ,'%Y-%m')",orgParam.getDataDate().substring(0, 7));
List<RStatOrgMPO> rStatOrgMPOS = rStatOrgMMapper.selectList(rStatOrgMPOQueryWrapper);
if(CollectionUtils.isEmpty(rStatOrgMPOS)){
sumEffectiveMeasurement=0;
}else {
sumEffectiveMeasurement = rStatOrgMPOS.stream().mapToInt(RStatOrgMPO::getEffectiveMeasurementAccrued).sum();
}
int finalSumEffectiveMeasurement = sumEffectiveMeasurement;
dataTypeMap.forEach((k, v)->{
steadyStatis.forEach(dictData -> {
if (Objects.equals(dictData.getCode(), DicDataEnum.TOTAL_INDICATOR.getCode())) {
return;
}
queryWrapper.clear();
queryWrapper.eq("org_no",temp).
eq("harmonic_type",dictData.getId()).
eq("data_type",v.getId()).
eq("DATE_FORMAT( data_date ,'%Y-%m')",orgParam.getDataDate().substring(0, 7));
List<RStatHarmonicMPO> rStatHarmonicMPOS = rStatHarmonicMPOMapper.selectList(queryWrapper);
Double overLimitMeasurementAverage =0.00;
int overDay =0;
int overLimitMeasurementAccrued=0;
Double overLimitMeasurementRatioAverage=0.00;
Double overLimitMeasurementRatioAccrued=0.00;
if(!CollectionUtils.isEmpty(rStatHarmonicMPOS)){
overDay = rStatHarmonicMPOS.stream().mapToInt(RStatHarmonicMPO::getOverDay).sum();
overLimitMeasurementAccrued = rStatHarmonicMPOS.stream().mapToInt(RStatHarmonicMPO::getOverLimitMeasurementAccrued).sum();
double asDouble = rStatHarmonicMPOS.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementAverage).average().getAsDouble();
overLimitMeasurementAverage = Double.parseDouble(df.format(asDouble));
double asDouble1 = rStatHarmonicMPOS.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementRatioAverage).average().getAsDouble();
overLimitMeasurementRatioAverage = Double.parseDouble(df.format(asDouble1));
if(finalSumEffectiveMeasurement ==0){
overLimitMeasurementRatioAccrued=0.00;
}else {
overLimitMeasurementRatioAccrued=Double.parseDouble(df.format((float)overLimitMeasurementAccrued / finalSumEffectiveMeasurement));
}
}
RStatHarmonicOrgMPO rStatHarmonicOrgMPO = new RStatHarmonicOrgMPO();
rStatHarmonicOrgMPO.setOrgNo(temp);
rStatHarmonicOrgMPO.setDataDate(localDate);
rStatHarmonicOrgMPO.setHarmonicType(dictData.getId());
rStatHarmonicOrgMPO.setDataType(v.getId());
rStatHarmonicOrgMPO.setOverDay(overDay);
rStatHarmonicOrgMPO.setOverLimitMeasurementAccrued(overLimitMeasurementAccrued);
rStatHarmonicOrgMPO.setOverLimitMeasurementAverage(overLimitMeasurementAverage);
rStatHarmonicOrgMPO.setOverLimitMeasurementRatioAccrued(overLimitMeasurementRatioAccrued);
rStatHarmonicOrgMPO.setOverLimitMeasurementRatioAverage(overLimitMeasurementRatioAverage);
rStatHarmonicOrgMPOList.add(rStatHarmonicOrgMPO);
});
});
});
if(!CollectionUtils.isEmpty(rStatHarmonicOrgMPOList)){
rStatHarmonicMPOService.saveOrUpdateBatchByMultiId(rStatHarmonicOrgMPOList,500);
}
}
@Transactional
@Async("asyncExecutor")
@SneakyThrows
private void hanlderDay(OrgParam orgParam) {
List<RStatHarmonicOrgDPO> rStatHarmonicOrgDPOList = new ArrayList<>();
List<String> data = deptFeignClient.getDepSonIdtByDeptId(orgParam.getOrgId()).getData();
Date date = DateUtil.parse(orgParam.getDataDate());
LocalDate localDate = LocalDateTimeUtil.parseDate(orgParam.getDataDate(), DatePattern.NORM_DATE_PATTERN);
QueryWrapper<RStatHarmonicDPO> queryWrapper = new QueryWrapper<>();
/*获取稳态统计指标*/
List<DictData> steadyStatis = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
/*获取数据类型*/
List<DictData> dataTypeList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.DATA_TYPE.getCode()).getData();
Map<String, DictData> dataTypeMap = dataTypeList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
;
/*获取监测点类型类型*/
List<DictData> lineSortList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.LINE_SORT.getCode()).getData();
Map<String, DictData> lineSortMap = lineSortList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
data.stream().forEach(temp->{
int sumEffectiveMeasurement =0;
List<RStatOrgDVO> rStatOrgDVOS = rStatOrgDMapper.listAll(orgParam.getDataDate(), temp);
if(CollectionUtils.isEmpty(rStatOrgDVOS)){
sumEffectiveMeasurement=0;
}else {
sumEffectiveMeasurement = rStatOrgDVOS.stream().mapToInt(RStatOrgDVO::getEffectiveMeasurement).sum();
}
int finalSumEffectiveMeasurement = sumEffectiveMeasurement;
dataTypeMap.forEach((k, v)->{
steadyStatis.forEach(dictData -> {
if (Objects.equals(dictData.getCode(), DicDataEnum.TOTAL_INDICATOR.getCode())) {
return;
}
queryWrapper.clear();
queryWrapper.select("over_limit_measurement").
eq("org_no",temp).
eq("data_type",v.getId()).
eq("harmonic_type",dictData.getId()).
eq("DATE_FORMAT( data_date ,'%Y-%m-%d')",orgParam.getDataDate());
List<RStatHarmonicDPO> rStatHarmonicDPOList = rStatHarmonicDPOMapper.selectList(queryWrapper);
int sumOverLimitMeasurement =0;
if(CollectionUtils.isEmpty(rStatOrgDVOS)){
sumOverLimitMeasurement=0;
}else {
sumOverLimitMeasurement = rStatHarmonicDPOList.stream().mapToInt(RStatHarmonicDPO::getOverLimitMeasurement).sum();
}
RStatHarmonicOrgDPO rStatHarmonicOrgDPO = new RStatHarmonicOrgDPO();
rStatHarmonicOrgDPO.setOrgNo(temp);
rStatHarmonicOrgDPO.setDataDate(localDate);
rStatHarmonicOrgDPO.setHarmonicType(dictData.getId());
rStatHarmonicOrgDPO.setDataType(v.getId());
rStatHarmonicOrgDPO.setOverLimitMeasurementAverage(sumOverLimitMeasurement);
if(finalSumEffectiveMeasurement ==0){
rStatHarmonicOrgDPO.setOverLimitMeasurementRatioAverage(0.00);
}else {
rStatHarmonicOrgDPO.setOverLimitMeasurementRatioAverage(Double.parseDouble(df.format((float)sumOverLimitMeasurement / finalSumEffectiveMeasurement)));
}
rStatHarmonicOrgDPOList.add(rStatHarmonicOrgDPO);
});
});
});
if(!CollectionUtils.isEmpty(rStatHarmonicOrgDPOList)){
rStatHarmonicDPOService.saveOrUpdateBatchByMultiId(rStatHarmonicOrgDPOList,500);
}
}
public static void main(String[] args) {
List<RStatOrgDVO> rStatOrgDVOS = null;
int sumEffectiveMeasurement = rStatOrgDVOS.stream().mapToInt(RStatOrgDVO::getEffectiveMeasurement).sum();
}
} }

760
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/area/RStatHarmonicServiceImpl.java
View File

@@ -19,16 +19,12 @@ import com.njcn.prepare.harmonic.pojo.bo.CalculatedParam;
import com.njcn.prepare.harmonic.pojo.mysql.ROperatingMonitorDPO; import com.njcn.prepare.harmonic.pojo.mysql.ROperatingMonitorDPO;
import com.njcn.prepare.harmonic.pojo.mysql.po.*; import com.njcn.prepare.harmonic.pojo.mysql.po.*;
import com.njcn.prepare.harmonic.service.mysql.area.*; import com.njcn.prepare.harmonic.service.mysql.area.*;
import com.njcn.prepare.harmonic.utils.PublicUtil;
import com.njcn.system.api.DicDataFeignClient; import com.njcn.system.api.DicDataFeignClient;
import com.njcn.system.enums.DicDataEnum; import com.njcn.system.enums.DicDataEnum;
import com.njcn.system.enums.DicDataTypeEnum; import com.njcn.system.enums.DicDataTypeEnum;
import com.njcn.system.pojo.po.DictData; import com.njcn.system.pojo.po.DictData;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils; import org.springframework.util.CollectionUtils;
import java.math.BigDecimal; import java.math.BigDecimal;
@@ -855,624 +851,6 @@ public class RStatHarmonicServiceImpl implements RStatHarmonicService {
/***----------------------------------------------------------------------------------------------**/ /***----------------------------------------------------------------------------------------------**/
@Override
public void handler(List<DeptGetChildrenMoreDTO> data, String dataDate, Integer type) {
switch (type) {
case 1:
this.hanlderOracleYear (data, dataDate, type);
break;
case 2:
this.hanlderOracleQtr (data, dataDate, type);
break;
case 3:
this.hanlderM ( data, dataDate, type);
break;
case 5:
this.hanlderDay ( data, dataDate, type);
break;
default:
break;
}
}
@Transactional
@Async("asyncExecutor")
@SneakyThrows
private void hanlderOracleYear(List<DeptGetChildrenMoreDTO> data, String dataDate, Integer type) {
List<RStatHarmonicYPO> rStatHarmonicYPOList = new ArrayList<>();
Date date = DateUtil.parse(dataDate);
LocalDate localDate = LocalDateTimeUtil.parseDate(dataDate, DatePattern.NORM_DATE_PATTERN);
/*获取监测点类型类型*/
QueryWrapper<RMpPartHarmonicDetailM> queryWrapper = new QueryWrapper<>();
QueryWrapper<RMpSurplusHarmonicDetailM> rMpSurplusHarmonicDetailMQueryWrapper = new QueryWrapper<>();
QueryWrapper<RStatOrgYPO> rStatOrgYPOQueryWrapper = new QueryWrapper<>();
QueryWrapper<RStatHarmonicMPO> harmonicMPOQueryWrapper = new QueryWrapper<>();
DecimalFormat df = new DecimalFormat("0.00000");
/*获取稳态统计指标*/
List<DictData> steadyStatis = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
/*获取数据类型*/
List<DictData> dataTypeList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.DATA_TYPE.getCode()).getData();
Map<String, DictData> dataTypeMap = dataTypeList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
;
/*获取监测点类型类型*/
List<DictData> lineSortList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.LINE_SORT.getCode()).getData();
Map<String, DictData> lineSortMap = lineSortList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
data.forEach(deptGetChildrenMoreDTO -> {
/*主网*/
if (!CollectionUtils.isEmpty(deptGetChildrenMoreDTO.getLineBaseList())) {
List<LineDevGetDTO> lineBaseList = deptGetChildrenMoreDTO.getLineBaseList();
Map<String, List<LineDevGetDTO>> collect = lineBaseList.stream().collect(Collectors.groupingBy(LineDevGetDTO::getLineTag));
collect.forEach((k, v) -> {
List<String> collect1 = v.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
queryWrapper.clear();
queryWrapper.select("freq_over_day", "v_dev_over_day", "v_over_day", "i_over_day", "unbalance_over_day", "i_neg_over_day").
in("measurement_point_id", collect1).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
List<RMpPartHarmonicDetailM> rMpPartHarmonicDetailMS = rMpPartHarmonicDetailMMapper.selectList(queryWrapper);
rMpSurplusHarmonicDetailMQueryWrapper.clear();
rMpSurplusHarmonicDetailMQueryWrapper.select("flicker_over_day", "inuharm_over_day").
in("measurement_point_id", collect1).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
List<RMpSurplusHarmonicDetailM> rMpSurplusHarmonicDetailMS = rMpSurplusHarmonicDetailMMapper.selectList(rMpSurplusHarmonicDetailMQueryWrapper);
rStatOrgYPOQueryWrapper.clear();
rStatOrgYPOQueryWrapper.select("effective_measurement_accrued").
eq("org_no", deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class", k).
eq("data_type", dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId()).
eq("YEAR( data_date)", dataDate.substring(0,4));
RStatOrgYPO rStatOrgYPO = rStatOrgYMapper.selectOne(rStatOrgYPOQueryWrapper);
steadyStatis.forEach(dictData -> {
if (Objects.equals(dictData.getCode(), DicDataEnum.TOTAL_INDICATOR.getCode())) {
return;
}
RStatHarmonicYPO rStatHarmonicYPO = new RStatHarmonicYPO();
rStatHarmonicYPO.setOrgNo(deptGetChildrenMoreDTO.getUnitId());
rStatHarmonicYPO.setDataDate(localDate);
rStatHarmonicYPO.setHarmonicType(dictData.getId());
rStatHarmonicYPO.setDataType(dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId());
rStatHarmonicYPO.setMeasurementTypeClass(k);
/**4、累计超标监测点数*/
rStatHarmonicYPO.setOverLimitMeasurementAccrued(getOverLimitMeasurementAccruedTime(dictData, rMpPartHarmonicDetailMS, rMpSurplusHarmonicDetailMS));
/*3、日均超标监测点数,6、日均超标监测点数占比*/
harmonicMPOQueryWrapper.clear();
harmonicMPOQueryWrapper.eq("org_no", deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class", k).
eq("data_type", dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId()).
eq("harmonic_type", dictData.getId()).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
List<RStatHarmonicMPO> list = rStatHarmonicMPOService.list(harmonicMPOQueryWrapper);
double asDouble = list.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementAverage).average().orElse(0.00);
asDouble = BigDecimal.valueOf(asDouble).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
double asDouble1 = list.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementRatioAverage).average().orElse(0.00);
asDouble1 = BigDecimal.valueOf(asDouble1).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
int sum1 = list.stream().mapToInt(RStatHarmonicMPO::getOverDay).sum();
rStatHarmonicYPO.setOverLimitMeasurementAverage(asDouble);
rStatHarmonicYPO.setOverLimitMeasurementRatioAverage(asDouble1);
if (rStatHarmonicYPO.getOverLimitMeasurementAccrued() == 0) {
//todo为0时如何设值
rStatHarmonicYPO.setAverageOverDay(0.00);
} else {
String value = df.format((float) sum1 / rStatHarmonicYPO.getOverLimitMeasurementAccrued());
rStatHarmonicYPO.setAverageOverDay(Double.parseDouble(value));
}
if (rStatOrgYPO.getEffectiveMeasurementAccrued() == 0) {
//todo为0时如何设值
rStatHarmonicYPO.setOverLimitMeasurementRatioAccrued(0.00);
} else {
String value = df.format((float) rStatHarmonicYPO.getOverLimitMeasurementAccrued() / rStatOrgYPO.getEffectiveMeasurementAccrued());
rStatHarmonicYPO.setOverLimitMeasurementRatioAccrued(Double.parseDouble(value));
}
rStatHarmonicYPOList.add(rStatHarmonicYPO);
});
});
}
/*配网*/
if(CollectionUtil.isNotEmpty(deptGetChildrenMoreDTO.getPwMonitorIds())){
List<LineDevGetDTO> pwMonitorIds = deptGetChildrenMoreDTO.getPwMonitorIds();
Map<Integer, List<LineDevGetDTO>> collect = pwMonitorIds.stream().collect(Collectors.groupingBy(LineDevGetDTO::getLineType));
collect.forEach((k, v) -> {
List<String> collect1 = v.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
queryWrapper.clear();
queryWrapper.select("freq_over_day", "v_dev_over_day", "v_over_day", "i_over_day", "unbalance_over_day", "i_neg_over_day").
in("measurement_point_id", collect1).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
List<RMpPartHarmonicDetailM> rMpPartHarmonicDetailMS = rMpPartHarmonicDetailMMapper.selectList(queryWrapper);
rMpSurplusHarmonicDetailMQueryWrapper.clear();
rMpSurplusHarmonicDetailMQueryWrapper.select("flicker_over_day", "inuharm_over_day").
in("measurement_point_id", collect1).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
List<RMpSurplusHarmonicDetailM> rMpSurplusHarmonicDetailMS = rMpSurplusHarmonicDetailMMapper.selectList(rMpSurplusHarmonicDetailMQueryWrapper);
rStatOrgYPOQueryWrapper.clear();
rStatOrgYPOQueryWrapper.select("effective_measurement_accrued").
eq("org_no", deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class", getmeasurementType(k, lineSortMap)).
eq("data_type", dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId()).
eq("YEAR( data_date)", dataDate.substring(0,4));
RStatOrgYPO rStatOrgYPO = rStatOrgYMapper.selectOne(rStatOrgYPOQueryWrapper);
steadyStatis.forEach(dictData -> {
if (Objects.equals(dictData.getCode(), DicDataEnum.TOTAL_INDICATOR.getCode())) {
return;
}
RStatHarmonicYPO rStatHarmonicYPO = new RStatHarmonicYPO();
rStatHarmonicYPO.setOrgNo(deptGetChildrenMoreDTO.getUnitId());
rStatHarmonicYPO.setDataDate(localDate);
rStatHarmonicYPO.setHarmonicType(dictData.getId());
rStatHarmonicYPO.setDataType(dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId());
rStatHarmonicYPO.setMeasurementTypeClass(getmeasurementType(k, lineSortMap));
/**4、累计超标监测点数*/
rStatHarmonicYPO.setOverLimitMeasurementAccrued(getOverLimitMeasurementAccruedTime(dictData, rMpPartHarmonicDetailMS, rMpSurplusHarmonicDetailMS));
/*3、日均超标监测点数,6、日均超标监测点数占比*/
harmonicMPOQueryWrapper.clear();
harmonicMPOQueryWrapper.eq("org_no", deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class", getmeasurementType(k, lineSortMap)).
eq("data_type", dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId()).
eq("harmonic_type", dictData.getId()).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
List<RStatHarmonicMPO> list = rStatHarmonicMPOService.list(harmonicMPOQueryWrapper);
double asDouble = list.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementAverage).average().orElse(0.00);
asDouble = BigDecimal.valueOf(asDouble).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
double asDouble1 = list.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementRatioAverage).average().orElse(0.00);
asDouble1 = BigDecimal.valueOf(asDouble1).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
int sum1 = list.stream().mapToInt(RStatHarmonicMPO::getOverDay).sum();
rStatHarmonicYPO.setOverLimitMeasurementAverage(asDouble);
rStatHarmonicYPO.setOverLimitMeasurementRatioAverage(asDouble1);
if (rStatHarmonicYPO.getOverLimitMeasurementAccrued() == 0) {
//todo为0时如何设值
rStatHarmonicYPO.setAverageOverDay(0.00);
} else {
String value = df.format((float) sum1 / rStatHarmonicYPO.getOverLimitMeasurementAccrued());
rStatHarmonicYPO.setAverageOverDay(Double.parseDouble(value));
}
if (rStatOrgYPO.getEffectiveMeasurementAccrued() == 0) {
//todo为0时如何设值
rStatHarmonicYPO.setOverLimitMeasurementRatioAccrued(0.00);
} else {
String value = df.format((float) rStatHarmonicYPO.getOverLimitMeasurementAccrued() / rStatOrgYPO.getEffectiveMeasurementAccrued());
rStatHarmonicYPO.setOverLimitMeasurementRatioAccrued(Double.parseDouble(value));
}
rStatHarmonicYPOList.add(rStatHarmonicYPO);
});
});
}
});
if(CollectionUtil.isNotEmpty(rStatHarmonicYPOList)){
rStatHarmonicYPOService.saveOrUpdateBatchByMultiId(rStatHarmonicYPOList,500);
}
}
@Transactional
@Async("asyncExecutor")
@SneakyThrows
private void hanlderOracleQtr(List<DeptGetChildrenMoreDTO> data, String dataDate, Integer type) {
List<RStatHarmonicQPO> rStatHarmonicQPOList = new ArrayList<>();
Date date = DateUtil.parse(dataDate);
LocalDate localDate = LocalDateTimeUtil.parseDate(dataDate, DatePattern.NORM_DATE_PATTERN);
QueryWrapper<RMpPartHarmonicDetailM> queryWrapper = new QueryWrapper<>();
QueryWrapper<RMpSurplusHarmonicDetailM> rMpSurplusHarmonicDetailMQueryWrapper = new QueryWrapper<>();
QueryWrapper<RStatOrgQPO> rStatOrgQPOQueryWrapper = new QueryWrapper<>();
QueryWrapper<RStatHarmonicMPO> harmonicMPOQueryWrapper = new QueryWrapper<>();
DecimalFormat df = new DecimalFormat("0.00000");
/*获取稳态统计指标*/
List<DictData> steadyStatis = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
/*获取数据类型*/
List<DictData> dataTypeList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.DATA_TYPE.getCode()).getData();
Map<String, DictData> dataTypeMap = dataTypeList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
;
/*获取监测点类型类型*/
List<DictData> lineSortList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.LINE_SORT.getCode()).getData();
Map<String, DictData> lineSortMap = lineSortList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
data.forEach(deptGetChildrenMoreDTO -> {
/*主网*/
if (!CollectionUtils.isEmpty(deptGetChildrenMoreDTO.getLineBaseList())) {
List<LineDevGetDTO> lineBaseList = deptGetChildrenMoreDTO.getLineBaseList();
Map<String, List<LineDevGetDTO>> collect = lineBaseList.stream().collect(Collectors.groupingBy(LineDevGetDTO::getLineTag));
collect.forEach((k, v) -> {
List<String> collect1 = v.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
queryWrapper.clear();
queryWrapper.select("freq_over_day", "v_dev_over_day", "v_over_day", "i_over_day", "unbalance_over_day", "i_neg_over_day").
in("measurement_point_id", collect1).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
List<RMpPartHarmonicDetailM> rMpPartHarmonicDetailMS = rMpPartHarmonicDetailMMapper.selectList(queryWrapper);
rMpSurplusHarmonicDetailMQueryWrapper.clear();
rMpSurplusHarmonicDetailMQueryWrapper.select("flicker_over_day", "inuharm_over_day").
in("measurement_point_id", collect1).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
List<RMpSurplusHarmonicDetailM> rMpSurplusHarmonicDetailMS = rMpSurplusHarmonicDetailMMapper.selectList(rMpSurplusHarmonicDetailMQueryWrapper);
rStatOrgQPOQueryWrapper.clear();
rStatOrgQPOQueryWrapper.select("effective_measurement_accrued").
eq("org_no", deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class", k).
eq("data_type", dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId()).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
RStatOrgQPO rStatOrgQPO = rStatOrgQMapper.selectOne(rStatOrgQPOQueryWrapper);
steadyStatis.forEach(dictData -> {
if (Objects.equals(dictData.getCode(), DicDataEnum.TOTAL_INDICATOR.getCode())) {
return;
}
RStatHarmonicQPO rStatHarmonicQPO = new RStatHarmonicQPO();
rStatHarmonicQPO.setOrgNo(deptGetChildrenMoreDTO.getUnitId());
rStatHarmonicQPO.setDataDate(localDate);
rStatHarmonicQPO.setHarmonicType(dictData.getId());
rStatHarmonicQPO.setDataType(dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId());
rStatHarmonicQPO.setMeasurementTypeClass(k);
/**4、累计超标监测点数*/
rStatHarmonicQPO.setOverLimitMeasurementAccrued(getOverLimitMeasurementAccruedTime(dictData, rMpPartHarmonicDetailMS, rMpSurplusHarmonicDetailMS));
/*3、日均超标监测点数,6、日均超标监测点数占比*/
harmonicMPOQueryWrapper.clear();
harmonicMPOQueryWrapper.eq("org_no", deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class", k).
eq("data_type", dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId()).
eq("harmonic_type", dictData.getId()).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
List<RStatHarmonicMPO> list = rStatHarmonicMPOService.list(harmonicMPOQueryWrapper);
double asDouble = list.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementAverage).average().orElse(0.00);
asDouble = BigDecimal.valueOf(asDouble).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
double asDouble1 = list.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementRatioAverage).average().orElse(0.00);
asDouble1 = BigDecimal.valueOf(asDouble1).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
int sum1 = list.stream().mapToInt(RStatHarmonicMPO::getOverDay).sum();
rStatHarmonicQPO.setOverLimitMeasurementAverage(asDouble);
rStatHarmonicQPO.setOverLimitMeasurementRatioAverage(asDouble1);
if (rStatHarmonicQPO.getOverLimitMeasurementAccrued() == 0) {
//todo为0时如何设值
rStatHarmonicQPO.setAverageOverDay(0.00);
} else {
String value = df.format((float) sum1 / rStatHarmonicQPO.getOverLimitMeasurementAccrued());
rStatHarmonicQPO.setAverageOverDay(Double.parseDouble(value));
}
if (rStatOrgQPO.getEffectiveMeasurementAccrued() == 0) {
//todo为0时如何设值
rStatHarmonicQPO.setOverLimitMeasurementRatioAccrued(0.00);
} else {
String value = df.format((float) rStatHarmonicQPO.getOverLimitMeasurementAccrued() / rStatOrgQPO.getEffectiveMeasurementAccrued());
rStatHarmonicQPO.setOverLimitMeasurementRatioAccrued(Double.parseDouble(value));
}
rStatHarmonicQPOList.add(rStatHarmonicQPO);
});
});
}
/*配网*/
if(CollectionUtil.isNotEmpty(deptGetChildrenMoreDTO.getPwMonitorIds())){
List<LineDevGetDTO> pwMonitorIds = deptGetChildrenMoreDTO.getPwMonitorIds();
Map<Integer, List<LineDevGetDTO>> collect = pwMonitorIds.stream().collect(Collectors.groupingBy(LineDevGetDTO::getLineType));
collect.forEach((k, v) -> {
List<String> collect1 = v.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
queryWrapper.clear();
queryWrapper.select("freq_over_day", "v_dev_over_day", "v_over_day", "i_over_day", "unbalance_over_day", "i_neg_over_day").
in("measurement_point_id", collect1).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
List<RMpPartHarmonicDetailM> rMpPartHarmonicDetailMS = rMpPartHarmonicDetailMMapper.selectList(queryWrapper);
rMpSurplusHarmonicDetailMQueryWrapper.clear();
rMpSurplusHarmonicDetailMQueryWrapper.select("flicker_over_day", "inuharm_over_day").
in("measurement_point_id", collect1).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
List<RMpSurplusHarmonicDetailM> rMpSurplusHarmonicDetailMS = rMpSurplusHarmonicDetailMMapper.selectList(rMpSurplusHarmonicDetailMQueryWrapper);
rStatOrgQPOQueryWrapper.clear();
rStatOrgQPOQueryWrapper.select("effective_measurement_accrued").
eq("org_no", deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class", getmeasurementType(k, lineSortMap)).
eq("data_type", dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId()).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
RStatOrgQPO rStatOrgQPO = rStatOrgQMapper.selectOne(rStatOrgQPOQueryWrapper);
steadyStatis.forEach(dictData -> {
if (Objects.equals(dictData.getCode(), DicDataEnum.TOTAL_INDICATOR.getCode())) {
return;
}
RStatHarmonicQPO rStatHarmonicQPO = new RStatHarmonicQPO();
rStatHarmonicQPO.setOrgNo(deptGetChildrenMoreDTO.getUnitId());
rStatHarmonicQPO.setDataDate(localDate);
rStatHarmonicQPO.setHarmonicType(dictData.getId());
rStatHarmonicQPO.setDataType(dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId());
rStatHarmonicQPO.setMeasurementTypeClass(getmeasurementType(k, lineSortMap));
/**4、累计超标监测点数*/
rStatHarmonicQPO.setOverLimitMeasurementAccrued(getOverLimitMeasurementAccruedTime(dictData, rMpPartHarmonicDetailMS, rMpSurplusHarmonicDetailMS));
/*3、日均超标监测点数,6、日均超标监测点数占比*/
harmonicMPOQueryWrapper.clear();
harmonicMPOQueryWrapper.eq("org_no", deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class", getmeasurementType(k, lineSortMap)).
eq("data_type", dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId()).
eq("harmonic_type", dictData.getId()).
eq("QUARTER( data_date)", PublicUtil.getNowQuarter (dataDate));
List<RStatHarmonicMPO> list = rStatHarmonicMPOService.list(harmonicMPOQueryWrapper);
double asDouble = list.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementAverage).average().orElse(0.00);
asDouble = BigDecimal.valueOf(asDouble).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
double asDouble1 = list.stream().mapToDouble(RStatHarmonicMPO::getOverLimitMeasurementRatioAverage).average().orElse(0.00);
asDouble1 = BigDecimal.valueOf(asDouble1).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
int sum1 = list.stream().mapToInt(RStatHarmonicMPO::getOverDay).sum();
rStatHarmonicQPO.setOverLimitMeasurementAverage(asDouble);
rStatHarmonicQPO.setOverLimitMeasurementRatioAverage(asDouble1);
if (rStatHarmonicQPO.getOverLimitMeasurementAccrued() == 0) {
//todo为0时如何设值
rStatHarmonicQPO.setAverageOverDay(0.00);
} else {
String value = df.format((float) sum1 / rStatHarmonicQPO.getOverLimitMeasurementAccrued());
rStatHarmonicQPO.setAverageOverDay(Double.parseDouble(value));
}
if (rStatOrgQPO.getEffectiveMeasurementAccrued() == 0) {
//todo为0时如何设值
rStatHarmonicQPO.setOverLimitMeasurementRatioAccrued(0.00);
} else {
String value = df.format((float) rStatHarmonicQPO.getOverLimitMeasurementAccrued() / rStatOrgQPO.getEffectiveMeasurementAccrued());
rStatHarmonicQPO.setOverLimitMeasurementRatioAccrued(Double.parseDouble(value));
}
rStatHarmonicQPOList.add(rStatHarmonicQPO);
});
});
}
});
if(CollectionUtil.isNotEmpty(rStatHarmonicQPOList)){
rStatHarmonicQPOService.saveOrUpdateBatchByMultiId(rStatHarmonicQPOList,500);
}
}
@Transactional
@Async("asyncExecutor")
@SneakyThrows
private void hanlderM(List<DeptGetChildrenMoreDTO> data, String dataDate, Integer type) {
List<RStatHarmonicMPO> rStatHarmonicMPOList = new ArrayList<>();
Date date = DateUtil.parse(dataDate);
LocalDate localDate = LocalDateTimeUtil.parseDate(dataDate, DatePattern.NORM_DATE_PATTERN);
QueryWrapper<RMpPartHarmonicDetailM> queryWrapper = new QueryWrapper<>();
QueryWrapper<RMpSurplusHarmonicDetailM> rMpSurplusHarmonicDetailMQueryWrapper = new QueryWrapper<>();
QueryWrapper<RStatOrgMPO> rStatOrgMPOQueryWrapper = new QueryWrapper<>();
QueryWrapper<RStatHarmonicDPO> harmonicDPOQueryWrapper = new QueryWrapper<>();
DecimalFormat df = new DecimalFormat("0.00000");
/*获取稳态统计指标*/
List<DictData> steadyStatis = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
/*获取数据类型*/
List<DictData> dataTypeList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.DATA_TYPE.getCode()).getData();
Map<String, DictData> dataTypeMap = dataTypeList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
;
/*获取监测点类型类型*/
List<DictData> lineSortList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.LINE_SORT.getCode()).getData();
Map<String, DictData> lineSortMap = lineSortList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
data.forEach(deptGetChildrenMoreDTO -> {
/*主网*/
if (!CollectionUtils.isEmpty(deptGetChildrenMoreDTO.getLineBaseList())) {
List<LineDevGetDTO> lineBaseList = deptGetChildrenMoreDTO.getLineBaseList();
Map<String, List<LineDevGetDTO>> collect = lineBaseList.stream().collect(Collectors.groupingBy(LineDevGetDTO::getLineTag));
collect.forEach((k, v) -> {
List<String> collect1 = v.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
queryWrapper.clear();
queryWrapper.select("freq_over_day", "v_dev_over_day", "v_over_day", "i_over_day", "unbalance_over_day", "i_neg_over_day").
in("measurement_point_id", collect1).
eq("DATE_FORMAT( data_date ,'%Y-%m')",dataDate.substring(0, 7));
List<RMpPartHarmonicDetailM> rMpPartHarmonicDetailMS = rMpPartHarmonicDetailMMapper.selectList(queryWrapper);
rMpSurplusHarmonicDetailMQueryWrapper.clear();
rMpSurplusHarmonicDetailMQueryWrapper.select("flicker_over_day", "inuharm_over_day").
in("measurement_point_id", collect1).
eq("DATE_FORMAT( data_date ,'%Y-%m')",dataDate.substring(0, 7));
List<RMpSurplusHarmonicDetailM> rMpSurplusHarmonicDetailMS = rMpSurplusHarmonicDetailMMapper.selectList(rMpSurplusHarmonicDetailMQueryWrapper);
rStatOrgMPOQueryWrapper.clear();
rStatOrgMPOQueryWrapper.select("effective_measurement_accrued").
eq("org_no", deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class", k).
eq("data_type", dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId()).
eq("DATE_FORMAT( data_date ,'%Y-%m')",dataDate.substring(0, 7));
RStatOrgMPO rStatOrgMPO = rStatOrgMMapper.selectOne(rStatOrgMPOQueryWrapper);
steadyStatis.forEach(dictData -> {
if (Objects.equals(dictData.getCode(), DicDataEnum.TOTAL_INDICATOR.getCode())) {
return;
}
RStatHarmonicMPO rStatHarmonicMPO = new RStatHarmonicMPO();
rStatHarmonicMPO.setOrgNo(deptGetChildrenMoreDTO.getUnitId());
rStatHarmonicMPO.setDataDate(localDate);
rStatHarmonicMPO.setHarmonicType(dictData.getId());
rStatHarmonicMPO.setDataType(dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId());
rStatHarmonicMPO.setMeasurementTypeClass(k);
/**4、累计超标监测点数*/
rStatHarmonicMPO.setOverLimitMeasurementAccrued(getOverLimitMeasurementAccruedTime(dictData, rMpPartHarmonicDetailMS, rMpSurplusHarmonicDetailMS));
/*3、日均超标监测点数,6、日均超标监测点数占比*/
harmonicDPOQueryWrapper.clear();
harmonicDPOQueryWrapper.eq("org_no", deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class", k).
eq("data_type", dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId()).
eq("harmonic_type", dictData.getId()).
eq("DATE_FORMAT( data_date ,'%Y-%m')",dataDate.substring(0, 7));
List<RStatHarmonicDPO> rStatHarmonicDPOList = rStatHarmonicDPOService.list(harmonicDPOQueryWrapper);
double asDouble = rStatHarmonicDPOList.stream().mapToDouble(RStatHarmonicDPO::getOverLimitMeasurement).average().orElse(0.00);
asDouble = BigDecimal.valueOf(asDouble).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
double asDouble1 = rStatHarmonicDPOList.stream().mapToDouble(RStatHarmonicDPO::getOverLimitMeasurementRatio).average().orElse(0.00);
asDouble1 = BigDecimal.valueOf(asDouble1).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
rStatHarmonicMPO.setOverLimitMeasurementAverage(asDouble);
double sum = rStatHarmonicDPOList.stream().mapToDouble(RStatHarmonicDPO::getOverLimitMeasurement).sum();
rStatHarmonicMPO.setOverLimitMeasurementRatioAverage(asDouble1);
int i = BigDecimal.valueOf(asDouble1).setScale(0, BigDecimal.ROUND_HALF_UP).intValue();
rStatHarmonicMPO.setOverDay(i);
if (rStatOrgMPO.getEffectiveMeasurementAccrued() == 0) {
//todo为0时如何设值
rStatHarmonicMPO.setOverLimitMeasurementRatioAccrued(0.00);
} else {
String value = df.format((float) rStatHarmonicMPO.getOverLimitMeasurementAccrued() / rStatOrgMPO.getEffectiveMeasurementAccrued());
rStatHarmonicMPO.setOverLimitMeasurementRatioAccrued(Double.parseDouble(value));
}
rStatHarmonicMPOList.add(rStatHarmonicMPO);
});
});
}
/*配网*/
if(CollectionUtil.isNotEmpty(deptGetChildrenMoreDTO.getPwMonitorIds())){
List<LineDevGetDTO> pwMonitorIds = deptGetChildrenMoreDTO.getPwMonitorIds();
Map<Integer, List<LineDevGetDTO>> collect = pwMonitorIds.stream().collect(Collectors.groupingBy(LineDevGetDTO::getLineType));
collect.forEach((k, v) -> {
List<String> collect1 = v.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
queryWrapper.clear();
queryWrapper.select("freq_over_day", "v_dev_over_day", "v_over_day", "i_over_day", "unbalance_over_day", "i_neg_over_day").
in("measurement_point_id", collect1).
eq("DATE_FORMAT( data_date ,'%Y-%m')",dataDate.substring(0, 7));
List<RMpPartHarmonicDetailM> rMpPartHarmonicDetailMS = rMpPartHarmonicDetailMMapper.selectList(queryWrapper);
rMpSurplusHarmonicDetailMQueryWrapper.clear();
rMpSurplusHarmonicDetailMQueryWrapper.select("flicker_over_day", "inuharm_over_day").
in("measurement_point_id", collect1).
eq("DATE_FORMAT( data_date ,'%Y-%m')",dataDate.substring(0, 7));
List<RMpSurplusHarmonicDetailM> rMpSurplusHarmonicDetailMS = rMpSurplusHarmonicDetailMMapper.selectList(rMpSurplusHarmonicDetailMQueryWrapper);
rStatOrgMPOQueryWrapper.clear();
rStatOrgMPOQueryWrapper.select("effective_measurement_accrued").
eq("org_no", deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class", getmeasurementType(k, lineSortMap)).
eq("data_type", dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId()).
eq("DATE_FORMAT( data_date ,'%Y-%m')",dataDate.substring(0, 7));
RStatOrgMPO rStatOrgMPO = rStatOrgMMapper.selectOne(rStatOrgMPOQueryWrapper);
steadyStatis.forEach(dictData -> {
if (Objects.equals(dictData.getCode(), DicDataEnum.TOTAL_INDICATOR.getCode())) {
return;
}
RStatHarmonicMPO rStatHarmonicMPO = new RStatHarmonicMPO();
rStatHarmonicMPO.setOrgNo(deptGetChildrenMoreDTO.getUnitId());
rStatHarmonicMPO.setDataDate(localDate);
rStatHarmonicMPO.setHarmonicType(dictData.getId());
rStatHarmonicMPO.setDataType(dataTypeMap.get(DicDataEnum.DISTRIBUTION_POINT.getCode()).getId());
rStatHarmonicMPO.setMeasurementTypeClass(getmeasurementType(k, lineSortMap));
/**4、累计超标监测点数*/
rStatHarmonicMPO.setOverLimitMeasurementAccrued(getOverLimitMeasurementAccruedTime(dictData, rMpPartHarmonicDetailMS, rMpSurplusHarmonicDetailMS));
/*3、日均超标监测点数,6、日均超标监测点数占比*/
harmonicDPOQueryWrapper.clear();
harmonicDPOQueryWrapper.eq("org_no", deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class", getmeasurementType(k, lineSortMap)).
eq("data_type", dataTypeMap.get(DicDataEnum.DISTRIBUTION_POINT.getCode()).getId()).
eq("harmonic_type", dictData.getId()).
eq("DATE_FORMAT( data_date ,'%Y-%m')",dataDate.substring(0, 7));
List<RStatHarmonicDPO> rStatHarmonicDPOList = rStatHarmonicDPOService.list(harmonicDPOQueryWrapper);
double asDouble = rStatHarmonicDPOList.stream().mapToDouble(RStatHarmonicDPO::getOverLimitMeasurement).average().orElse(0.00);
asDouble = BigDecimal.valueOf(asDouble).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
double asDouble1 = rStatHarmonicDPOList.stream().mapToDouble(RStatHarmonicDPO::getOverLimitMeasurementRatio).average().orElse(0.00);
asDouble1 = BigDecimal.valueOf(asDouble1).setScale(5, BigDecimal.ROUND_HALF_UP).doubleValue();
rStatHarmonicMPO.setOverLimitMeasurementAverage(asDouble);
double sum = rStatHarmonicDPOList.stream().mapToDouble(RStatHarmonicDPO::getOverLimitMeasurement).sum();
rStatHarmonicMPO.setOverLimitMeasurementRatioAverage(asDouble1);
int i = BigDecimal.valueOf(asDouble1).setScale(0, BigDecimal.ROUND_HALF_UP).intValue();
rStatHarmonicMPO.setOverDay(i);
if (rStatOrgMPO.getEffectiveMeasurementAccrued() == 0) {
//todo为0时如何设值
rStatHarmonicMPO.setOverLimitMeasurementRatioAccrued(0.00);
} else {
String value = df.format((float) rStatHarmonicMPO.getOverLimitMeasurementAccrued() / rStatOrgMPO.getEffectiveMeasurementAccrued());
rStatHarmonicMPO.setOverLimitMeasurementRatioAccrued(Double.parseDouble(value));
}
rStatHarmonicMPOList.add(rStatHarmonicMPO);
});
});
}
});
if(CollectionUtil.isNotEmpty(rStatHarmonicMPOList)){
rStatHarmonicMPOService.saveOrUpdateBatchByMultiId(rStatHarmonicMPOList,500);
}
}
private Integer getOverLimitMeasurementAccruedTime(DictData dictData, List<RMpPartHarmonicDetailM> rMpPartHarmonicDetailMS, List<RMpSurplusHarmonicDetailM> rMpSurplusHarmonicDetailMS) { private Integer getOverLimitMeasurementAccruedTime(DictData dictData, List<RMpPartHarmonicDetailM> rMpPartHarmonicDetailMS, List<RMpSurplusHarmonicDetailM> rMpSurplusHarmonicDetailMS) {
Integer value = 0; Integer value = 0;
if (Objects.equals(dictData.getCode(),DicDataEnum.VOLTAGE_DEV.getCode())) { if (Objects.equals(dictData.getCode(),DicDataEnum.VOLTAGE_DEV.getCode())) {
@@ -1502,144 +880,6 @@ public class RStatHarmonicServiceImpl implements RStatHarmonicService {
return value; return value;
} }
@Transactional(rollbackFor = {Exception.class})
@Async("asyncExecutor")
@SneakyThrows
private void hanlderDay(List<DeptGetChildrenMoreDTO> data, String dataDate, Integer type) {
List<RStatHarmonicDPO> rStatHarmonicDPOList = new ArrayList<>();
Date date = DateUtil.parse(dataDate);
LocalDate localDate = LocalDateTimeUtil.parseDate(dataDate, DatePattern.NORM_DATE_PATTERN);
QueryWrapper<RMpPartHarmonicDetailD> queryWrapper = new QueryWrapper<>();
QueryWrapper<RMpSurplusHarmonicDetailD> rMpSurplusHarmonicDetailDQueryWrapper = new QueryWrapper<>();
QueryWrapper<RStatOrgDPO> rStatOrgDPOQueryWrapper = new QueryWrapper<>();
DecimalFormat df = new DecimalFormat("0.00000");
/*获取稳态统计指标*/
List<DictData> steadyStatis = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.STEADY_STATIS.getCode()).getData();
/*获取数据类型*/
List<DictData> dataTypeList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.DATA_TYPE.getCode()).getData();
Map<String, DictData> dataTypeMap = dataTypeList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
;
/*获取监测点类型类型*/
List<DictData> lineSortList = dicDataFeignClient.getDicDataByTypeCode(DicDataTypeEnum.LINE_SORT.getCode()).getData();
Map<String, DictData> lineSortMap = lineSortList.stream().collect(Collectors.toMap(DictData::getCode, dictData -> dictData));
data.forEach(deptGetChildrenMoreDTO -> {
/*主网*/
if(!CollectionUtils.isEmpty(deptGetChildrenMoreDTO.getLineBaseList())){
List<LineDevGetDTO> lineBaseList = deptGetChildrenMoreDTO.getLineBaseList();
Map<String, List<LineDevGetDTO>> collect = lineBaseList.stream().collect(Collectors.groupingBy(LineDevGetDTO::getLineTag));
collect.forEach((k, v)->{
List<String> collect1 = v.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
queryWrapper.clear();
queryWrapper.select("is_freq","is_v_dev","is_v","is_i","is_unbalance","is_i_neg").
in("measurement_point_id",collect1).
eq("DATE_FORMAT( data_date ,'%Y-%m-%d')",dataDate);
List<RMpPartHarmonicDetailD> rMpPartHarmonicDetailDS = rMpPartHarmonicDetailDMapper.selectList(queryWrapper);
rMpSurplusHarmonicDetailDQueryWrapper.clear();
rMpSurplusHarmonicDetailDQueryWrapper.select("is_flicker","is_inuharm").
in("measurement_point_id",collect1).
eq("DATE_FORMAT( data_date ,'%Y-%m-%d')",dataDate);
List<RMpSurplusHarmonicDetailD> rMpSurplusHarmonicDetailDS = rMpSurplusHarmonicDetailDMapper.selectList(rMpSurplusHarmonicDetailDQueryWrapper);
rStatOrgDPOQueryWrapper.clear();
rStatOrgDPOQueryWrapper.select("effective_measurement").
eq("org_no",deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class",k).
eq("data_type",dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId()).
eq("DATE_FORMAT( data_date ,'%Y-%m-%d')",dataDate);
RStatOrgDPO rStatOrgDPO = rStatOrgDMapper.selectOne(rStatOrgDPOQueryWrapper);
steadyStatis.forEach(dictData -> {
if(Objects.equals(dictData.getCode(),DicDataEnum.TOTAL_INDICATOR.getCode())){
return;
}
RStatHarmonicDPO rStatHarmonicDPO = new RStatHarmonicDPO();
rStatHarmonicDPO.setOrgNo(deptGetChildrenMoreDTO.getUnitId());
rStatHarmonicDPO.setDataDate(localDate);
rStatHarmonicDPO.setHarmonicType(dictData.getId());
rStatHarmonicDPO.setDataType(dataTypeMap.get(DicDataEnum.MAINNET_POINT.getCode()).getId());
rStatHarmonicDPO.setMeasurementTypeClass(k);
rStatHarmonicDPO.setOverLimitMeasurement(getSteadyStatisData(dictData,rMpPartHarmonicDetailDS,rMpSurplusHarmonicDetailDS));
if(rStatOrgDPO.getEffectiveMeasurement()==0){
rStatHarmonicDPO.setOverLimitMeasurementRatio(1.00);
}else{
String value = df.format((float)rStatHarmonicDPO.getOverLimitMeasurement() / rStatOrgDPO.getEffectiveMeasurement());
rStatHarmonicDPO.setOverLimitMeasurementRatio(Double.parseDouble(value));
}
rStatHarmonicDPOList.add(rStatHarmonicDPO);
});
});
}
/*配网*/
if(!CollectionUtils.isEmpty(deptGetChildrenMoreDTO.getPwMonitorIds())) {
List<LineDevGetDTO> pwMonitorIds = deptGetChildrenMoreDTO.getPwMonitorIds();
Map<Integer, List<LineDevGetDTO>> pwMonitorMap = pwMonitorIds.stream().collect(Collectors.groupingBy(LineDevGetDTO::getLineType));
pwMonitorMap.forEach((k, v) -> {
List<String> collect1 = v.stream().map(LineDevGetDTO::getPointId).collect(Collectors.toList());
queryWrapper.clear();
queryWrapper.select("is_freq", "is_v_dev", "is_v", "is_i", "is_unbalance", "is_i_neg").
in("measurement_point_id", collect1).
eq("DATE_FORMAT( data_date ,'%Y-%m-%d')", dataDate);
List<RMpPartHarmonicDetailD> rMpPartHarmonicDetailDS = rMpPartHarmonicDetailDMapper.selectList(queryWrapper);
rMpSurplusHarmonicDetailDQueryWrapper.clear();
rMpSurplusHarmonicDetailDQueryWrapper.select("is_flicker", "is_inuharm").
in("measurement_point_id", collect1).
eq("DATE_FORMAT( data_date ,'%Y-%m-%d')", dataDate);
List<RMpSurplusHarmonicDetailD> rMpSurplusHarmonicDetailDS = rMpSurplusHarmonicDetailDMapper.selectList(rMpSurplusHarmonicDetailDQueryWrapper);
rStatOrgDPOQueryWrapper.clear();
rStatOrgDPOQueryWrapper.select("effective_measurement").
eq("org_no", deptGetChildrenMoreDTO.getUnitId()).
eq("measurement_type_class", getmeasurementType(k, lineSortMap)).
eq("data_type", dataTypeMap.get(DicDataEnum.DISTRIBUTION_POINT.getCode()).getId()).
eq("DATE_FORMAT( data_date ,'%Y-%m-%d')", dataDate);
RStatOrgDPO rStatOrgDPO = rStatOrgDMapper.selectOne(rStatOrgDPOQueryWrapper);
steadyStatis.forEach(dictData -> {
if (Objects.equals(dictData.getCode(), DicDataEnum.NEG_CURRENT.getCode())) {
return;
}
RStatHarmonicDPO rStatHarmonicDPO = new RStatHarmonicDPO();
rStatHarmonicDPO.setOrgNo(deptGetChildrenMoreDTO.getUnitId());
rStatHarmonicDPO.setDataDate(localDate);
rStatHarmonicDPO.setHarmonicType(dictData.getId());
rStatHarmonicDPO.setDataType(dataTypeMap.get(DicDataEnum.DISTRIBUTION_POINT.getCode()).getId());
rStatHarmonicDPO.setMeasurementTypeClass(getmeasurementType(k, lineSortMap));
rStatHarmonicDPO.setOverLimitMeasurement(getSteadyStatisData(dictData, rMpPartHarmonicDetailDS, rMpSurplusHarmonicDetailDS));
if (rStatOrgDPO.getEffectiveMeasurement() == 0) {
rStatHarmonicDPO.setOverLimitMeasurementRatio(1.00);
} else {
String value = df.format(rStatHarmonicDPO.getOverLimitMeasurement() / rStatOrgDPO.getEffectiveMeasurement());
rStatHarmonicDPO.setOverLimitMeasurementRatio(Double.parseDouble(value));
}
rStatHarmonicDPOList.add(rStatHarmonicDPO);
});
});
}
});
if(!CollectionUtils.isEmpty(rStatHarmonicDPOList)){
rStatHarmonicDPOService.saveOrUpdateBatchByMultiId(rStatHarmonicDPOList,500);
}
}
private String getmeasurementType(Integer k, Map<String, DictData> lineSortMap) { private String getmeasurementType(Integer k, Map<String, DictData> lineSortMap) {
String value =""; String value ="";
switch (k) { switch (k) {

997
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/area/RStatOrgServiceImpl.java
View File

File diff suppressed because it is too large Load Diff

112
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/device/DeviceAbnormaStatisticsServiceImpl.java
View File

@@ -38,118 +38,6 @@ public class DeviceAbnormaStatisticsServiceImpl extends MppServiceImpl<DeviceAbn
private final DeviceAbnormaStatisticsMapper deviceAbnormaStatisticsMapper; private final DeviceAbnormaStatisticsMapper deviceAbnormaStatisticsMapper;
private final InfluxDbUtils influxDbUtils; private final InfluxDbUtils influxDbUtils;
@Override
public boolean dailyDeviceAbnormaStatistics (DeviceAbnormaStatisticsParam param) {
Map<String, List<TopMsgPO>> comMap = new HashMap<>();
Map<String, List<AlarmPO>> deviceFlowMap = new HashMap<>();
// 获取所有装置以及下属监测点
List<AlarmPO> lines = deviceAbnormaStatisticsMapper.getLines();
if(CollectionUtil.isEmpty(lines)){
return true;
}
// 根据装置id分组
Map<String, List<AlarmPO>> devMap = lines.stream().collect(Collectors.groupingBy(AlarmPO::getDeviceId));
// 监测点集合
List<String> monotorIds = lines.stream().map(AlarmPO::getId).collect(Collectors.toList());
// 装置id集合
List<String> devIds = new ArrayList<>(devMap.keySet());
// 获取异常告警策略
List<AlarmStrategyVO> alarmStrategyVOS = deviceAbnormaStatisticsMapper.selectAlarmStrategy();
Map<Integer, List<AlarmStrategyVO>> levMap = alarmStrategyVOS.stream().collect(Collectors.groupingBy(AlarmStrategyVO::getAlgoDesc));
// 获取监测点数据完整性
List<AlarmPO> lineIntegritys = deviceAbnormaStatisticsMapper.getIntegrityByLineIds(
monotorIds,
DateUtil.beginOfDay(DateUtil.parse(param.getTime())),
DateUtil.endOfDay(DateUtil.parse(param.getTime())));
Map<String, List<AlarmPO>> lineIntegrityMap = lineIntegritys.stream().collect(Collectors.groupingBy(AlarmPO::getDeviceId));
// 告警信息统计
List<AlarmPO> lineAlarms = deviceAbnormaStatisticsMapper.getAlarmByLines(
monotorIds,
devIds,
DateUtil.beginOfDay(DateUtil.parse(param.getTime())),
DateUtil.endOfDay(DateUtil.parse(param.getTime())));
Map<String, List<AlarmPO>> lineAlarmsMap = lineAlarms.stream().collect(Collectors.groupingBy(AlarmPO::getDeviceId));
// 获取终端在线率
List<AlarmPO> deviceOnlineRate = deviceAbnormaStatisticsMapper.getOnlineRateByDevice(
devIds,
DateUtil.beginOfDay(DateUtil.parse(param.getTime())),
DateUtil.endOfDay(DateUtil.parse(param.getTime())));
Map<String, List<AlarmPO>> deviceOnlineMap = deviceOnlineRate.stream().collect(Collectors.groupingBy(AlarmPO::getDeviceId));
// 获取设备流量
List<AlarmPO> deviceFlow = deviceAbnormaStatisticsMapper.getFlowByDevice(devIds,param.getTime().substring(0,7));
if (CollectionUtil.isNotEmpty(deviceFlow)) {
deviceFlowMap = deviceFlow.stream().collect(Collectors.groupingBy(AlarmPO::getDeviceId));
}
// 获取通信中断信息
List<TopMsgPO> comMsgs = getPqsCommunicate(devIds, param.getTime());
if (CollectionUtil.isNotEmpty(comMsgs)) {
comMap = comMsgs.stream().collect(Collectors.groupingBy(TopMsgPO::getDevId));
}
// 整合装置信息
List<TopMsgPO> topMsgPOS = new ArrayList<>();
for (Map.Entry<String, List<AlarmPO>> devEntry : devMap.entrySet()) {
TopMsgPO topMsg = new TopMsgPO();
topMsg.setDevId(devEntry.getKey());
int deviceLevel = devEntry.getValue().stream().mapToInt(AlarmPO::getLevel).min().orElse(-1);
// 装置等级
topMsg.setDeviceLevel(deviceLevel);
// 等级对应的告警策略
AlarmStrategyVO alarmStrategyVO = levMap.get(deviceLevel).get(0);
// 数据完整性
if (lineIntegrityMap.containsKey(devEntry.getKey())) {
topMsg.setIntegrityFlag(lineIntegrityMap.get(devEntry.getKey()).get(0).getIntegrity() < alarmStrategyVO.getIntegrityValue() ? 0 : 1);
topMsg.setIntegrityValue(lineIntegrityMap.get(devEntry.getKey()).get(0).getIntegrity());
} else {
topMsg.setIntegrityFlag(-1);
}
// 装置告警
if (lineAlarmsMap.containsKey(devEntry.getKey())) {
List<AlarmPO> lineAlarmPOS = lineAlarmsMap.get(devEntry.getKey());
int alarmCount = lineAlarmPOS.stream().mapToInt(AlarmPO::getAlarmCount).sum();
String alarmDesc = String.join(",", lineAlarmPOS.stream().map(AlarmPO::getAlarmDesc).collect(Collectors.toList()));
topMsg.setAlarmCountFlag(alarmCount > alarmStrategyVO.getWarnValue() ? 0 : 1);
topMsg.setAlarmCount(alarmCount);
topMsg.setAlarmDesc(alarmDesc);
} else {
topMsg.setAlarmCountFlag(1);
topMsg.setAlarmCount(0);
}
// 在线率
if (deviceOnlineMap.containsKey(devEntry.getKey())) {
AlarmPO alarmPO = deviceOnlineMap.get(devEntry.getKey()).get(0);
topMsg.setOnlineRateFlag(alarmPO.getOnlineRate() * 100 < alarmStrategyVO.getOnlineValue() ? 0 : 1);
topMsg.setOnlineRateValue(alarmPO.getOnlineRate() *100);
} else {
topMsg.setOnlineRateFlag(-1);
}
// 流量
if (deviceFlowMap.containsKey(devEntry.getKey()) && Objects.nonNull(deviceFlowMap.get(devEntry.getKey()).get(0).getFlowProportion())) {
AlarmPO alarmPO = deviceFlowMap.get(devEntry.getKey()).get(0);
topMsg.setFlowFlag(alarmPO.getActualValue() > alarmPO.getFlowMeal() ? 0 : 1);
topMsg.setFlowValue(alarmPO.getFlowProportion());
} else {
topMsg.setFlowFlag(-1);
}
if (comMap.containsKey(devEntry.getKey())) {
TopMsgPO comOutPO = comMap.get(devEntry.getKey()).get(0);
List<PqsCommunicate> abnormals = comOutPO.getCommunicates().stream().filter(t -> t.getDuration() > alarmStrategyVO.getOffTimeValue()).collect(Collectors.toList());
topMsg.setOfftimeFlag(abnormals.size() > 0 ? 0 :1);
topMsg.setComOutCount(abnormals.size());
List<String> abnormalDesc = abnormals.stream().map(PqsCommunicate::getDesc).collect(Collectors.toList());
topMsg.setComOutDescription(String.join(",",abnormalDesc));
} else {
topMsg.setOfftimeFlag(1);
topMsg.setComOutCount(0);
}
if (topMsg.getFlowFlag() ==0 || topMsg.getIntegrityFlag() ==0 || topMsg.getOfftimeFlag() == 0
|| topMsg.getAlarmCountFlag() ==0 || topMsg.getOnlineRateFlag() ==0) {
topMsgPOS.add(topMsg);
}
}
return topMsgPOS.size()>0 ? deviceAbnormaStatisticsMapper.insertTopMsg(topMsgPOS) : true;
}
@Override @Override
public void deviceAbnormaStatisticsD(CalculatedParam calculatedParam) { public void deviceAbnormaStatisticsD(CalculatedParam calculatedParam) {

37
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/device/RStatDevSignalDPOServiceImpl.java
View File

@@ -17,10 +17,8 @@ import com.njcn.system.api.DicDataFeignClient;
import com.njcn.system.enums.DicDataEnum; import com.njcn.system.enums.DicDataEnum;
import com.njcn.system.pojo.po.DictData; import com.njcn.system.pojo.po.DictData;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.ListUtils; import org.apache.commons.collections4.ListUtils;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
@@ -98,39 +96,4 @@ public class RStatDevSignalDPOServiceImpl extends MppServiceImpl<RStatDevSignalD
} }
} }
// public void eventdetailHandler(DeviceParam deviceParam) {
// List<RStatDevSignalDPO> rStatDevSignalDPOList = new ArrayList<>();
// Date date = DateUtil.parse(deviceParam.getDataDate());
// QueryWrapper<RMpMonitorEvaluateDPO> wrapper = new QueryWrapper<>();
// DictData data = dicDataFeignClient.getDicDataByCode(DicDataEnum.RUNNING.getCode()).getData();
// deviceParam.getDetailList().forEach(temp -> {
//
// RStatDevSignalDPO rStatDevSignalDPO = new RStatDevSignalDPO();
// rStatDevSignalDPO.setDeviceId(temp.getDevId());
// rStatDevSignalDPO.setDeviceStatus(data.getId());
// rStatDevSignalDPO.setUpdateTime(temp.getUpdateTime());
// rStatDevSignalDPO.setDataDate(date);
// /**
// * 1、运行状态：设备下任意一个监测点有效接入分钟数（effective_minute_count > 0）为在线状态，反之离线状态
// */
// Integer effective_minute_count = 0;
// List<String> lineIds = temp.getLineIds();
// if (CollUtil.isNotEmpty(lineIds)) {
// wrapper.clear();
// wrapper.select("sum(effective_minute_count) as effective_minute_count ");
// wrapper.eq("device_id", temp.getDevId());
// wrapper.in("measurement_point_id", lineIds);
// RMpMonitorEvaluateDPO rMpMonitorEvaluateDPO = revaluateDMapper.selectOne(wrapper);
// effective_minute_count = rMpMonitorEvaluateDPO.getEffectiveMinuteCount();
// }
// String runStatus = "0";
// if (effective_minute_count > 0 && temp.getDeviceStatus().equals("1")) {
// runStatus = "1";
// }
// rStatDevSignalDPO.setRunStatus(runStatus);
// rStatDevSignalDPOList.add(rStatDevSignalDPO);
//
// });
// this.saveOrUpdateBatchByMultiId(rStatDevSignalDPOList, 500);
// }
} }

365
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/line/AlarmDetailServiceImpl.java
View File

@@ -1,9 +1,6 @@
package com.njcn.prepare.harmonic.service.mysql.Impl.line; package com.njcn.prepare.harmonic.service.mysql.Impl.line;
import com.github.jeffreyning.mybatisplus.service.MppServiceImpl; import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
import com.njcn.device.pms.api.DistributionMonitorClient;
import com.njcn.device.pms.api.MonitorClient;
import com.njcn.prepare.harmonic.mapper.mysql.area.RMpTargetWarnDMapper;
import com.njcn.prepare.harmonic.mapper.mysql.day.RStatDataVDMapper; import com.njcn.prepare.harmonic.mapper.mysql.day.RStatDataVDMapper;
import com.njcn.prepare.harmonic.mapper.mysql.line.*; import com.njcn.prepare.harmonic.mapper.mysql.line.*;
import com.njcn.prepare.harmonic.pojo.bo.CalculatedParam; import com.njcn.prepare.harmonic.pojo.bo.CalculatedParam;
@@ -11,11 +8,9 @@ import com.njcn.prepare.harmonic.pojo.dto.AlarmDetailDayDTO;
import com.njcn.prepare.harmonic.pojo.mysql.po.line.RMpTargetDiffDPO; import com.njcn.prepare.harmonic.pojo.mysql.po.line.RMpTargetDiffDPO;
import com.njcn.prepare.harmonic.service.mysql.line.AlarmDetailService; import com.njcn.prepare.harmonic.service.mysql.line.AlarmDetailService;
import com.njcn.prepare.harmonic.utils.PublicUtil; import com.njcn.prepare.harmonic.utils.PublicUtil;
import com.njcn.system.api.DicDataFeignClient;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.ListUtils; import org.apache.commons.collections4.ListUtils;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils; import org.springframework.util.CollectionUtils;
@@ -38,50 +33,8 @@ import java.util.stream.Collectors;
@Slf4j @Slf4j
public class AlarmDetailServiceImpl extends MppServiceImpl<AlarmMapper, RMpTargetDiffDPO> implements AlarmDetailService { public class AlarmDetailServiceImpl extends MppServiceImpl<AlarmMapper, RMpTargetDiffDPO> implements AlarmDetailService {
private final DistributionMonitorClient distributionMonitorClient;
private final MonitorClient monitorClient;
private final DicDataFeignClient dicDataFeignClient;
private final RMpTargetWarnDMapper rMpTargetWarnDMapper;
private final RMpMeasurePhaseReportDPOMapper rMpMeasurePhaseReportDPOMapper;
private final RMpMeasureReportDPOMapper rMpMeasureReportDPOMapper;
private final RMpHarmonicVRateReportDPOMapper rMpHarmonicVRateReportDPOMapper;
private final RMpEventDetailDMapper rMpEventDetailDMapper;
private final RMpPltReportDPOMapper rMpPltReportDPOMapper;
private final RStatDataVDMapper rStatDataVDMapper; private final RStatDataVDMapper rStatDataVDMapper;
// @Override
// @Transactional(rollbackFor = {Exception.class})
// @Async("asyncExecutor")
// public void targetDiff(LineParam lineParam) {
// String startTime,endTime;
// //月处理
// if (Objects.equals(true,lineParam.getRepairFlag())){
// List<String> rangeDate = NjcnDateUtils.findEveryDay(lineParam.getBeginTime(),lineParam.getEndTime());
// for (String item : rangeDate) {
// log.info(item+"-->开始执行");
// startTime = item + " 00:00:00";
// endTime = PublicUtil.getYesterday(item) + " 00:00:00";
// diffData(startTime,endTime,lineParam.getLineIds());
// }
// }
// //日处理
// else {
// startTime = lineParam.getBeginTime();
// endTime = PublicUtil.getYesterday(lineParam.getDataDate()) + " 00:00:00";
// diffData(startTime,endTime,lineParam.getLineIds());
// }
// }
/*******************************************新算法***********************************************************************/
@Override @Override
@Transactional(rollbackFor = {Exception.class}) @Transactional(rollbackFor = {Exception.class})
public void targetDiff(CalculatedParam calculatedParam) { public void targetDiff(CalculatedParam calculatedParam) {
@@ -102,7 +55,7 @@ public class AlarmDetailServiceImpl extends MppServiceImpl<AlarmMapper, RMpTarge
/** /**
* 生成指标差值日统计 * 生成指标差值日统计
*/ */
public List<RMpTargetDiffDPO> diffData(String startTime, String endTime, List<String> list) { private List<RMpTargetDiffDPO> diffData(String startTime, String endTime, List<String> list) {
List<RMpTargetDiffDPO> intersectionList = new ArrayList<>(); List<RMpTargetDiffDPO> intersectionList = new ArrayList<>();
List<RMpTargetDiffDPO> localData = rStatDataVDMapper.getDayData(startTime,list); List<RMpTargetDiffDPO> localData = rStatDataVDMapper.getDayData(startTime,list);
List<RMpTargetDiffDPO> yesterdayData = rStatDataVDMapper.getDayData(endTime,list); List<RMpTargetDiffDPO> yesterdayData = rStatDataVDMapper.getDayData(endTime,list);
@@ -131,320 +84,4 @@ public class AlarmDetailServiceImpl extends MppServiceImpl<AlarmMapper, RMpTarge
return this.baseMapper.getAvgDiffData(endTime,time,list); return this.baseMapper.getAvgDiffData(endTime,time,list);
} }
// /**
// * 处理数据（电压偏差告警日统计）
// * @author qijian
// * @date 2022/12/28
// */
// private void processVoltageDeviationAlarm(String date, Integer type, String lineId) {
// //日期条件（取前天、昨天、今天）
// LocalDate localDate = LocalDate.parse(date);
// LocalDate yesterday = localDate.plusDays(-1);
// LocalDate beforeYesterday = yesterday.plusDays(-1);
// double localMax = rMpMeasurePhaseReportDPOMapper.getMaxVDeUp(lineId, localDate);
// double yesterdayMax = rMpMeasurePhaseReportDPOMapper.getMaxVDeUp(lineId, yesterday);
// double beforeYesterdayMax = rMpMeasurePhaseReportDPOMapper.getMaxVDeUp(lineId, beforeYesterday);
//
// //计算RM和CL值
// double rm = ((localMax - yesterdayMax) + (yesterdayMax - beforeYesterdayMax)) / 2;
// double cl = (localMax + yesterdayMax + beforeYesterdayMax) / 3;
//
// //计算RL和UCL值
// double rl = rm * 3.3;
// double ucl = cl + rm * 3;
//
// //如果本日最大值>UCL 且 本日最大值>昨日最大值，则告警
// if (localMax > ucl && localMax > yesterdayMax){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsVDevWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
//
// //如果本日>昨日>前日，且前日的值超过RL值，则告警
// if (localMax > yesterdayMax && yesterdayMax > beforeYesterdayMax && beforeYesterdayMax > rl){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsVDevWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
// }
// /**
// * 处理数据（频率偏差告警日统计）
// * @author qijian
// * @date 2022/12/29
// */
// private void processFrequencyDeviationAlarm(String date, Integer type, String lineId) {
// //日期条件（取前天、昨天、今天）
// LocalDate localDate = LocalDate.parse(date);
// LocalDate yesterday = localDate.plusDays(-1);
// LocalDate beforeYesterday = yesterday.plusDays(-1);
// double localMax = rMpMeasureReportDPOMapper.getMaxFrequencyDeviation(lineId, localDate);
// double yesterdayMax = rMpMeasureReportDPOMapper.getMaxFrequencyDeviation(lineId, yesterday);
// double beforeYesterdayMax = rMpMeasureReportDPOMapper.getMaxFrequencyDeviation(lineId, beforeYesterday);
//
// //计算RM和CL值
// double rm = ((localMax - yesterdayMax) + (yesterdayMax - beforeYesterdayMax)) / 2;
// double cl = (localMax + yesterdayMax + beforeYesterdayMax) / 3;
//
// //计算RL和UCL值
// double rl = rm * 3.3;
// double ucl = cl + rm * 3;
//
// //如果本日最大值>UCL 且 本日最大值>昨日最大值，则告警
// if (localMax > ucl && localMax > yesterdayMax){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsFreqWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
//
// //如果本日>昨日>前日，且前日的值超过RL值，则告警
// if (localMax > yesterdayMax && yesterdayMax > beforeYesterdayMax && beforeYesterdayMax > rl){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsFreqWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
// }
// /**
// * 处理数据（三相电压不平衡告警日统计）
// * @author qijian
// * @date 2022/12/29
// */
// private void processUnbalance95Alarm(String date, Integer type, String lineId) {
// //日期条件（取前天、昨天、今天）
// LocalDate localDate = LocalDate.parse(date);
// LocalDate yesterday = localDate.plusDays(-1);
// LocalDate beforeYesterday = yesterday.plusDays(-1);
// double localMax = rMpMeasureReportDPOMapper.getMaxUnbalance95(lineId, localDate);
// double yesterdayMax = rMpMeasureReportDPOMapper.getMaxUnbalance95(lineId, yesterday);
// double beforeYesterdayMax = rMpMeasureReportDPOMapper.getMaxUnbalance95(lineId, beforeYesterday);
//
// //计算RM和CL值
// double rm = ((localMax - yesterdayMax) + (yesterdayMax - beforeYesterdayMax)) / 2;
// double cl = (localMax + yesterdayMax + beforeYesterdayMax) / 3;
//
// //计算RL和UCL值
// double rl = rm * 3.3;
// double ucl = cl + rm * 3;
//
// //如果本日最大值>UCL 且 本日最大值>昨日最大值，则告警
// if (localMax > ucl && localMax > yesterdayMax){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsUnbalanceWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
//
// //如果本日>昨日>前日，且前日的值超过RL值，则告警
// if (localMax > yesterdayMax && yesterdayMax > beforeYesterdayMax && beforeYesterdayMax > rl){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsUnbalanceWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
// }
// /**
// * 处理数据（谐波电压告警日统计）
// * @author qijian
// * @date 2022/12/29
// */
// private void processVoltageHarmonicThd95Alarm(String date, Integer type, String lineId) {
// //日期条件（取前天、昨天、今天）
// LocalDate localDate = LocalDate.parse(date);
// LocalDate yesterday = localDate.plusDays(-1);
// LocalDate beforeYesterday = yesterday.plusDays(-1);
// double localMax = rMpHarmonicVRateReportDPOMapper.getMaxVoltageHarmonicThd95(lineId, localDate);
// double yesterdayMax = rMpHarmonicVRateReportDPOMapper.getMaxVoltageHarmonicThd95(lineId, yesterday);
// double beforeYesterdayMax = rMpHarmonicVRateReportDPOMapper.getMaxVoltageHarmonicThd95(lineId, beforeYesterday);
//
// //计算RM和CL值
// double rm = ((localMax - yesterdayMax) + (yesterdayMax - beforeYesterdayMax)) / 2;
// double cl = (localMax + yesterdayMax + beforeYesterdayMax) / 3;
//
// //计算RL和UCL值
// double rl = rm * 3.3;
// double ucl = cl + rm * 3;
//
// //如果本日最大值>UCL 且 本日最大值>昨日最大值，则告警
// if (localMax > ucl && localMax > yesterdayMax){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsVWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
//
// //如果本日>昨日>前日，且前日的值超过RL值，则告警
// if (localMax > yesterdayMax && yesterdayMax > beforeYesterdayMax && beforeYesterdayMax > rl){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsVWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
// }
// /**
// * 处理数据（长时电压闪变告警日统计）
// * @author qijian
// * @date 2022/12/30
// */
// private void processFlashingAlarm(String date, Integer type, String lineId) {
// //日期条件（取前天、昨天、今天）
// LocalDate localDate = LocalDate.parse(date);
// LocalDate yesterday = localDate.plusDays(-1);
// LocalDate beforeYesterday = yesterday.plusDays(-1);
// double localMax = rMpPltReportDPOMapper.getMaxFlashing(lineId, localDate);
// double yesterdayMax = rMpPltReportDPOMapper.getMaxFlashing(lineId, yesterday);
// double beforeYesterdayMax = rMpPltReportDPOMapper.getMaxFlashing(lineId, beforeYesterday);
//
// //计算RM和CL值
// double rm = ((localMax - yesterdayMax) + (yesterdayMax - beforeYesterdayMax)) / 2;
// double cl = (localMax + yesterdayMax + beforeYesterdayMax) / 3;
//
// //计算RL和UCL值
// double rl = rm * 3.3;
// double ucl = cl + rm * 3;
//
// //如果本日最大值>UCL 且 本日最大值>昨日最大值，则告警
// if (localMax > ucl && localMax > yesterdayMax){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsFlickerWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
//
// //如果本日>昨日>前日，且前日的值超过RL值，则告警
// if (localMax > yesterdayMax && yesterdayMax > beforeYesterdayMax && beforeYesterdayMax > rl){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsFlickerWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
// }
// /**
// * 处理数据（电压暂降告警日统计）
// * @author qijian
// * @date 2022/12/29
// */
// private void processSagTimesAlarm(String date, Integer type, String lineId) {
// //日期条件（取前天、昨天、今天）
// LocalDate localDate = LocalDate.parse(date);
// LocalDate yesterday = localDate.plusDays(-1);
// LocalDate beforeYesterday = yesterday.plusDays(-1);
// int localMax = rMpEventDetailDMapper.getSagTimes(lineId, localDate);
// int yesterdayMax = rMpEventDetailDMapper.getSagTimes(lineId, yesterday);
// int beforeYesterdayMax = rMpEventDetailDMapper.getSagTimes(lineId, beforeYesterday);
//
// //计算RM和CL值
// double rm = ((localMax - yesterdayMax) + (yesterdayMax - beforeYesterdayMax)) / 2;
// double cl = (localMax + yesterdayMax + beforeYesterdayMax) / 3;
//
// //计算RL和UCL值
// double rl = rm * 3.3;
// double ucl = cl + rm * 3;
//
// //如果本日最大值>UCL 且 本日最大值>昨日最大值，则告警
// if (localMax > ucl && localMax > yesterdayMax){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsSagWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
//
// //如果本日>昨日>前日，且前日的值超过RL值，则告警
// if (localMax > yesterdayMax && yesterdayMax > beforeYesterdayMax && beforeYesterdayMax > rl){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsSagWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
// }
// /**
// * 处理数据（电压短时中断告警日统计）
// * @author qijian
// * @date 2022/12/29
// */
// private void processInterruptTimesAlarm(String date, Integer type, String lineId) {
// //日期条件（取前天、昨天、今天）
// LocalDate localDate = LocalDate.parse(date);
// LocalDate yesterday = localDate.plusDays(-1);
// LocalDate beforeYesterday = yesterday.plusDays(-1);
// int localMax = rMpEventDetailDMapper.getInterruptTimes(lineId, localDate);
// int yesterdayMax = rMpEventDetailDMapper.getInterruptTimes(lineId, yesterday);
// int beforeYesterdayMax = rMpEventDetailDMapper.getInterruptTimes(lineId, beforeYesterday);
//
// //计算RM和CL值
// double rm = ((localMax - yesterdayMax) + (yesterdayMax - beforeYesterdayMax)) / 2;
// double cl = (localMax + yesterdayMax + beforeYesterdayMax) / 3;
//
// //计算RL和UCL值
// double rl = rm * 3.3;
// double ucl = cl + rm * 3;
//
// //如果本日最大值>UCL 且 本日最大值>昨日最大值，则告警
// if (localMax > ucl && localMax > yesterdayMax){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsInterruptWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
//
// //如果本日>昨日>前日，且前日的值超过RL值，则告警
// if (localMax > yesterdayMax && yesterdayMax > beforeYesterdayMax && beforeYesterdayMax > rl){
// RMpTargetWarnDPO rMpTargetWarnD = new RMpTargetWarnDPO();
// rMpTargetWarnD.setMeasurementPointId(lineId);
// rMpTargetWarnD.setDataDate(DateUtil.parse(date));
// rMpTargetWarnD.setIsInterruptWarn(1);
// addAlarmData(rMpTargetWarnD);
// return;
// }
// }
// /**
// * 存入数据库
// * @author qijian
// * @date 2022/12/28
// */
// private void addAlarmData(RMpTargetWarnDPO rMpTargetWarnD) {
// LambdaQueryWrapper<RMpTargetWarnDPO> lambdaQueryWrapper = new LambdaQueryWrapper<>();
// lambdaQueryWrapper.eq(RMpTargetWarnDPO::getMeasurementPointId, rMpTargetWarnD.getMeasurementPointId()).eq(RMpTargetWarnDPO::getDataDate, rMpTargetWarnD.getDataDate());
// RMpTargetWarnDPO rMpTargetWarnDOne = rMpTargetWarnDMapper.selectOne(lambdaQueryWrapper);
// if (Objects.nonNull(rMpTargetWarnDOne)) {
// rMpTargetWarnDMapper.update(rMpTargetWarnD, lambdaQueryWrapper);
// } else {
// rMpTargetWarnDMapper.insert(rMpTargetWarnD);
// }
// }
} }

Some files were not shown because too many files have changed in this diff Show More