From f86a3c4167a9e48a59d8357bb78ba3c204298195 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B4=BE=E5=90=8C=E5=AD=A6?= Date: Thu, 4 Dec 2025 10:22:51 +0800 Subject: [PATCH] =?UTF-8?q?=E6=A8=A1=E5=9D=97=E8=BF=81=E7=A7=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../njcn/csdevice/api/OverLimitClient.java | 39 + .../fallback/OverLimitFallbackFactory.java | 49 + .../com/njcn/csdevice/pojo/po/Overlimit.java | 953 ++++++++++++++++++ .../csdevice/pojo/vo/LineOverLimitVO.java | 120 +++ .../njcn/csdevice/utils/COverlimitUtil.java | 383 +++++++ .../controller/PQOverlimitController.java | 104 ++ .../controller/line/CslineController.java | 4 +- .../njcn/csdevice/mapper/OverlimitMapper.java | 2 +- .../mapper/mapping/OverlimitMapper.xml | 20 + .../csdevice/service/IOverLimitService.java | 28 + .../service/OverlimitServiceImpl.java | 21 - .../service/impl/CsGroupServiceImpl.java | 1 - .../csdevice/service/impl/IcdServiceImpl.java | 3 +- .../service/impl/OverLimitServiceImpl.java | 42 + .../service/impl/OverlimitService.java | 17 - .../service/impl/WlRecordServiceImpl.java | 15 +- .../njcn/csharmonic/annotaion/HarCurrent.java | 9 + .../njcn/csharmonic/annotaion/HarVoltage.java | 9 + .../csharmonic/annotaion/InterharVoltage.java | 11 + .../pojo/param/LimitCalendarQueryParam.java | 9 + .../pojo/param/LimitExtentDayQueryParam.java | 23 + .../pojo/param/LimitExtentQueryParam.java | 9 + .../param/LimitProbabilityQueryParam.java | 9 + .../pojo/param/MainLineQueryParam.java | 35 + ...ainLineStatLimitRateDetailsQueryParam.java | 23 + .../pojo/param/RStatLimitQueryParam.java | 27 + .../param/StatSubstationBizBaseParam.java | 39 + ...TotalLimitStatisticsDetailsQueryParam.java | 9 + .../pojo/param/TotalLimitStatisticsParam.java | 19 + .../csharmonic/pojo/po/RStatLimitRateDPO.java | 614 +++++++++++ .../pojo/po/RStatLimitRateDetailDPO.java | 594 +++++++++++ .../csharmonic/pojo/vo/LimitCalendarVO.java | 23 + .../csharmonic/pojo/vo/LimitExtentVO.java | 49 + .../pojo/vo/LimitProbabilityVO.java | 22 + .../pojo/vo/LimitTimeProbabilityVO.java | 21 + .../vo/MainLineStatLimitRateDetailsVO.java | 11 + .../njcn/csharmonic/pojo/vo/MainLineVO.java | 21 + .../pojo/vo/MonitorOverLimitVO.java | 145 +++ .../csharmonic/pojo/vo/RStatLimitRateDVO.java | 34 + .../vo/TotalLimitStatisticsDetailsVO.java | 207 ++++ .../pojo/vo/TotalLimitStatisticsVO.java | 15 + .../pojo/vo/TotalLimitTotalStatisticsVO.java | 19 + cs-harmonic/cs-harmonic-boot/pom.xml | 5 - .../controller/RStatLimitRateDController.java | 159 +++ .../RStatLimitRateDetailDController.java | 85 ++ .../mapper/RStatLimitRateDMapper.java | 76 ++ .../mapper/RStatLimitRateDetailDMapper.java | 9 + .../mapper/mapping/RStatLimitRateDMapper.xml | 475 +++++++++ .../mapping/RStatLimitRateDetailDMapper.xml | 6 + .../service/IRStatLimitRateDService.java | 48 + .../IRStatLimitRateDetailDService.java | 30 + .../impl/RStatLimitRateDServiceImpl.java | 600 +++++++++++ .../RStatLimitRateDetailDServiceImpl.java | 549 ++++++++++ 53 files changed, 5789 insertions(+), 60 deletions(-) create mode 100644 cs-device/cs-device-api/src/main/java/com/njcn/csdevice/api/OverLimitClient.java create mode 100644 cs-device/cs-device-api/src/main/java/com/njcn/csdevice/api/fallback/OverLimitFallbackFactory.java create mode 100644 cs-device/cs-device-api/src/main/java/com/njcn/csdevice/pojo/po/Overlimit.java create mode 100644 cs-device/cs-device-api/src/main/java/com/njcn/csdevice/pojo/vo/LineOverLimitVO.java create mode 100644 cs-device/cs-device-api/src/main/java/com/njcn/csdevice/utils/COverlimitUtil.java create mode 100644 cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/controller/PQOverlimitController.java create mode 100644 cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/mapper/mapping/OverlimitMapper.xml create mode 100644 cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/IOverLimitService.java delete mode 100644 cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/OverlimitServiceImpl.java create mode 100644 cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/OverLimitServiceImpl.java delete mode 100644 cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/OverlimitService.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/HarCurrent.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/HarVoltage.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/InterharVoltage.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitCalendarQueryParam.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitExtentDayQueryParam.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitExtentQueryParam.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitProbabilityQueryParam.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/MainLineQueryParam.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/MainLineStatLimitRateDetailsQueryParam.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/RStatLimitQueryParam.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/StatSubstationBizBaseParam.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/TotalLimitStatisticsDetailsQueryParam.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/TotalLimitStatisticsParam.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/po/RStatLimitRateDPO.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/po/RStatLimitRateDetailDPO.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitCalendarVO.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitExtentVO.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitProbabilityVO.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitTimeProbabilityVO.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MainLineStatLimitRateDetailsVO.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MainLineVO.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MonitorOverLimitVO.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/RStatLimitRateDVO.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitStatisticsVO.java create mode 100644 cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitTotalStatisticsVO.java create mode 100644 cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/controller/RStatLimitRateDController.java create mode 100644 cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/controller/RStatLimitRateDetailDController.java create mode 100644 cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/RStatLimitRateDMapper.java create mode 100644 cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/RStatLimitRateDetailDMapper.java create mode 100644 cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/mapping/RStatLimitRateDMapper.xml create mode 100644 cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/mapping/RStatLimitRateDetailDMapper.xml create mode 100644 cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/IRStatLimitRateDService.java create mode 100644 cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/IRStatLimitRateDetailDService.java create mode 100644 cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/impl/RStatLimitRateDServiceImpl.java create mode 100644 cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/impl/RStatLimitRateDetailDServiceImpl.java diff --git a/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/api/OverLimitClient.java b/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/api/OverLimitClient.java new file mode 100644 index 0000000..9eeb5bb --- /dev/null +++ b/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/api/OverLimitClient.java @@ -0,0 +1,39 @@ +package com.njcn.csdevice.api; + +import com.njcn.common.pojo.constant.ServerInfo; +import com.njcn.common.pojo.response.HttpResult; +import com.njcn.csdevice.api.fallback.OverLimitFallbackFactory; +import com.njcn.csdevice.pojo.po.Overlimit; +import org.springframework.cloud.openfeign.FeignClient; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; + +import java.util.List; +import java.util.Map; + +/** + * 监测点数据完整性 + * @author cdf + * @date 2023/6/7 + */ +@FeignClient(value = ServerInfo.CS_DEVICE_BOOT, + path = "/overLimit", + fallbackFactory = OverLimitFallbackFactory.class,contextId = "overLimit") +public interface OverLimitClient { + + /** + * + * @author cdf + * @date 2023/6/7 + */ + @PostMapping("/getOverLimitByLineIds") + HttpResult> getOverLimitByLineIds(@RequestBody List lineIds); + + /** + * + * @author cdf + * @date 2023/6/7 + */ + @PostMapping("/getLimitMapsByLineIds") + HttpResult>> getLimitMapsByLineIds(@RequestBody List lineIds); +} diff --git a/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/api/fallback/OverLimitFallbackFactory.java b/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/api/fallback/OverLimitFallbackFactory.java new file mode 100644 index 0000000..85b6c17 --- /dev/null +++ b/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/api/fallback/OverLimitFallbackFactory.java @@ -0,0 +1,49 @@ +package com.njcn.csdevice.api.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.csdevice.api.OverLimitClient; +import com.njcn.csdevice.pojo.po.Overlimit; +import com.njcn.device.biz.utils.DeviceEnumUtil; +import feign.hystrix.FallbackFactory; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Component; + +import java.util.List; +import java.util.Map; + +/** + * 告警管理熔断降级 + * @author yzh + * @date 2022/9/19 + */ +@Slf4j +@Component +public class OverLimitFallbackFactory implements FallbackFactory { + @Override + public OverLimitClient create(Throwable throwable) { + //判断抛出异常是否为解码器抛出的业务异常 + Enum exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK; + if (throwable.getCause() instanceof BusinessException) { + BusinessException businessException = (BusinessException) throwable.getCause(); + exceptionEnum = DeviceEnumUtil.getExceptionEnum(businessException.getResult()); + } + Enum finalExceptionEnum = exceptionEnum; + return new OverLimitClient() { + @Override + public HttpResult> getOverLimitByLineIds(List lineIds) { + log.error("{}异常，降级处理，异常为：{}", "监测点限值", throwable.toString()); + throw new BusinessException(finalExceptionEnum); + } + + @Override + public HttpResult>> getLimitMapsByLineIds(List lineIds) { + log.error("{}异常，降级处理，异常为：{}", "获取监测点限值map", throwable.toString()); + throw new BusinessException(finalExceptionEnum); + } + + }; + } +} + diff --git a/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/pojo/po/Overlimit.java b/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/pojo/po/Overlimit.java new file mode 100644 index 0000000..30aab32 --- /dev/null +++ b/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/pojo/po/Overlimit.java @@ -0,0 +1,953 @@ +package com.njcn.csdevice.pojo.po; + +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import com.njcn.device.biz.utils.COverlimit; +import lombok.Data; + +import java.io.Serializable; + +/** + *

+ * + *

+ * + * @author cdf + * @since 2022-01-04 + */ +@Data +@TableName("pq_overlimit") +public class Overlimit implements Serializable { + + private static final long serialVersionUID = 1L; + + /** + * 监测点序号 + */ + private String id; + + /** + * 频率限值 + */ + private Float freqDev; + + /** + * 电压波动 + */ + private Float voltageFluctuation; + + /** + * 电压上偏差限值 + */ + private Float voltageDev; + + /** + * 电压下偏差限值 + */ + private Float uvoltageDev; + + /** + * 三相电压不平衡度限值 + */ + private Float ubalance; + + /** + * 短时电压不平衡度限值 + */ + private Float shortUbalance; + + /** + * 闪变限值 + */ + private Float flicker; + + /** + * 电压总谐波畸变率限值 + */ + private Float uaberrance; + + /** + * 负序电流限值 + */ + private Float iNeg; + + /** + * 2次谐波电压限值 + */ + @TableField("uharm_2") + private Float uharm2; + + /** + * 3次谐波电压限值 + */ + @TableField("uharm_3") + private Float uharm3; + + /** + * 4次谐波电压限值 + */ + @TableField("uharm_4") + private Float uharm4; + + /** + * 5次谐波电压限值 + */ + @TableField("uharm_5") + private Float uharm5; + + /** + * 6次谐波电压限值 + */ + @TableField("uharm_6") + private Float uharm6; + + /** + * 7次谐波电压限值 + */ + @TableField("uharm_7") + private Float uharm7; + + /** + * 8次谐波电压限值 + */ + @TableField("uharm_8") + private Float uharm8; + + /** + * 9次谐波电压限值 + */ + @TableField("uharm_9") + private Float uharm9; + + /** + * 10次谐波电压限值 + */ + @TableField("uharm_10") + private Float uharm10; + + /** + * 11次谐波电压限值 + */ + @TableField("uharm_11") + private Float uharm11; + + /** + * 12次谐波电压限值 + */ + @TableField("uharm_12") + private Float uharm12; + + /** + * 13次谐波电压限值 + */ + @TableField("uharm_13") + private Float uharm13; + + /** + * 14次谐波电压限值 + */ + @TableField("uharm_14") + private Float uharm14; + + /** + * 15次谐波电压限值 + */ + @TableField("uharm_15") + private Float uharm15; + + /** + * 16次谐波电压限值 + */ + @TableField("uharm_16") + private Float uharm16; + + /** + * 17次谐波电压限值 + */ + @TableField("uharm_17") + private Float uharm17; + + /** + * 18次谐波电压限值 + */ + @TableField("uharm_18") + private Float uharm18; + + /** + * 19次谐波电压限值 + */ + @TableField("uharm_19") + private Float uharm19; + + /** + * 20次谐波电压限值 + */ + @TableField("uharm_20") + private Float uharm20; + + /** + * 21次谐波电压限值 + */ + @TableField("uharm_21") + private Float uharm21; + + /** + * 22次谐波电压限值 + */ + @TableField("uharm_22") + private Float uharm22; + + /** + * 23次谐波电压限值 + */ + @TableField("uharm_23") + private Float uharm23; + + /** + * 24次谐波电压限值 + */ + @TableField("uharm_24") + private Float uharm24; + + /** + * 25次谐波电压限值 + */ + @TableField("uharm_25") + private Float uharm25; + + /** + * 2次谐波电压限值 + */ + @TableField("uharm_26") + private Float uharm26; + + /** + * 3次谐波电压限值 + */ + @TableField("uharm_27") + private Float uharm27; + + /** + * 4次谐波电压限值 + */ + @TableField("uharm_28") + private Float uharm28; + + /** + * 5次谐波电压限值 + */ + @TableField("uharm_29") + private Float uharm29; + + /** + * 6次谐波电压限值 + */ + @TableField("uharm_30") + private Float uharm30; + + /** + * 7次谐波电压限值 + */ + @TableField("uharm_31") + private Float uharm31; + + /** + * 8次谐波电压限值 + */ + @TableField("uharm_32") + private Float uharm32; + + /** + * 9次谐波电压限值 + */ + @TableField("uharm_33") + private Float uharm33; + + /** + * 10次谐波电压限值 + */ + @TableField("uharm_34") + private Float uharm34; + + /** + * 11次谐波电压限值 + */ + @TableField("uharm_35") + private Float uharm35; + + /** + * 12次谐波电压限值 + */ + @TableField("uharm_36") + private Float uharm36; + + /** + * 13次谐波电压限值 + */ + @TableField("uharm_37") + private Float uharm37; + + /** + * 14次谐波电压限值 + */ + @TableField("uharm_38") + private Float uharm38; + + /** + * 15次谐波电压限值 + */ + @TableField("uharm_39") + private Float uharm39; + + /** + * 16次谐波电压限值 + */ + @TableField("uharm_40") + private Float uharm40; + + /** + * 17次谐波电压限值 + */ + @TableField("uharm_41") + private Float uharm41; + + /** + * 18次谐波电压限值 + */ + @TableField("uharm_42") + private Float uharm42; + + /** + * 19次谐波电压限值 + */ + @TableField("uharm_43") + private Float uharm43; + + /** + * 20次谐波电压限值 + */ + @TableField("uharm_44") + private Float uharm44; + + /** + * 21次谐波电压限值 + */ + @TableField("uharm_45") + private Float uharm45; + + /** + * 22次谐波电压限值 + */ + @TableField("uharm_46") + private Float uharm46; + + /** + * 23次谐波电压限值 + */ + @TableField("uharm_47") + private Float uharm47; + + /** + * 24次谐波电压限值 + */ + @TableField("uharm_48") + private Float uharm48; + + /** + * 25次谐波电压限值 + */ + @TableField("uharm_49") + private Float uharm49; + + /** + * 50次谐波电压限值 + */ + @TableField("uharm_50") + private Float uharm50; + + + + /** + * 2次谐波电流限值 + */ + @TableField("iharm_2") + private Float iharm2; + + /** + * 3次谐波电流限值 + */ + @TableField("iharm_3") + private Float iharm3; + + /** + * 4次谐波电流限值 + */ + @TableField("iharm_4") + private Float iharm4; + + /** + * 5次谐波电流限值 + */ + @TableField("iharm_5") + private Float iharm5; + + /** + * 6次谐波电流限值 + */ + @TableField("iharm_6") + private Float iharm6; + + /** + * 7次谐波电流限值 + */ + @TableField("iharm_7") + private Float iharm7; + + /** + * 8次谐波电流限值 + */ + @TableField("iharm_8") + private Float iharm8; + + /** + * 9次谐波电流限值 + */ + @TableField("iharm_9") + private Float iharm9; + + /** + * 10次谐波电流限值 + */ + @TableField("iharm_10") + private Float iharm10; + + /** + * 11次谐波电流限值 + */ + @TableField("iharm_11") + private Float iharm11; + + /** + * 12次谐波电流限值 + */ + @TableField("iharm_12") + private Float iharm12; + + /** + * 13次谐波电流限值 + */ + @TableField("iharm_13") + private Float iharm13; + + /** + * 14次谐波电流限值 + */ + @TableField("iharm_14") + private Float iharm14; + + /** + * 15次谐波电流限值 + */ + @TableField("iharm_15") + private Float iharm15; + + /** + * 16次谐波电流限值 + */ + @TableField("iharm_16") + private Float iharm16; + + /** + * 17次谐波电流限值 + */ + @TableField("iharm_17") + private Float iharm17; + + /** + * 18次谐波电流限值 + */ + @TableField("iharm_18") + private Float iharm18; + + /** + * 19次谐波电流限值 + */ + @TableField("iharm_19") + private Float iharm19; + + /** + * 20次谐波电流限值 + */ + @TableField("iharm_20") + private Float iharm20; + + /** + * 21次谐波电流限值 + */ + @TableField("iharm_21") + private Float iharm21; + + /** + * 22次谐波电流限值 + */ + @TableField("iharm_22") + private Float iharm22; + + /** + * 23次谐波电流限值 + */ + @TableField("iharm_23") + private Float iharm23; + + /** + * 24次谐波电流限值 + */ + @TableField("iharm_24") + private Float iharm24; + + /** + * 25次谐波电流限值 + */ + @TableField("iharm_25") + private Float iharm25; + + /** + * 2次谐波电压限值 + */ + @TableField("iharm_26") + private Float iharm26; + + /** + * 3次谐波电压限值 + */ + @TableField("iharm_27") + private Float iharm27; + + /** + * 4次谐波电压限值 + */ + @TableField("iharm_28") + private Float iharm28; + + /** + * 5次谐波电压限值 + */ + @TableField("iharm_29") + private Float iharm29; + + /** + * 6次谐波电压限值 + */ + @TableField("iharm_30") + private Float iharm30; + + /** + * 7次谐波电压限值 + */ + @TableField("iharm_31") + private Float iharm31; + + /** + * 8次谐波电压限值 + */ + @TableField("iharm_32") + private Float iharm32; + + /** + * 9次谐波电压限值 + */ + @TableField("iharm_33") + private Float iharm33; + + /** + * 10次谐波电压限值 + */ + @TableField("iharm_34") + private Float iharm34; + + /** + * 11次谐波电压限值 + */ + @TableField("iharm_35") + private Float iharm35; + + /** + * 12次谐波电压限值 + */ + @TableField("iharm_36") + private Float iharm36; + + /** + * 13次谐波电压限值 + */ + @TableField("iharm_37") + private Float iharm37; + + /** + * 14次谐波电压限值 + */ + @TableField("iharm_38") + private Float iharm38; + + /** + * 15次谐波电压限值 + */ + @TableField("iharm_39") + private Float iharm39; + + /** + * 16次谐波电压限值 + */ + @TableField("iharm_40") + private Float iharm40; + + /** + * 17次谐波电压限值 + */ + @TableField("iharm_41") + private Float iharm41; + + /** + * 18次谐波电压限值 + */ + @TableField("iharm_42") + private Float iharm42; + + /** + * 19次谐波电压限值 + */ + @TableField("iharm_43") + private Float iharm43; + + /** + * 20次谐波电压限值 + */ + @TableField("iharm_44") + private Float iharm44; + + /** + * 21次谐波电压限值 + */ + @TableField("iharm_45") + private Float iharm45; + + /** + * 22次谐波电压限值 + */ + @TableField("iharm_46") + private Float iharm46; + + /** + * 23次谐波电压限值 + */ + @TableField("iharm_47") + private Float iharm47; + + /** + * 24次谐波电压限值 + */ + @TableField("iharm_48") + private Float iharm48; + + /** + * 25次谐波电压限值 + */ + @TableField("iharm_49") + private Float iharm49; + + /** + * 50次谐波电压限值 + */ + @TableField("iharm_50") + private Float iharm50; + + + + /** + * 0.5次间谐波电压限值 + */ + @TableField("inuharm_1") + private Float inuharm1; + + /** + * 1.5次间谐波电压限值 + */ + @TableField("inuharm_2") + private Float inuharm2; + + /** + * 2.5次间谐波电压限值 + */ + @TableField("inuharm_3") + private Float inuharm3; + + /** + * 3.5次间谐波电压限值 + */ + @TableField("inuharm_4") + private Float inuharm4; + + /** + * 4.5次间谐波电压限值 + */ + @TableField("inuharm_5") + private Float inuharm5; + + /** + * 5.5次间谐波电压限值 + */ + @TableField("inuharm_6") + private Float inuharm6; + + /** + * 6.5次间谐波电压限值 + */ + @TableField("inuharm_7") + private Float inuharm7; + + /** + * 7.5次间谐波电压限值 + */ + @TableField("inuharm_8") + private Float inuharm8; + + /** + * 8.5次间谐波电压限值 + */ + @TableField("inuharm_9") + private Float inuharm9; + + /** + * 9.5次间谐波电压限值 + */ + @TableField("inuharm_10") + private Float inuharm10; + + /** + * 10.5次间谐波电压限值 + */ + @TableField("inuharm_11") + private Float inuharm11; + + /** + * 11.5次间谐波电压限值 + */ + @TableField("inuharm_12") + private Float inuharm12; + + /** + * 12.5次间谐波电压限值 + */ + @TableField("inuharm_13") + private Float inuharm13; + + /** + * 13.5次间谐波电压限值 + */ + @TableField("inuharm_14") + private Float inuharm14; + + /** + * 14.5次间谐波电压限值 + */ + @TableField("inuharm_15") + private Float inuharm15; + + /** + * 15.5次间谐波电压限值 + */ + @TableField("inuharm_16") + private Float inuharm16; + + public Overlimit(){} + + + public Overlimit(String lineId, String scaTmp, float fDLRL, float fJZRL, float fXYRL, float fSBRL){ + float[] fLimit = COverlimit.GetOverLimit(scaTmp, fDLRL, fJZRL, fXYRL, fSBRL); + this.id=lineId; + this.freqDev=fLimit[0]; + this.voltageDev=fLimit[1]; + this.ubalance=fLimit[2]; + this.flicker=fLimit[3]; + this.uaberrance=fLimit[4]; + this.uharm2=fLimit[5]; + this.uharm3=fLimit[6]; + this.uharm4=fLimit[7]; + this.uharm5=fLimit[8]; + this.uharm6=fLimit[9]; + this.uharm7=fLimit[10]; + this.uharm8=fLimit[11]; + this.uharm9=fLimit[12]; + this.uharm10=fLimit[13]; + this.uharm11=fLimit[14]; + this.uharm12=fLimit[15]; + this.uharm13=fLimit[16]; + this.uharm14=fLimit[17]; + this.uharm15=fLimit[18]; + this.uharm16=fLimit[19]; + this.uharm17=fLimit[20]; + this.uharm18=fLimit[21]; + this.uharm19=fLimit[22]; + this.uharm20=fLimit[23]; + this.uharm21=fLimit[24]; + this.uharm22=fLimit[25]; + this.uharm23=fLimit[26]; + this.uharm24=fLimit[27]; + this.uharm25=fLimit[28]; + this.iharm2=fLimit[29]; + this.iharm3=fLimit[30]; + this.iharm4=fLimit[31]; + this.iharm5=fLimit[32]; + this.iharm6=fLimit[33]; + this.iharm7=fLimit[34]; + this.iharm8=fLimit[35]; + this.iharm9=fLimit[36]; + this.iharm10=fLimit[37]; + this.iharm11=fLimit[38]; + this.iharm12=fLimit[39]; + this.iharm13=fLimit[40]; + this.iharm14=fLimit[41]; + this.iharm15=fLimit[42]; + this.iharm16=fLimit[43]; + this.iharm17=fLimit[44]; + this.iharm18=fLimit[45]; + this.iharm19=fLimit[46]; + this.iharm20=fLimit[47]; + this.iharm21=fLimit[48]; + this.iharm22=fLimit[49]; + this.iharm23=fLimit[50]; + this.iharm24=fLimit[51]; + this.iharm25=fLimit[52]; + this.uvoltageDev=fLimit[53]; + this.iNeg=fLimit[54]; + this.inuharm1=fLimit[55]; + this.inuharm2=fLimit[56]; + this.inuharm3=fLimit[57]; + this.inuharm4=fLimit[58]; + this.inuharm5=fLimit[59]; + this.inuharm6=fLimit[60]; + this.inuharm7=fLimit[61]; + this.inuharm8=fLimit[62]; + this.inuharm9=fLimit[63]; + this.inuharm10=fLimit[64]; + this.inuharm11=fLimit[65]; + this.inuharm12=fLimit[66]; + this.inuharm13=fLimit[67]; + this.inuharm14=fLimit[68]; + this.inuharm15=fLimit[69]; + this.inuharm16=fLimit[70]; + } + + public void buildIHarm(Float[] iHarmTem){ + this.iharm2= iHarmTem[0]; + this.iharm4= iHarmTem[2]; + this.iharm6= iHarmTem[4]; + this.iharm8= iHarmTem[6]; + this.iharm10= iHarmTem[8]; + this.iharm12= iHarmTem[10]; + this.iharm14= iHarmTem[12]; + this.iharm16= iHarmTem[14]; + this.iharm18= iHarmTem[16]; + this.iharm20= iHarmTem[18]; + this.iharm22= iHarmTem[20]; + this.iharm24= iHarmTem[22]; + this.iharm26= iHarmTem[24]; + this.iharm28= iHarmTem[26]; + this.iharm30= iHarmTem[28]; + this.iharm32= iHarmTem[30]; + this.iharm34= iHarmTem[32]; + this.iharm36= iHarmTem[34]; + this.iharm38= iHarmTem[36]; + this.iharm40= iHarmTem[38]; + this.iharm42= iHarmTem[40]; + this.iharm44= iHarmTem[42]; + this.iharm46= iHarmTem[44]; + this.iharm48= iHarmTem[46]; + this.iharm50= iHarmTem[48]; + + + + this.iharm3= iHarmTem[1]; + this.iharm5= iHarmTem[3]; + this.iharm7= iHarmTem[5]; + this.iharm9= iHarmTem[7]; + this.iharm11= iHarmTem[9]; + this.iharm13= iHarmTem[11]; + this.iharm15= iHarmTem[13]; + this.iharm17= iHarmTem[15]; + this.iharm19= iHarmTem[17]; + this.iharm21= iHarmTem[19]; + this.iharm23= iHarmTem[21]; + this.iharm25= iHarmTem[23]; + this.iharm27= iHarmTem[25]; + this.iharm29= iHarmTem[27]; + this.iharm31= iHarmTem[29]; + this.iharm33= iHarmTem[31]; + this.iharm35= iHarmTem[33]; + this.iharm37= iHarmTem[35]; + this.iharm39= iHarmTem[37]; + this.iharm41= iHarmTem[39]; + this.iharm43= iHarmTem[41]; + this.iharm45= iHarmTem[43]; + this.iharm47= iHarmTem[45]; + this.iharm49= iHarmTem[47]; + } + + public void buildUharm(Float resultEven,Float resultOdd){ + this.uharm2=resultEven; + this.uharm4=resultEven; + this.uharm6=resultEven; + this.uharm8=resultEven; + this.uharm10=resultEven; + this.uharm12=resultEven; + this.uharm14=resultEven; + this.uharm16=resultEven; + this.uharm18=resultEven; + this.uharm20=resultEven; + this.uharm22=resultEven; + this.uharm24=resultEven; + this.uharm26=resultEven; + this.uharm28=resultEven; + this.uharm30=resultEven; + this.uharm32=resultEven; + this.uharm34=resultEven; + this.uharm36=resultEven; + this.uharm38=resultEven; + this.uharm40=resultEven; + this.uharm42=resultEven; + this.uharm44=resultEven; + this.uharm46=resultEven; + this.uharm48=resultEven; + this.uharm50=resultEven; + + + this.uharm3=resultOdd; + this.uharm5=resultOdd; + this.uharm7=resultOdd; + this.uharm9=resultOdd; + this.uharm11=resultOdd; + this.uharm13=resultOdd; + this.uharm15=resultOdd; + this.uharm17=resultOdd; + this.uharm19=resultOdd; + this.uharm21=resultOdd; + this.uharm23=resultOdd; + this.uharm25=resultOdd; + this.uharm27=resultOdd; + this.uharm29=resultOdd; + this.uharm31=resultOdd; + this.uharm33=resultOdd; + this.uharm35=resultOdd; + this.uharm37=resultOdd; + this.uharm39=resultOdd; + this.uharm41=resultOdd; + this.uharm43=resultOdd; + this.uharm45=resultOdd; + this.uharm47=resultOdd; + this.uharm49=resultOdd; + } + + + + +} diff --git a/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/pojo/vo/LineOverLimitVO.java b/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/pojo/vo/LineOverLimitVO.java new file mode 100644 index 0000000..2a6a28c --- /dev/null +++ b/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/pojo/vo/LineOverLimitVO.java @@ -0,0 +1,120 @@ +package com.njcn.csdevice.pojo.vo; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * @author denghuajun + * @date 2022/2/23 + * + */ +@Data +@ApiModel +public class LineOverLimitVO { + + @ApiModelProperty(name = "freqDev",value = "频率限值") + private Float freqDev; + + @ApiModelProperty(name = "voltageDev",value = "电压上偏差限值") + private Float voltageDev; + + @ApiModelProperty(name = "uvoltageDev",value = "电压下偏差限值") + private Float uvoltageDev; + + @ApiModelProperty(name = "ubalance",value = "三相电压不平衡度限值") + private Float ubalance; + + @ApiModelProperty(name = "iNeg",value = "负序电流") + private Float iNeg; + + @ApiModelProperty(name = "flicker",value = "长时闪变限值") + private Float flicker; + + @ApiModelProperty(name = "uaberrance",value = "电压总谐波畸变率限值") + private Float uaberrance; + + @ApiModelProperty(name = "oddHarm",value = "奇次谐波含有率限值") + private Float oddHarm; + + @ApiModelProperty(name = "evenHarm",value = "偶次谐波含有率限值") + private Float evenHarm; + + @ApiModelProperty(name = "iharm2",value = "2次谐波电流幅值限值") + private Float iharm2; + + @ApiModelProperty(name = "iharm3",value = "3次谐波电流幅值限值") + private Float iharm3; + + @ApiModelProperty(name = "iharm4",value = "4次谐波电流幅值限值") + private Float iharm4; + + @ApiModelProperty(name = "iharm5",value = "5次谐波电流幅值限值") + private Float iharm5; + + @ApiModelProperty(name = "iharm6",value = "6次谐波电流幅值限值") + private Float iharm6; + + @ApiModelProperty(name = "iharm7",value = "7次谐波电流幅值限值") + private Float iharm7; + + @ApiModelProperty(name = "iharm8",value = "8次谐波电流幅值限值") + private Float iharm8; + + @ApiModelProperty(name = "iharm9",value = "9次谐波电流幅值限值") + private Float iharm9; + + @ApiModelProperty(name = "iharm10",value = "10次谐波电流幅值限值") + private Float iharm10; + + @ApiModelProperty(name = "iharm11",value = "11次谐波电流幅值限值") + private Float iharm11; + + @ApiModelProperty(name = "iharm12",value = "12次谐波电流幅值限值") + private Float iharm12; + + @ApiModelProperty(name = "iharm13",value = "13次谐波电流幅值限值") + private Float iharm13; + + @ApiModelProperty(name = "iharm14",value = "14次谐波电流幅值限值") + private Float iharm14; + + @ApiModelProperty(name = "iharm15",value = "15次谐波电流幅值限值") + private Float iharm15; + + @ApiModelProperty(name = "iharm16",value = "16次谐波电流幅值限值") + private Float iharm16; + + @ApiModelProperty(name = "iharm17",value = "17次谐波电流幅值限值") + private Float iharm17; + + @ApiModelProperty(name = "iharm18",value = "18次谐波电流幅值限值") + private Float iharm18; + + @ApiModelProperty(name = "iharm19",value = "19次谐波电流幅值限值") + private Float iharm19; + + @ApiModelProperty(name = "iharm20",value = "20次谐波电流幅值限值") + private Float iharm20; + + @ApiModelProperty(name = "iharm21",value = "21次谐波电流幅值限值") + private Float iharm21; + + @ApiModelProperty(name = "iharm22",value = "22次谐波电流幅值限值") + private Float iharm22; + + @ApiModelProperty(name = "iharm23",value = "23次谐波电流幅值限值") + private Float iharm23; + + @ApiModelProperty(name = "iharm24",value = "24次谐波电流幅值限值") + private Float iharm24; + + @ApiModelProperty(name = "iharm25",value = "25次谐波电流幅值限值") + private Float iharm25; + + @ApiModelProperty(name = "inUharm",value = "0.5-1.5次间谐波电压幅值限值") + private Float inUharm; + + @ApiModelProperty(name = "inUharm16",value = "2.5-15.5次间谐波电压幅值限值") + private Float inUharm16; +} diff --git a/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/utils/COverlimitUtil.java b/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/utils/COverlimitUtil.java new file mode 100644 index 0000000..deadbc8 --- /dev/null +++ b/cs-device/cs-device-api/src/main/java/com/njcn/csdevice/utils/COverlimitUtil.java @@ -0,0 +1,383 @@ +package com.njcn.csdevice.utils; + +import com.njcn.csdevice.pojo.po.Overlimit; +import com.njcn.device.biz.enums.RunFlagEnum; +import com.njcn.system.enums.DicDataEnum; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.util.Objects; + + +/** + * pqs + * 限值计算工具类 + * + * @author cdf + * @date 2023/5/15 + */ +public class COverlimitUtil { + + + /** + * 谐波电流系数 + */ + private static final double[][] ARR = { + {78, 62, 39, 62, 26, 44, 19, 21, 16, 28, 13, 24, 11, 12, 9.7, 18, 8.6, 16, 7.8, 8.9, 7.1, 14, 6.5, 12, 6.0, 6.9, 5.6, 11, 5.2, 10, 4.9, 5.6, 4.6, 8.9, 4.3, 8.4, 4.1, 4.8, 3.9, 7.6, 3.7, 7.2, 3.5, 4.1, 3.4, 6.6, 3.3, 6.3, 3.1}, + {43, 34, 21, 34, 14, 24, 11, 11, 8.5, 16, 7.1, 13, 6.1, 6.8, 5.3, 10, 4.7, 9, 4.3, 4.9, 3.9, 7.4, 3.6, 6.8, 3.3, 3.8, 3.1, 5.9, 2.9, 5.5, 2.7, 3.1, 2.5, 4.9, 2.4, 4.6, 2.3, 2.6, 2.2, 4.1, 2.0, 4.0, 2.0, 2.3, 1.9, 3.6, 1.8, 3.5, 1.7}, + {26, 20, 13, 20, 8.5, 15, 6.4, 6.8, 5.1, 9.3, 4.3, 7.9, 3.7, 4.1, 3.2, 6, 2.8, 5.4, 2.6, 2.9, 2.3, 4.5, 2.1, 4.1, 2.0, 2.2, 1.9, 3.4, 1.7, 3.2, 1.6, 1.8, 1.5, 2.9, 1.4, 2.7, 1.4, 1.5, 1.3, 2.4, 1.2, 2.3, 1.2, 1.3, 1.1, 2.1, 1.1, 2.0, 1.0}, + {15, 12, 7.7, 12, 5.1, 8.8, 3.8, 4.1, 3.1, 5.6, 2.6, 4.7, 2.2, 2.5, 1.9, 3.6, 1.7, 3.2, 1.5, 1.8, 1.4, 2.7, 1.3, 2.5, 1.2, 1.3, 1.1, 2.1, 1.0, 1.9, 0.9, 1.1, 0.9, 1.7, 0.8, 1.6, 0.8, 0.9, 0.8, 1.5, 0.7, 1.4, 0.7, 0.8, 0.7, 1.3, 0.6, 1.2, 0.6}, + {16, 13, 8.1, 13, 5.4, 9.3, 4.1, 4.3, 3.3, 5.9, 2.7, 5, 2.3, 2.6, 2, 3.8, 1.8, 3.4, 1.6, 1.9, 1.5, 2.8, 1.4, 2.6, 1.2, 1.4, 1.1, 2.2, 1.1, 2.1, 1.0, 1.2, 0.9, 1.9, 0.9, 1.8, 0.8, 1.0, 0.8, 1.6, 0.8, 1.5, 0.7, 0.9, 0.7, 1.4, 0.7, 1.3, 0.6}, + {12, 9.6, 6, 9.6, 4, 6.8, 3, 3.2, 2.4, 4.3, 2, 3.7, 1.7, 1.9, 1.5, 2.8, 1.3, 2.5, 1.2, 1.4, 1.1, 2.1, 1, 1.9, 0.9, 1.1, 0.9, 1.7, 0.8, 1.5, 0.8, 0.9, 0.7, 1.4, 0.7, 1.3, 0.6, 0.7, 0.6, 1.2, 0.6, 1.1, 0.5, 0.6, 0.5, 1.0, 0.5, 1.0, 0.5} + }; + + + /** + * 计算监测点限值 + * @param voltageLevel 电压等级（10kV = 10 220kV = 220 ） + * @param protocolCapacity 协议容量 + * @param devCapacity 设备容量 + * @param shortCapacity 短路容量 + * @param powerFlag 0.用户侧 1.电网侧 + * @param lineType 0.主网 1.配网 需要注意配网目前没有四种容量，谐波电流幅值限值,负序电流限值无法计算默认-3.14159 + */ + public static Overlimit globalAssemble(Float voltageLevel, Float protocolCapacity, Float devCapacity, + Float shortCapacity, Integer powerFlag, Integer lineType) { + Overlimit overlimit = new Overlimit(); + voltageDeviation(overlimit,voltageLevel); + frequency(overlimit); + voltageFluctuation(overlimit,voltageLevel); + voltageFlicker(overlimit,voltageLevel); + totalHarmonicDistortion(overlimit,voltageLevel); + uHarm(overlimit,voltageLevel); + threeVoltageUnbalance(overlimit); + interharmonicCurrent(overlimit,voltageLevel); + + if(Objects.equals(lineType, RunFlagEnum.PW_FLAG.getStatus())) { + //配网 + Float[] iHarmTem = new Float[49]; + for (int i = 0; i <= 48; i++) { + + iHarmTem[i] = -3.14159f; + } + overlimit.buildIHarm(iHarmTem); + overlimit.setINeg(-3.14159f); + }else { + //主网 + iHarm(overlimit, voltageLevel, protocolCapacity, devCapacity, shortCapacity); + negativeSequenceCurrent(overlimit, voltageLevel, shortCapacity); + } + return overlimit; + } + + + /** + * 电压偏差限值 + * + */ + public static void voltageDeviation(Overlimit overlimit,Float voltageLevel) { + float voltageDev = 3.14159f,uvoltageDev = 3.14159f; + if(voltageLevel <= Float.parseFloat(DicDataEnum.V220.getCode())){ + voltageDev = 7.0f; + uvoltageDev=-10.0f; + }else if(voltageLevel>Float.parseFloat(DicDataEnum.V220.getCode())&&voltageLevel=Float.parseFloat(DicDataEnum.KV20.getCode())&&voltageLevel=Float.parseFloat(DicDataEnum.KV35.getCode())&&voltageLevel=Float.parseFloat(DicDataEnum.KV66.getCode())&&voltageLevel<=Float.parseFloat(DicDataEnum.KV110.getCode())){ + voltageDev = 7.0f; + uvoltageDev=-3.0f; + }else if(voltageLevel>Float.parseFloat(DicDataEnum.KV110.getCode())){ + voltageDev = 10.0f; + uvoltageDev=-10.0f; + } + overlimit.setVoltageDev(voltageDev); + overlimit.setUvoltageDev(uvoltageDev); + } + + + /** + * 频率偏差 + * 默认限值：±0.2Hz（即：-0.2 Hz≤限值≤0.2 Hz） + */ + public static void frequency(Overlimit overlimit) { + overlimit.setFreqDev(0.2f); + } + + + /** + * 电压波动 + * 对LV、MV：0≤限值≤3%；对HV：0≤限值≤2.5%。 + * LV、MV、HV的定义： + * 低压（LV） UN≤1kV + * 中压（MV） 1kV＜UN≤35kV + * 高压（HV） 35kV＜UN≤220kV + * 超高压（EHV），220kV＜UN，参照HV执行 + */ + public static void voltageFluctuation(Overlimit overlimit, Float voltageLevel) { + if (voltageLevel < Float.parseFloat(DicDataEnum.KV35.getCode())) { + overlimit.setVoltageFluctuation(3.0f); + } else { + overlimit.setVoltageFluctuation(2.5f); + } + } + + + + /** + * 电压闪变 + * ≤110kV 1 + * ＞110kV 0.8 + */ + public static void voltageFlicker(Overlimit overlimit, Float voltageLevel) { + if (voltageLevel <= Float.parseFloat(DicDataEnum.KV110.getCode())) { + overlimit.setFlicker(1.0f); + } else { + overlimit.setFlicker(0.8f); + } + } + + + /** + * 总谐波电压畸变率 + * + * + */ + public static void totalHarmonicDistortion(Overlimit overlimit, Float voltageLevel) { + float result = 3.14159f; + if (voltageLevel < Float.parseFloat(DicDataEnum.KV6.getCode())) { + result = 5.0f; + } else if(voltageLevel >= Float.parseFloat(DicDataEnum.KV6.getCode()) && voltageLevel <= Float.parseFloat(DicDataEnum.KV20.getCode())){ + result = 4.0f; + } else if(voltageLevel >= Float.parseFloat(DicDataEnum.KV35.getCode()) && voltageLevel <= Float.parseFloat(DicDataEnum.KV66.getCode())){ + result = 3.0f; + } else if(voltageLevel >= Float.parseFloat(DicDataEnum.KV110.getCode()) && voltageLevel <= Float.parseFloat(DicDataEnum.KV1000.getCode())){ + result = 2.0f; + } + overlimit.setUaberrance(result); + } + + + + /** + * 谐波电压含有率 + */ + public static void uHarm(Overlimit overlimit, Float voltageLevel) { + float resultOdd = 3.14159f,resultEven = 3.14159f; + if (voltageLevel < Float.parseFloat(DicDataEnum.KV6.getCode())) { + resultOdd = 4.0f; + resultEven = 2.0f; + } else if(voltageLevel >= Float.parseFloat(DicDataEnum.KV6.getCode()) && voltageLevel <= Float.parseFloat(DicDataEnum.KV20.getCode())){ + resultOdd = 3.2f; + resultEven = 1.6f; + } else if(voltageLevel >= Float.parseFloat(DicDataEnum.KV35.getCode()) && voltageLevel <= Float.parseFloat(DicDataEnum.KV66.getCode())){ + resultOdd = 2.4f; + resultEven = 1.2f; + } else if(voltageLevel >= Float.parseFloat(DicDataEnum.KV110.getCode()) && voltageLevel <= Float.parseFloat(DicDataEnum.KV1000.getCode())){ + resultOdd = 1.6f; + resultEven = 0.8f; + } + overlimit.buildUharm(resultEven,resultOdd); + } + + + /** + * 负序电压不平衡（三相电压不平衡度） + * + */ + public static void threeVoltageUnbalance(Overlimit overlimit) { + overlimit.setUbalance(2.0f); + overlimit.setShortUbalance(4.0f); + } + + + /*---------------------------------谐波电流限值start-----------------------------------*/ + + /** + * 谐波电流限值 + */ + public static void iHarm(Overlimit overlimit, Float voltageLevel,Float protocolCapacity,Float devCapacity,Float shortCapacity) { + float calCap = shortCapacity/getDlCapByVoltageLevel(voltageLevel); + //24谐波电流幅值 + Float[] iHarmTem = new Float[49]; + for (int i = 0; i <= 48; i++) { + float inHarm = iHarmCalculate(i+2,voltageLevel,protocolCapacity,devCapacity,calCap); + iHarmTem[i] = inHarm; + } + overlimit.buildIHarm(iHarmTem); + } + /** + * @Description: iHarmCalculate + * @Param: protocolCapacity 协议容量 devCapacity设备容量 calCap 短路容量 + * @return: float + * @Author: clam + * @Date: 2024/2/4 + */ + private static float iHarmCalculate(int nHarm, Float voltageLevel,float protocolCapacity, float devCapacity,float calCap) { + double tag = calCap*getHarmTag(nHarm,voltageLevel); + Double limit = getHarmonicLimit(nHarm,tag,new BigDecimal(String.valueOf(devCapacity)).doubleValue(),new BigDecimal(String.valueOf(protocolCapacity)).doubleValue()); + BigDecimal bigDecimal = BigDecimal.valueOf(limit).setScale(4,RoundingMode.HALF_UP); + return bigDecimal.floatValue(); + } + + + /** + * 电流谐波限值 + */ + private static Double getHarmTag(Integer iCount, Float voltageLevel) { + int x, y; + if (voltageLevel < DicDataEnum.KV6.getValue()) { + x = 0; + } else if (voltageLevel getOverLimitDataTerminal(@RequestParam("id") String id) { + String methodDescribe = getMethodDescribe("getOverLimitData"); + Overlimit result = overLimitService.getOverLimitDataById(id); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe); + } + + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @PostMapping("/line/getOverLimitData") + @ApiOperation("根据监测点id获取越限数值") + @ApiImplicitParam(name = "id", value = "监测点id", required = true) + public HttpResult getOverLimitData(@RequestParam("id") String id) { + String methodDescribe = getMethodDescribe("getOverLimitData"); + Overlimit result = overLimitService.getOverLimitDataById(id); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe); + } + + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @PostMapping("/line/getLineOverLimitData") + @ApiOperation("根据监测点id获取越限详情") + @ApiImplicitParam(name = "id", value = "监测点id", required = true) + public HttpResult getLineOverLimitData(@RequestParam("id") String id) { + String methodDescribe = getMethodDescribe("getLineOverLimitData"); + LineOverLimitVO result = overLimitService.getLineOverLimitDataById(id); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe); + } + + + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @PostMapping("/overLimit/getOverLimitByLineIds") + @ApiOperation("监测点集合获取限值") + @ApiImplicitParam(name = "lineIds", value = "监测点ids", required = true) + @ApiIgnore + public HttpResult> getOverLimitByLineIds(@RequestBody List lineIds){ + String methodDescribe = getMethodDescribe("getOverLimitByLineIds"); + List overLimitList= overLimitService.list(new LambdaQueryWrapper().in(Overlimit::getId,lineIds)); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, overLimitList, methodDescribe); + } + + + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @PostMapping("/commTerminal/getOverLimitDataByIds") + @ApiOperation("根据监测点id集合获取越限数值") + @ApiImplicitParam(name = "ids", value = "监测点id集合", required = true) + public HttpResult> getOverLimitDataByIds(@RequestBody List ids) { + String methodDescribe = getMethodDescribe("getOverLimitDataByIds"); + List result = overLimitService.listByIds(ids); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe); + } + + + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @PostMapping("/overLimit/getLimitMapsByLineIds") + @ApiOperation("监测点集合获取限值") + @ApiImplicitParam(name = "lineIds", value = "监测点ids", required = true) + @ApiIgnore + public HttpResult>> getLimitMapsByLineIds(@RequestBody List lineIds){ + String methodDescribe = getMethodDescribe("getLimitMapsByLineIds"); + List> overLimitList= overLimitService.listMaps(new LambdaQueryWrapper().in(Overlimit::getId,lineIds)); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, overLimitList, methodDescribe); + } +} diff --git a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/controller/line/CslineController.java b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/controller/line/CslineController.java index 97426a0..71d0c77 100644 --- a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/controller/line/CslineController.java +++ b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/controller/line/CslineController.java @@ -11,10 +11,10 @@ import com.njcn.common.utils.HttpResultUtil; import com.njcn.csdevice.mapper.OverlimitMapper; import com.njcn.csdevice.pojo.param.CsLineParam; import com.njcn.csdevice.pojo.po.CsLinePO; +import com.njcn.csdevice.pojo.po.Overlimit; import com.njcn.csdevice.pojo.vo.PqSensitiveUserLineVO; import com.njcn.csdevice.service.CsLinePOService; -import com.njcn.device.biz.pojo.po.Overlimit; -import com.njcn.device.biz.utils.COverlimitUtil; +import com.njcn.csdevice.utils.COverlimitUtil; import com.njcn.web.controller.BaseController; import com.njcn.web.pojo.param.BaseParam; import io.swagger.annotations.*; diff --git a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/mapper/OverlimitMapper.java b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/mapper/OverlimitMapper.java index 64d50b5..d99efb1 100644 --- a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/mapper/OverlimitMapper.java +++ b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/mapper/OverlimitMapper.java @@ -3,7 +3,7 @@ package com.njcn.csdevice.mapper; import com.baomidou.dynamic.datasource.annotation.DS; import com.baomidou.mybatisplus.core.mapper.BaseMapper; -import com.njcn.device.biz.pojo.po.Overlimit; +import com.njcn.csdevice.pojo.po.Overlimit; import org.apache.ibatis.annotations.Mapper; diff --git a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/mapper/mapping/OverlimitMapper.xml b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/mapper/mapping/OverlimitMapper.xml new file mode 100644 index 0000000..fb1720e --- /dev/null +++ b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/mapper/mapping/OverlimitMapper.xml @@ -0,0 +1,20 @@ + + + + + + + diff --git a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/IOverLimitService.java b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/IOverLimitService.java new file mode 100644 index 0000000..a9721d4 --- /dev/null +++ b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/IOverLimitService.java @@ -0,0 +1,28 @@ +package com.njcn.csdevice.service; + + +import com.baomidou.mybatisplus.extension.service.IService; +import com.njcn.csdevice.pojo.po.Overlimit; +import com.njcn.csdevice.pojo.vo.LineOverLimitVO; + +/** + *

+ * 越限表实体 + *

+ * + * @author hongawen + * @since 2023-03-28 + */ +public interface IOverLimitService extends IService { + + + Overlimit getOverLimitDataById(String id); + + /** + * 获取监测点越限详情 + * @param id 监测点id + * @return 结果 + */ + LineOverLimitVO getLineOverLimitDataById(String id); + + } diff --git a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/OverlimitServiceImpl.java b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/OverlimitServiceImpl.java deleted file mode 100644 index b066ede..0000000 --- a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/OverlimitServiceImpl.java +++ /dev/null @@ -1,21 +0,0 @@ -package com.njcn.csdevice.service; - -import com.baomidou.dynamic.datasource.annotation.DS; -import com.njcn.device.biz.pojo.po.Overlimit; -import org.springframework.stereotype.Service; -import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; -import com.njcn.csdevice.mapper.OverlimitMapper; -import com.njcn.csdevice.service.impl.OverlimitService; -/** - * - * Description: - * Date: 2024/10/22 14:14【需求编号】 - * - * @author clam - * @version V1.0.0 - */ -@Service -@DS("sjzx") -public class OverlimitServiceImpl extends ServiceImpl implements OverlimitService{ - -} diff --git a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/CsGroupServiceImpl.java b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/CsGroupServiceImpl.java index 76d3512..52449a6 100644 --- a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/CsGroupServiceImpl.java +++ b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/CsGroupServiceImpl.java @@ -37,7 +37,6 @@ import com.njcn.csharmonic.constant.HarmonicConstant; import com.njcn.csharmonic.param.*; import com.njcn.csharmonic.pojo.vo.ThdDataTdVO; import com.njcn.csharmonic.pojo.vo.ThdDataVO; -import com.njcn.device.biz.pojo.po.Overlimit; import com.njcn.influx.pojo.bo.CommonQueryParam; import com.njcn.influx.pojo.dto.EventDataSetDTO; import com.njcn.influx.pojo.dto.StatisticalDataDTO; diff --git a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/IcdServiceImpl.java b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/IcdServiceImpl.java index e69b975..6579361 100644 --- a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/IcdServiceImpl.java +++ b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/IcdServiceImpl.java @@ -22,10 +22,9 @@ import com.njcn.csdevice.pojo.po.*; import com.njcn.csdevice.pojo.vo.CldLedgerVo; import com.njcn.csdevice.pojo.vo.DeviceInfo; import com.njcn.csdevice.service.*; +import com.njcn.csdevice.utils.COverlimitUtil; import com.njcn.csharmonic.api.EventFeignClient; import com.njcn.csharmonic.pojo.po.CsEventPO; -import com.njcn.device.biz.pojo.po.Overlimit; -import com.njcn.device.biz.utils.COverlimitUtil; import com.njcn.mq.message.BZEventMessage; import com.njcn.mq.template.BZEventMessageTemplate; import com.njcn.redis.pojo.enums.AppRedisKey; diff --git a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/OverLimitServiceImpl.java b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/OverLimitServiceImpl.java new file mode 100644 index 0000000..bf12ebf --- /dev/null +++ b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/OverLimitServiceImpl.java @@ -0,0 +1,42 @@ +package com.njcn.csdevice.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.njcn.csdevice.mapper.OverlimitMapper; +import com.njcn.csdevice.pojo.po.Overlimit; +import com.njcn.csdevice.pojo.vo.LineOverLimitVO; +import com.njcn.csdevice.service.IOverLimitService; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; + +/** + * pqs + * + * @author cdf + * @date 2023/6/7 + */ +@Service +@RequiredArgsConstructor +public class OverLimitServiceImpl extends ServiceImpl implements IOverLimitService { + + + @Override + public Overlimit getOverLimitDataById(String id) { + return this.baseMapper.selectById(id); + } + + @Override + public LineOverLimitVO getLineOverLimitDataById(String id) { + //根据监测点id查询所在监测点的限值表数据 + Overlimit overlimit = this.baseMapper.selectById(id); + LineOverLimitVO lineOverLimitVO = new LineOverLimitVO(); + BeanUtil.copyProperties(overlimit, lineOverLimitVO); + lineOverLimitVO.setOddHarm(overlimit.getUharm3()); + lineOverLimitVO.setEvenHarm(overlimit.getUharm2()); + lineOverLimitVO.setInUharm(overlimit.getInuharm1()); + lineOverLimitVO.setInUharm16(overlimit.getInuharm16()); + return lineOverLimitVO; + } + +} + diff --git a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/OverlimitService.java b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/OverlimitService.java deleted file mode 100644 index 0a39e4e..0000000 --- a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/OverlimitService.java +++ /dev/null @@ -1,17 +0,0 @@ -package com.njcn.csdevice.service.impl; - -import com.baomidou.mybatisplus.extension.service.IService; -import com.njcn.device.biz.pojo.po.Overlimit; - -/** - * - * Description: - * Date: 2024/10/22 14:14【需求编号】 - * - * @author clam - * @version V1.0.0 - */ -public interface OverlimitService extends IService{ - - -} diff --git a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/WlRecordServiceImpl.java b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/WlRecordServiceImpl.java index 5d69d28..fe7cd4d 100644 --- a/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/WlRecordServiceImpl.java +++ b/cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/WlRecordServiceImpl.java @@ -18,27 +18,24 @@ import com.njcn.csdevice.api.EquipmentFeignClient; import com.njcn.csdevice.constant.DataParam; import com.njcn.csdevice.enums.LineBaseEnum; import com.njcn.csdevice.mapper.CsDataSetMapper; -import com.njcn.csdevice.mapper.CsEquipmentDeliveryMapper; -import com.njcn.csdevice.mapper.CsLinePOMapper; import com.njcn.csdevice.mapper.WlRecordMapper; import com.njcn.csdevice.param.WlRecordPageParam; import com.njcn.csdevice.pojo.dto.CsEquipmentDeliveryDTO; import com.njcn.csdevice.pojo.param.WlRecordParam; import com.njcn.csdevice.pojo.po.CsDataSet; import com.njcn.csdevice.pojo.po.CsLinePO; +import com.njcn.csdevice.pojo.po.Overlimit; import com.njcn.csdevice.pojo.po.WlRecord; import com.njcn.csdevice.pojo.vo.RecordAllDevTreeVo; import com.njcn.csdevice.pojo.vo.RecordTreeVo; import com.njcn.csdevice.pojo.vo.RecordVo; +import com.njcn.csdevice.service.IOverLimitService; import com.njcn.csdevice.service.IWlRecordService; import com.njcn.csdevice.util.InfluxDbParamUtil; -import com.njcn.csdevice.utils.DataChangeUtil; +import com.njcn.csdevice.utils.COverlimitUtil; import com.njcn.csdevice.utils.StringUtil; -import com.njcn.csharmonic.constant.HarmonicConstant; import com.njcn.csharmonic.param.CommonStatisticalQueryParam; import com.njcn.csharmonic.pojo.vo.ThdDataVO; -import com.njcn.device.biz.pojo.po.Overlimit; -import com.njcn.device.biz.utils.COverlimitUtil; import com.njcn.influx.imapper.CommonMapper; import com.njcn.influx.pojo.bo.CommonQueryParam; import com.njcn.influx.pojo.constant.InfluxDBTableConstant; @@ -62,7 +59,6 @@ import java.time.LocalDateTime; import java.time.ZoneOffset; import java.time.format.DateTimeFormatter; import java.util.*; -import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; @@ -93,10 +89,7 @@ public class WlRecordServiceImpl extends ServiceImpl i private final InfluxDbParamUtil influxDbParamUtil; - private final CsLinePOMapper csLinePOMapper; - - private final CsEquipmentDeliveryMapper csEquipmentDeliveryMapper; - private final OverlimitService overlimitService; + private final IOverLimitService overlimitService; private final DicDataFeignClient dicDataFeignClient; private final DecimalFormat df = new DecimalFormat(DataParam.DecimalFormatStr); diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/HarCurrent.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/HarCurrent.java new file mode 100644 index 0000000..63fbbcd --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/HarCurrent.java @@ -0,0 +1,9 @@ +package com.njcn.csharmonic.annotaion; + +import java.lang.annotation.*; + +@Documented +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.FIELD) +public @interface HarCurrent { +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/HarVoltage.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/HarVoltage.java new file mode 100644 index 0000000..96589a7 --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/HarVoltage.java @@ -0,0 +1,9 @@ +package com.njcn.csharmonic.annotaion; + +import java.lang.annotation.*; + +@Documented +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.FIELD) +public @interface HarVoltage { +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/InterharVoltage.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/InterharVoltage.java new file mode 100644 index 0000000..613909e --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/InterharVoltage.java @@ -0,0 +1,11 @@ +package com.njcn.csharmonic.annotaion; + +import java.lang.annotation.*; + + + +@Documented +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.FIELD) +public @interface InterharVoltage { +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitCalendarQueryParam.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitCalendarQueryParam.java new file mode 100644 index 0000000..462962d --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitCalendarQueryParam.java @@ -0,0 +1,9 @@ +package com.njcn.csharmonic.pojo.param; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +@EqualsAndHashCode(callSuper = true) +@Data +public class LimitCalendarQueryParam extends TotalLimitStatisticsParam { +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitExtentDayQueryParam.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitExtentDayQueryParam.java new file mode 100644 index 0000000..26022d0 --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitExtentDayQueryParam.java @@ -0,0 +1,23 @@ +package com.njcn.csharmonic.pojo.param; + +import com.njcn.web.pojo.annotation.DateTimeStrValid; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import javax.validation.constraints.NotBlank; + +@Data +public class LimitExtentDayQueryParam { + + @ApiModelProperty(value = "发生时间") + @NotBlank(message = "发生日期不能为空") + @DateTimeStrValid(message = "发生日期格式出错") + private String time; + + @ApiModelProperty(value = "监测点id") + @NotBlank(message = "监测点id不能为空") + private String lineId; + @ApiModelProperty(value = "指标编码") + @NotBlank(message = "指标编码不能为空") + private String code; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitExtentQueryParam.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitExtentQueryParam.java new file mode 100644 index 0000000..ace0330 --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitExtentQueryParam.java @@ -0,0 +1,9 @@ +package com.njcn.csharmonic.pojo.param; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +@EqualsAndHashCode(callSuper = true) +@Data +public class LimitExtentQueryParam extends TotalLimitStatisticsParam { +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitProbabilityQueryParam.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitProbabilityQueryParam.java new file mode 100644 index 0000000..d32a9f9 --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitProbabilityQueryParam.java @@ -0,0 +1,9 @@ +package com.njcn.csharmonic.pojo.param; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +@EqualsAndHashCode(callSuper = true) +@Data +public class LimitProbabilityQueryParam extends MainLineStatLimitRateDetailsQueryParam { +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/MainLineQueryParam.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/MainLineQueryParam.java new file mode 100644 index 0000000..19ec00b --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/MainLineQueryParam.java @@ -0,0 +1,35 @@ +package com.njcn.csharmonic.pojo.param; + +import com.njcn.web.pojo.annotation.DateTimeStrValid; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import javax.validation.constraints.NotBlank; + + +@Data +@Builder +@AllArgsConstructor +@NoArgsConstructor +public class MainLineQueryParam { + @ApiModelProperty("关键词") + private String keywords; + + @ApiModelProperty(name = "searchBeginTime", value = "开始时间") + @NotBlank(message = "起始时间不可为空") + @DateTimeStrValid(message = "起始时间格式出错") + private String searchBeginTime; + + @ApiModelProperty(name = "searchEndTime", value = "结束时间") + @NotBlank(message = "结束时间不可为空") + private String searchEndTime; + + @ApiModelProperty(value = "页码", example = "1") + private int pageNum = 1; + + @ApiModelProperty(value = "每页记录数", example = "10") + private int pageSize = 10; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/MainLineStatLimitRateDetailsQueryParam.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/MainLineStatLimitRateDetailsQueryParam.java new file mode 100644 index 0000000..c358542 --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/MainLineStatLimitRateDetailsQueryParam.java @@ -0,0 +1,23 @@ +package com.njcn.csharmonic.pojo.param; + +import com.njcn.web.pojo.annotation.DateTimeStrValid; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import javax.validation.constraints.NotBlank; + +@Data +public class MainLineStatLimitRateDetailsQueryParam { + @NotBlank(message = "监测点ID不可为空") + @ApiModelProperty("监测点ID") + private String lineId; + + @ApiModelProperty(name = "searchBeginTime", value = "开始时间") + @NotBlank(message = "起始时间不可为空") + @DateTimeStrValid(message = "起始时间格式出错") + private String searchBeginTime; + + @ApiModelProperty(name = "searchEndTime", value = "结束时间") + @NotBlank(message = "结束时间不可为空") + private String searchEndTime; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/RStatLimitQueryParam.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/RStatLimitQueryParam.java new file mode 100644 index 0000000..3e385bd --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/RStatLimitQueryParam.java @@ -0,0 +1,27 @@ +package com.njcn.csharmonic.pojo.param; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.util.List; + +/** + * pqs + * + * @author cdf + * @date 2024/2/28 + */ +@Data +@Builder +@AllArgsConstructor +@NoArgsConstructor +public class RStatLimitQueryParam { + + private List ids; + + private String date; + + private String endDate; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/StatSubstationBizBaseParam.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/StatSubstationBizBaseParam.java new file mode 100644 index 0000000..192248c --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/StatSubstationBizBaseParam.java @@ -0,0 +1,39 @@ +package com.njcn.csharmonic.pojo.param; + +import com.njcn.common.pojo.param.StatisticsBizBaseParam; +import com.njcn.web.constant.ValidMessage; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; +import org.hibernate.validator.constraints.Range; + +import java.util.List; + +/** + * <功能描述> + * + * @author 1754607820@qq.com + * @createTime: 2022-10-18 + */ +@Data +public class StatSubstationBizBaseParam extends StatisticsBizBaseParam { + + @ApiModelProperty(value = "ids集合", required = true) + private List ids; + + @ApiModelProperty(value = "是否是国网监测点信息", required = true) + private Integer isUpToGrid; + + @ApiModelProperty("页码") + private Integer pageNum; + + @ApiModelProperty("页面尺寸") + private Integer pageSize; + + /** + * 0-电网侧 + * 1-非电网侧 + */ + @ApiModelProperty("电网侧标识") + @Range(min = 0, max = 2, message = "电网侧标识" + ValidMessage.PARAM_FORMAT_ERROR) + private Integer powerFlag; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/TotalLimitStatisticsDetailsQueryParam.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/TotalLimitStatisticsDetailsQueryParam.java new file mode 100644 index 0000000..45a0dda --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/TotalLimitStatisticsDetailsQueryParam.java @@ -0,0 +1,9 @@ +package com.njcn.csharmonic.pojo.param; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +@EqualsAndHashCode(callSuper = true) +@Data +public class TotalLimitStatisticsDetailsQueryParam extends MainLineStatLimitRateDetailsQueryParam { +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/TotalLimitStatisticsParam.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/TotalLimitStatisticsParam.java new file mode 100644 index 0000000..38de1bf --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/TotalLimitStatisticsParam.java @@ -0,0 +1,19 @@ +package com.njcn.csharmonic.pojo.param; + +import com.njcn.web.pojo.annotation.DateTimeStrValid; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import javax.validation.constraints.NotBlank; + +@Data +public class TotalLimitStatisticsParam { + @ApiModelProperty(name = "searchBeginTime", value = "开始时间") + @NotBlank(message = "起始时间不可为空") + @DateTimeStrValid(message = "起始时间格式出错") + private String searchBeginTime; + + @ApiModelProperty(name = "searchEndTime", value = "结束时间") + @NotBlank(message = "结束时间不可为空") + private String searchEndTime; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/po/RStatLimitRateDPO.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/po/RStatLimitRateDPO.java new file mode 100644 index 0000000..73da47c --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/po/RStatLimitRateDPO.java @@ -0,0 +1,614 @@ +package com.njcn.csharmonic.pojo.po; + +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import com.fasterxml.jackson.annotation.JsonFormat; +import com.github.jeffreyning.mybatisplus.anno.MppMultiId; +import com.njcn.csharmonic.annotaion.HarCurrent; +import com.njcn.csharmonic.annotaion.HarVoltage; +import com.njcn.csharmonic.annotaion.InterharVoltage; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.time.LocalDate; + +@Data +@AllArgsConstructor +@NoArgsConstructor +@TableName(value = "r_stat_limit_rate_d") +public class RStatLimitRateDPO { + /** + * 监测点ID合格率的变电站/装置/母线/线路序号 + */ + @MppMultiId + @TableField(value = "my_index") + @ApiModelProperty(value = "监测点ID合格率的变电站/装置/母线/线路序号") + private String lineId; + + /** + * 数据类型,’A’表示A相，’B’表示B相,’C’表示C相,’’M’表示ABC三项总和，T’表示总 + */ + @MppMultiId + @TableField(value = "phasic_type") + @ApiModelProperty(value = "数据类型,'A'表示A相，'B'表示B相,'C'表示C相,''M'表示ABC三项总和，T'表示总") + private String phasicType; + + /** + * 合格率时间 + */ + @MppMultiId + @TableField(value = "time_id") + @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8") + @ApiModelProperty(value = "合格率时间") + private LocalDate time; + + /** + * 总计算次数 + */ + @TableField(value = "all_time") + @ApiModelProperty(value = "总计算次数") + private Integer allTime; + + /** + * 闪变越限次数 + */ + @TableField(value = "flicker_overtime") + @ApiModelProperty(value = "闪变越限次数") + private Integer flickerOvertime; + + /** + * 闪变总计算次数 + */ + @TableField(value = "flicker_all_time") + @ApiModelProperty(value = "闪变总计算次数") + private Integer flickerAllTime; + + /** + * 频率偏差越限次数 + */ + @TableField(value = "freq_dev_overtime") + @ApiModelProperty(value = "频率偏差越限次数") + private Integer freqDevOvertime; + + /** + * 电压偏差越限次数 + */ + @TableField(value = "voltage_dev_overtime") + @ApiModelProperty(value = "电压偏差越限次数") + private Integer voltageDevOvertime; + + /** + * 三相电压不平衡度越限次数 + */ + @TableField(value = "ubalance_overtime") + @ApiModelProperty(value = "三相电压不平衡度越限次数") + private Integer ubalanceOvertime; + + /** + * 电压谐波畸变率越限次数 + */ + @TableField(value = "uaberrance_overtime") + @ApiModelProperty(value = "电压谐波畸变率越限次数") + private Integer uaberranceOvertime; + + /** + * 负序电流限值次数 + */ + @TableField(value = "i_neg_overtime") + @ApiModelProperty(value = "负序电流限值次数") + private Integer iNegOvertime; + + /** + * 2次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_2_overtime") + @ApiModelProperty(value = "2次电压谐波含有率越限次数") + private Integer uharm2Overtime; + + /** + * 3次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_3_overtime") + @ApiModelProperty(value = "3次电压谐波含有率越限次数") + private Integer uharm3Overtime; + + /** + * 4次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_4_overtime") + @ApiModelProperty(value = "4次电压谐波含有率越限次数") + private Integer uharm4Overtime; + + /** + * 5次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_5_overtime") + @ApiModelProperty(value = "5次电压谐波含有率越限次数") + private Integer uharm5Overtime; + + /** + * 6次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_6_overtime") + @ApiModelProperty(value = "6次电压谐波含有率越限次数") + private Integer uharm6Overtime; + + /** + * 7次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_7_overtime") + @ApiModelProperty(value = "7次电压谐波含有率越限次数") + private Integer uharm7Overtime; + + /** + * 8次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_8_overtime") + @ApiModelProperty(value = "8次电压谐波含有率越限次数") + private Integer uharm8Overtime; + + /** + * 9次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_9_overtime") + @ApiModelProperty(value = "9次电压谐波含有率越限次数") + private Integer uharm9Overtime; + + /** + * 10次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_10_overtime") + @ApiModelProperty(value = "10次电压谐波含有率越限次数") + private Integer uharm10Overtime; + + /** + * 11次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_11_overtime") + @ApiModelProperty(value = "11次电压谐波含有率越限次数") + private Integer uharm11Overtime; + + /** + * 12次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_12_overtime") + @ApiModelProperty(value = "12次电压谐波含有率越限次数") + private Integer uharm12Overtime; + + /** + * 13次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_13_overtime") + @ApiModelProperty(value = "13次电压谐波含有率越限次数") + private Integer uharm13Overtime; + + /** + * 14次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_14_overtime") + @ApiModelProperty(value = "14次电压谐波含有率越限次数") + private Integer uharm14Overtime; + + /** + * 15次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_15_overtime") + @ApiModelProperty(value = "15次电压谐波含有率越限次数") + private Integer uharm15Overtime; + + /** + * 16次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_16_overtime") + @ApiModelProperty(value = "16次电压谐波含有率越限次数") + private Integer uharm16Overtime; + + /** + * 17次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_17_overtime") + @ApiModelProperty(value = "17次电压谐波含有率越限次数") + private Integer uharm17Overtime; + + /** + * 18次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_18_overtime") + @ApiModelProperty(value = "18次电压谐波含有率越限次数") + private Integer uharm18Overtime; + + /** + * 19次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_19_overtime") + @ApiModelProperty(value = "19次电压谐波含有率越限次数") + private Integer uharm19Overtime; + + /** + * 20次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_20_overtime") + @ApiModelProperty(value = "20次电压谐波含有率越限次数") + private Integer uharm20Overtime; + + /** + * 21次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_21_overtime") + @ApiModelProperty(value = "21次电压谐波含有率越限次数") + private Integer uharm21Overtime; + + /** + * 22次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_22_overtime") + @ApiModelProperty(value = "22次电压谐波含有率越限次数") + private Integer uharm22Overtime; + + /** + * 23次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_23_overtime") + @ApiModelProperty(value = "23次电压谐波含有率越限次数") + private Integer uharm23Overtime; + + /** + * 24次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_24_overtime") + @ApiModelProperty(value = "24次电压谐波含有率越限次数") + private Integer uharm24Overtime; + + /** + * 25次电压谐波含有率越限次数 + */ + @HarVoltage + @TableField(value = "uharm_25_overtime") + @ApiModelProperty(value = "25次电压谐波含有率越限次数") + private Integer uharm25Overtime; + + /** + * 2次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_2_overtime") + @ApiModelProperty(value = "2次电流谐波幅值越限次数") + private Integer iharm2Overtime; + + /** + * 3次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_3_overtime") + @ApiModelProperty(value = "3次电流谐波幅值越限次数") + private Integer iharm3Overtime; + + /** + * 4次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_4_overtime") + @ApiModelProperty(value = "4次电流谐波幅值越限次数") + private Integer iharm4Overtime; + + /** + * 5次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_5_overtime") + @ApiModelProperty(value = "5次电流谐波幅值越限次数") + private Integer iharm5Overtime; + + /** + * 6次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_6_overtime") + @ApiModelProperty(value = "6次电流谐波幅值越限次数") + private Integer iharm6Overtime; + + /** + * 7次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_7_overtime") + @ApiModelProperty(value = "7次电流谐波幅值越限次数") + private Integer iharm7Overtime; + + /** + * 8次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_8_overtime") + @ApiModelProperty(value = "8次电流谐波幅值越限次数") + private Integer iharm8Overtime; + + /** + * 9次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_9_overtime") + @ApiModelProperty(value = "9次电流谐波幅值越限次数") + private Integer iharm9Overtime; + + /** + * 10次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_10_overtime") + @ApiModelProperty(value = "10次电流谐波幅值越限次数") + private Integer iharm10Overtime; + + /** + * 11次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_11_overtime") + @ApiModelProperty(value = "11次电流谐波幅值越限次数") + private Integer iharm11Overtime; + + /** + * 12次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_12_overtime") + @ApiModelProperty(value = "12次电流谐波幅值越限次数") + private Integer iharm12Overtime; + + /** + * 13次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_13_overtime") + @ApiModelProperty(value = "13次电流谐波幅值越限次数") + private Integer iharm13Overtime; + + /** + * 14次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_14_overtime") + @ApiModelProperty(value = "14次电流谐波幅值越限次数") + private Integer iharm14Overtime; + + /** + * 15次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_15_overtime") + @ApiModelProperty(value = "15次电流谐波幅值越限次数") + private Integer iharm15Overtime; + + /** + * 16次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_16_overtime") + @ApiModelProperty(value = "16次电流谐波幅值越限次数") + private Integer iharm16Overtime; + + /** + * 17次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_17_overtime") + @ApiModelProperty(value = "17次电流谐波幅值越限次数") + private Integer iharm17Overtime; + + /** + * 18次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_18_overtime") + @ApiModelProperty(value = "18次电流谐波幅值越限次数") + private Integer iharm18Overtime; + + /** + * 19次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_19_overtime") + @ApiModelProperty(value = "19次电流谐波幅值越限次数") + private Integer iharm19Overtime; + + /** + * 20次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_20_overtime") + @ApiModelProperty(value = "20次电流谐波幅值越限次数") + private Integer iharm20Overtime; + + /** + * 21次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_21_overtime") + @ApiModelProperty(value = "21次电流谐波幅值越限次数") + private Integer iharm21Overtime; + + /** + * 22次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_22_overtime") + @ApiModelProperty(value = "22次电流谐波幅值越限次数") + private Integer iharm22Overtime; + + /** + * 23次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_23_overtime") + @ApiModelProperty(value = "23次电流谐波幅值越限次数") + private Integer iharm23Overtime; + + /** + * 24次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_24_overtime") + @ApiModelProperty(value = "24次电流谐波幅值越限次数") + private Integer iharm24Overtime; + + /** + * 25次电流谐波幅值越限次数 + */ + @HarCurrent + @TableField(value = "iharm_25_overtime") + @ApiModelProperty(value = "25次电流谐波幅值越限次数") + private Integer iharm25Overtime; + + /** + * 0.5次间谐波电压限值次数 + */ + @TableField(value = "inuharm_1_overtime") + @InterharVoltage + @ApiModelProperty(value = "0.5次间谐波电压限值次数") + private Integer inuharm1Overtime; + + /** + * 1.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_2_overtime") + @ApiModelProperty(value = "1.5次间谐波电压限值次数") + private Integer inuharm2Overtime; + + /** + * 2.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_3_overtime") + @ApiModelProperty(value = "2.5次间谐波电压限值次数") + private Integer inuharm3Overtime; + + /** + * 3.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_4_overtime") + @ApiModelProperty(value = "3.5次间谐波电压限值次数") + private Integer inuharm4Overtime; + + /** + * 4.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_5_overtime") + @ApiModelProperty(value = "4.5次间谐波电压限值次数") + private Integer inuharm5Overtime; + + /** + * 5.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_6_overtime") + @ApiModelProperty(value = "5.5次间谐波电压限值次数") + private Integer inuharm6Overtime; + + /** + * 6.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_7_overtime") + @ApiModelProperty(value = "6.5次间谐波电压限值次数") + private Integer inuharm7Overtime; + + /** + * 7.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_8_overtime") + @ApiModelProperty(value = "7.5次间谐波电压限值次数") + private Integer inuharm8Overtime; + + /** + * 8.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_9_overtime") + @ApiModelProperty(value = "8.5次间谐波电压限值次数") + private Integer inuharm9Overtime; + + /** + * 9.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_10_overtime") + @ApiModelProperty(value = "9.5次间谐波电压限值次数") + private Integer inuharm10Overtime; + + /** + * 10.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_11_overtime") + @ApiModelProperty(value = "10.5次间谐波电压限值次数") + private Integer inuharm11Overtime; + + /** + * 11.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_12_overtime") + @ApiModelProperty(value = "11.5次间谐波电压限值次数") + private Integer inuharm12Overtime; + + /** + * 12.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_13_overtime") + @ApiModelProperty(value = "12.5次间谐波电压限值次数") + private Integer inuharm13Overtime; + + /** + * 13.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_14_overtime") + @ApiModelProperty(value = "13.5次间谐波电压限值次数") + private Integer inuharm14Overtime; + + /** + * 14.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_15_overtime") + @ApiModelProperty(value = "14.5次间谐波电压限值次数") + private Integer inuharm15Overtime; + + /** + * 15.5次间谐波电压限值次数 + */ + @InterharVoltage + @TableField(value = "inuharm_16_overtime") + @ApiModelProperty(value = "15.5次间谐波电压限值次数") + private Integer inuharm16Overtime; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/po/RStatLimitRateDetailDPO.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/po/RStatLimitRateDetailDPO.java new file mode 100644 index 0000000..d39c15a --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/po/RStatLimitRateDetailDPO.java @@ -0,0 +1,594 @@ +package com.njcn.csharmonic.pojo.po; + +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableName; +import com.fasterxml.jackson.annotation.JsonFormat; +import com.github.jeffreyning.mybatisplus.anno.MppMultiId; +import com.njcn.csharmonic.annotaion.HarCurrent; +import com.njcn.csharmonic.annotaion.HarVoltage; +import com.njcn.csharmonic.annotaion.InterharVoltage; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.time.LocalDate; + +@Data +@AllArgsConstructor +@NoArgsConstructor +@TableName(value = "r_stat_limit_rate_detail_d") +public class RStatLimitRateDetailDPO { + + /** + * 合格率时间 + */ + @MppMultiId + @TableField(value = "time_id") + @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8") + @ApiModelProperty(value = "合格率时间") + private LocalDate time; + + /** + * 监测点ID合格率的变电站/装置/母线/线路序号 + */ + @MppMultiId + @TableField(value = "my_index") + @ApiModelProperty(value = "监测点ID合格率的变电站/装置/母线/线路序号") + private String lineId; + + + /** + * 频率偏差越限数据 + */ + @TableField(value = "freq_dev_overtime") + @ApiModelProperty(value = "频率偏差越限数据") + private String freqDevOvertime; + + /** + * 电压偏差越限数据 + */ + @TableField(value = "voltage_dev_overtime") + @ApiModelProperty(value = "电压偏差越限数据") + private String voltageDevOvertime; + + /** + * 三相电压不平衡度越限数据 + */ + @TableField(value = "ubalance_overtime") + @ApiModelProperty(value = "三相电压不平衡度越限数据") + private String ubalanceOvertime; + /** + * 闪变越限数据 + */ + @TableField(value = "flicker_overtime") + @ApiModelProperty(value = "闪变越限数据") + private String flickerOvertime; + + + /** + * 电压谐波畸变率越限数据 + */ + @TableField(value = "uaberrance_overtime") + @ApiModelProperty(value = "电压谐波畸变率越限数据") + private String uaberranceOvertime; + + /** + * 负序电流限值数据 + */ + @TableField(value = "i_neg_overtime") + @ApiModelProperty(value = "负序电流限值数据") + private String iNegOvertime; + + /** + * 2次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_2_overtime") + @ApiModelProperty(value = "2次电压谐波含有率越限数据") + private String uharm2Overtime; + + /** + * 3次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_3_overtime") + @ApiModelProperty(value = "3次电压谐波含有率越限数据") + private String uharm3Overtime; + + /** + * 4次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_4_overtime") + @ApiModelProperty(value = "4次电压谐波含有率越限数据") + private String uharm4Overtime; + + /** + * 5次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_5_overtime") + @ApiModelProperty(value = "5次电压谐波含有率越限数据") + private String uharm5Overtime; + + /** + * 6次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_6_overtime") + @ApiModelProperty(value = "6次电压谐波含有率越限数据") + private String uharm6Overtime; + + /** + * 7次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_7_overtime") + @ApiModelProperty(value = "7次电压谐波含有率越限数据") + private String uharm7Overtime; + + /** + * 8次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_8_overtime") + @ApiModelProperty(value = "8次电压谐波含有率越限数据") + private String uharm8Overtime; + + /** + * 9次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_9_overtime") + @ApiModelProperty(value = "9次电压谐波含有率越限数据") + private String uharm9Overtime; + + /** + * 10次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_10_overtime") + @ApiModelProperty(value = "10次电压谐波含有率越限数据") + private String uharm10Overtime; + + /** + * 11次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_11_overtime") + @ApiModelProperty(value = "11次电压谐波含有率越限数据") + private String uharm11Overtime; + + /** + * 12次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_12_overtime") + @ApiModelProperty(value = "12次电压谐波含有率越限数据") + private String uharm12Overtime; + + /** + * 13次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_13_overtime") + @ApiModelProperty(value = "13次电压谐波含有率越限数据") + private String uharm13Overtime; + + /** + * 14次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_14_overtime") + @ApiModelProperty(value = "14次电压谐波含有率越限数据") + private String uharm14Overtime; + + /** + * 15次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_15_overtime") + @ApiModelProperty(value = "15次电压谐波含有率越限数据") + private String uharm15Overtime; + + /** + * 16次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_16_overtime") + @ApiModelProperty(value = "16次电压谐波含有率越限数据") + private String uharm16Overtime; + + /** + * 17次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_17_overtime") + @ApiModelProperty(value = "17次电压谐波含有率越限数据") + private String uharm17Overtime; + + /** + * 18次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_18_overtime") + @ApiModelProperty(value = "18次电压谐波含有率越限数据") + private String uharm18Overtime; + + /** + * 19次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_19_overtime") + @ApiModelProperty(value = "19次电压谐波含有率越限数据") + private String uharm19Overtime; + + /** + * 20次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_20_overtime") + @ApiModelProperty(value = "20次电压谐波含有率越限数据") + private String uharm20Overtime; + + /** + * 21次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_21_overtime") + @ApiModelProperty(value = "21次电压谐波含有率越限数据") + private String uharm21Overtime; + + /** + * 22次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_22_overtime") + @ApiModelProperty(value = "22次电压谐波含有率越限数据") + private String uharm22Overtime; + + /** + * 23次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_23_overtime") + @ApiModelProperty(value = "23次电压谐波含有率越限数据") + private String uharm23Overtime; + + /** + * 24次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_24_overtime") + @ApiModelProperty(value = "24次电压谐波含有率越限数据") + private String uharm24Overtime; + + /** + * 25次电压谐波含有率越限数据 + */ + @HarVoltage + @TableField(value = "uharm_25_overtime") + @ApiModelProperty(value = "25次电压谐波含有率越限数据") + private String uharm25Overtime; + + /** + * 2次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_2_overtime") + @ApiModelProperty(value = "2次电流谐波幅值越限数据") + private String iharm2Overtime; + + /** + * 3次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_3_overtime") + @ApiModelProperty(value = "3次电流谐波幅值越限数据") + private String iharm3Overtime; + + /** + * 4次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_4_overtime") + @ApiModelProperty(value = "4次电流谐波幅值越限数据") + private String iharm4Overtime; + + /** + * 5次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_5_overtime") + @ApiModelProperty(value = "5次电流谐波幅值越限数据") + private String iharm5Overtime; + + /** + * 6次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_6_overtime") + @ApiModelProperty(value = "6次电流谐波幅值越限数据") + private String iharm6Overtime; + + /** + * 7次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_7_overtime") + @ApiModelProperty(value = "7次电流谐波幅值越限数据") + private String iharm7Overtime; + + /** + * 8次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_8_overtime") + @ApiModelProperty(value = "8次电流谐波幅值越限数据") + private String iharm8Overtime; + + /** + * 9次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_9_overtime") + @ApiModelProperty(value = "9次电流谐波幅值越限数据") + private String iharm9Overtime; + + /** + * 10次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_10_overtime") + @ApiModelProperty(value = "10次电流谐波幅值越限数据") + private String iharm10Overtime; + + /** + * 11次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_11_overtime") + @ApiModelProperty(value = "11次电流谐波幅值越限数据") + private String iharm11Overtime; + + /** + * 12次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_12_overtime") + @ApiModelProperty(value = "12次电流谐波幅值越限数据") + private String iharm12Overtime; + + /** + * 13次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_13_overtime") + @ApiModelProperty(value = "13次电流谐波幅值越限数据") + private String iharm13Overtime; + + /** + * 14次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_14_overtime") + @ApiModelProperty(value = "14次电流谐波幅值越限数据") + private String iharm14Overtime; + + /** + * 15次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_15_overtime") + @ApiModelProperty(value = "15次电流谐波幅值越限数据") + private String iharm15Overtime; + + /** + * 16次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_16_overtime") + @ApiModelProperty(value = "16次电流谐波幅值越限数据") + private String iharm16Overtime; + + /** + * 17次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_17_overtime") + @ApiModelProperty(value = "17次电流谐波幅值越限数据") + private String iharm17Overtime; + + /** + * 18次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_18_overtime") + @ApiModelProperty(value = "18次电流谐波幅值越限数据") + private String iharm18Overtime; + + /** + * 19次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_19_overtime") + @ApiModelProperty(value = "19次电流谐波幅值越限数据") + private String iharm19Overtime; + + /** + * 20次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_20_overtime") + @ApiModelProperty(value = "20次电流谐波幅值越限数据") + private String iharm20Overtime; + + /** + * 21次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_21_overtime") + @ApiModelProperty(value = "21次电流谐波幅值越限数据") + private String iharm21Overtime; + + /** + * 22次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_22_overtime") + @ApiModelProperty(value = "22次电流谐波幅值越限数据") + private String iharm22Overtime; + + /** + * 23次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_23_overtime") + @ApiModelProperty(value = "23次电流谐波幅值越限数据") + private String iharm23Overtime; + + /** + * 24次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_24_overtime") + @ApiModelProperty(value = "24次电流谐波幅值越限数据") + private String iharm24Overtime; + + /** + * 25次电流谐波幅值越限数据 + */ + @HarCurrent + @TableField(value = "iharm_25_overtime") + @ApiModelProperty(value = "25次电流谐波幅值越限数据") + private String iharm25Overtime; + + /** + * 0.5次间谐波电压限值数据 + */ + @TableField(value = "inuharm_1_overtime") + @InterharVoltage + @ApiModelProperty(value = "0.5次间谐波电压限值数据") + private String inuharm1Overtime; + + /** + * 1.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_2_overtime") + @ApiModelProperty(value = "1.5次间谐波电压限值数据") + private String inuharm2Overtime; + + /** + * 2.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_3_overtime") + @ApiModelProperty(value = "2.5次间谐波电压限值数据") + private String inuharm3Overtime; + + /** + * 3.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_4_overtime") + @ApiModelProperty(value = "3.5次间谐波电压限值数据") + private String inuharm4Overtime; + + /** + * 4.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_5_overtime") + @ApiModelProperty(value = "4.5次间谐波电压限值数据") + private String inuharm5Overtime; + + /** + * 5.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_6_overtime") + @ApiModelProperty(value = "5.5次间谐波电压限值数据") + private String inuharm6Overtime; + + /** + * 6.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_7_overtime") + @ApiModelProperty(value = "6.5次间谐波电压限值数据") + private String inuharm7Overtime; + + /** + * 7.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_8_overtime") + @ApiModelProperty(value = "7.5次间谐波电压限值数据") + private String inuharm8Overtime; + + /** + * 8.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_9_overtime") + @ApiModelProperty(value = "8.5次间谐波电压限值数据") + private String inuharm9Overtime; + + /** + * 9.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_10_overtime") + @ApiModelProperty(value = "9.5次间谐波电压限值数据") + private String inuharm10Overtime; + + /** + * 10.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_11_overtime") + @ApiModelProperty(value = "10.5次间谐波电压限值数据") + private String inuharm11Overtime; + + /** + * 11.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_12_overtime") + @ApiModelProperty(value = "11.5次间谐波电压限值数据") + private String inuharm12Overtime; + + /** + * 12.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_13_overtime") + @ApiModelProperty(value = "12.5次间谐波电压限值数据") + private String inuharm13Overtime; + + /** + * 13.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_14_overtime") + @ApiModelProperty(value = "13.5次间谐波电压限值数据") + private String inuharm14Overtime; + + /** + * 14.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_15_overtime") + @ApiModelProperty(value = "14.5次间谐波电压限值数据") + private String inuharm15Overtime; + + /** + * 15.5次间谐波电压限值数据 + */ + @InterharVoltage + @TableField(value = "inuharm_16_overtime") + @ApiModelProperty(value = "15.5次间谐波电压限值数据") + private String inuharm16Overtime; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitCalendarVO.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitCalendarVO.java new file mode 100644 index 0000000..077bf93 --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitCalendarVO.java @@ -0,0 +1,23 @@ +package com.njcn.csharmonic.pojo.vo; + +import com.fasterxml.jackson.annotation.JsonFormat; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.time.LocalDate; +import java.util.List; + +@Data +public class LimitCalendarVO { + @ApiModelProperty("发生日期") + @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8") + private LocalDate time; + + @ApiModelProperty("越限项") + private List items; + + @ApiModelProperty("越限程度， 0:无 1:一般（超过限值80%以下）2:严重（超过限值80%以上）") + private int status; + + +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitExtentVO.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitExtentVO.java new file mode 100644 index 0000000..62c4c3d --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitExtentVO.java @@ -0,0 +1,49 @@ +package com.njcn.csharmonic.pojo.vo; + +import com.fasterxml.jackson.annotation.JsonFormat; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.time.LocalDate; + +@Data +public class LimitExtentVO { + + @ApiModelProperty("指标编码") + private String code; + @ApiModelProperty("指标名称") + private String name; + + @ApiModelProperty("越限最大值") + private float maxValue; + + @ApiModelProperty("国际限值") + private float internationalValue; + + @ApiModelProperty("越限程度") + private float extent; + + @ApiModelProperty("发生日期") + @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8") + private LocalDate time; + + @ApiModelProperty(value = "监测点ID合格率的变电站/装置/母线/线路序号") + private String lineId; + @ApiModelProperty("监测点名称") + private String lineName; + + + public float getExtent() { + if (internationalValue == 0) { + return 0.00F; + } + if (maxValue == 0) { + return 0.00F; + } + if (maxValue < internationalValue) { + return 0.00F; + } + return (maxValue - internationalValue) / internationalValue * 100; + } + +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitProbabilityVO.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitProbabilityVO.java new file mode 100644 index 0000000..0a6a8f1 --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitProbabilityVO.java @@ -0,0 +1,22 @@ +package com.njcn.csharmonic.pojo.vo; + +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.util.List; +import java.util.Map; + +@Data +public class LimitProbabilityVO { + + @ApiModelProperty("监测点id") + private String lineId; + @ApiModelProperty("监测点名称") + private String lineName; + @ApiModelProperty("指标名称") + private String indexName; + @ApiModelProperty("指标编码") + private String indexCode; + @ApiModelProperty("越限程度档级对应次数") + private List> extentGrades; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitTimeProbabilityVO.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitTimeProbabilityVO.java new file mode 100644 index 0000000..3f906e7 --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitTimeProbabilityVO.java @@ -0,0 +1,21 @@ +package com.njcn.csharmonic.pojo.vo; + +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +@Data +public class LimitTimeProbabilityVO { + + @ApiModelProperty("时间段") + private String timePeriod; + @ApiModelProperty("次数") + private int times; + @ApiModelProperty("监测点id") + private String lineId; + @ApiModelProperty("监测点名称") + private String lineName; + @ApiModelProperty("指标名称") + private String indexName; + @ApiModelProperty("指标编码") + private String indexCode; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MainLineStatLimitRateDetailsVO.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MainLineStatLimitRateDetailsVO.java new file mode 100644 index 0000000..c1d544b --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MainLineStatLimitRateDetailsVO.java @@ -0,0 +1,11 @@ +package com.njcn.csharmonic.pojo.vo; + +import com.njcn.csharmonic.pojo.po.RStatLimitRateDPO; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +@Data +public class MainLineStatLimitRateDetailsVO extends RStatLimitRateDPO { + @ApiModelProperty("监测点名称") + private String lineName; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MainLineVO.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MainLineVO.java new file mode 100644 index 0000000..00d81d2 --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MainLineVO.java @@ -0,0 +1,21 @@ +package com.njcn.csharmonic.pojo.vo; + +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.io.Serializable; + + +@Data +public class MainLineVO implements Serializable { + @ApiModelProperty("监测点ID") + private String lineId; + @ApiModelProperty("监测点名称") + private String lineName; + @ApiModelProperty("监测对象类型") + private String objType; + @ApiModelProperty("是否治理") + private String govern; + @ApiModelProperty("主要存在的电能质量问题") + private String problems; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MonitorOverLimitVO.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MonitorOverLimitVO.java new file mode 100644 index 0000000..3ed914d --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MonitorOverLimitVO.java @@ -0,0 +1,145 @@ +package com.njcn.csharmonic.pojo.vo; + +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/9 11:23 + */ +@Data +public class MonitorOverLimitVO { + + @ApiModelProperty("监测点id") + private String id; + + @ApiModelProperty("省公司") + private String provinceCompany; + + @ApiModelProperty("地市公司") + private String cityCompany; + + @ApiModelProperty("监测点名称") + private String lineName; + + @ApiModelProperty("干扰源类型") + private String loadType; + + @ApiModelProperty("监测点对象名称") + private String lineObjectName; + + @ApiModelProperty("监测点电压等级") + private String lineScale; + + @ApiModelProperty("厂家") + private String manufacturer; + + @ApiModelProperty("变电站名称") + private String subName; + + @ApiModelProperty("变电站电压等级") + private String subScale; + + @ApiModelProperty("超标天数") + private Integer overDay; + + @ApiModelProperty("频率偏差超标天数") + private Integer freqOverDay; + + @ApiModelProperty("电压偏差超标天数") + private Integer volDevOverDay; + + @ApiModelProperty("谐波电压超标天数") + private Integer harmVolOverDay; + + @ApiModelProperty("电压总谐波畸变率超标天数") + private Integer volDisOverDay; + @ApiModelProperty("谐波电压含有率超标天数") + private Integer volContainOverDay; + @ApiModelProperty("谐波电流超标天数") + private Integer harmCurOverDay; + + /** + *各次谐波电压含有率 + */ + @ApiModelProperty("3次") + private Integer overVolThreeTimes; + + @ApiModelProperty("5次") + private Integer overVolFiveTimes; + + @ApiModelProperty("7次") + private Integer overVolSevenTimes; + + @ApiModelProperty("11次") + private Integer overVolElevenTimes; + + @ApiModelProperty("13次") + private Integer overVolThirteenTimes; + + @ApiModelProperty("23次") + private Integer overVolTwentyThreeTimes; + + @ApiModelProperty("25次") + private Integer overVolTwentyFiveTimes; + + @ApiModelProperty("其他次") + private Integer overVolOtherTimes; + + /** + *各次谐波电流含量 + */ + @ApiModelProperty("3次") + private Integer overCurThreeTimes; + + @ApiModelProperty("5次") + private Integer overCurFiveTimes; + + @ApiModelProperty("7次") + private Integer overCurSevenTimes; + + @ApiModelProperty("11次") + private Integer overCurElevenTimes; + + @ApiModelProperty("13次") + private Integer overCurThirteenTimes; + + @ApiModelProperty("23次") + private Integer overCurTwentyThreeTimes; + + @ApiModelProperty("25次") + private Integer overCurTwentyFiveTimes; + + @ApiModelProperty("其他次") + private Integer overCurOtherTimes; + + @ApiModelProperty("间谐波电压含有率超标天数") + private Integer intHarmOverDay; + + @ApiModelProperty("三相电压不平衡度超标天数") + private Integer threeUnbalance; + + @ApiModelProperty("负序电流超标天数") + private Integer negativeOverDay; + + @ApiModelProperty("闪变超标天数") + private Integer flickerOverDay; + + @ApiModelProperty("监测点编号") + private String monitorNumber; + + @Data + public static class DataVO { + private static final long serialVersionUID = 1L; + + @ApiModelProperty("日期") + private String time; + + @ApiModelProperty("数据") + private Double data; + + } +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/RStatLimitRateDVO.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/RStatLimitRateDVO.java new file mode 100644 index 0000000..08a689d --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/RStatLimitRateDVO.java @@ -0,0 +1,34 @@ +package com.njcn.csharmonic.pojo.vo; + +import lombok.Data; + +/** + * <功能描述> + * + * @author wr + * @createTime: 2023-04-03 + */ +@Data +public class RStatLimitRateDVO { + private static final long serialVersionUID = 1L; + + private Integer alltime; + + private Integer frequency; + + private Integer uBalance; + + private Integer iNeg; + + private Integer harmElec; + + private Integer harmVoltage; + + private Integer flicker; + + private Integer allFlicker; + + private Integer voltageDeviation; + + private Integer inUharm; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java new file mode 100644 index 0000000..7a226f1 --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java @@ -0,0 +1,207 @@ +package com.njcn.csharmonic.pojo.vo; + +import com.fasterxml.jackson.annotation.JsonFormat; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +import java.time.LocalDate; + +@Data +public class TotalLimitStatisticsDetailsVO { + @ApiModelProperty("监测点名称") + private String lineName; + + @ApiModelProperty(value = "监测点ID合格率的变电站/装置/母线/线路序号") + private String lineId; + + @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8") + @ApiModelProperty(value = "合格率时间") + private LocalDate time; + + @ApiModelProperty(value = "总计算次数") + private Integer allTime; + + @ApiModelProperty(value = "闪变越限次数") + private Integer flickerOvertime; + + + @ApiModelProperty(value = "频率偏差越限") + private double freqDevOvertime; + + @ApiModelProperty(value = "电压偏差越限") + private double voltageDevOvertime; + + @ApiModelProperty(value = "三相电压不平衡度越限") + private double ubalanceOvertime; + + @ApiModelProperty(value = "电压谐波畸变率越限") + private double uaberranceOvertime; + + @ApiModelProperty(value = "负序电流限值") + private double iNegOvertime; + + @ApiModelProperty(value = "2次电压谐波含有率越限") + private double uharm2Overtime; + + @ApiModelProperty(value = "3次电压谐波含有率越限") + private double uharm3Overtime; + + @ApiModelProperty(value = "4次电压谐波含有率越限") + private double uharm4Overtime; + + @ApiModelProperty(value = "5次电压谐波含有率越限") + private double uharm5Overtime; + + @ApiModelProperty(value = "6次电压谐波含有率越限") + private double uharm6Overtime; + + @ApiModelProperty(value = "7次电压谐波含有率越限") + private double uharm7Overtime; + + @ApiModelProperty(value = "8次电压谐波含有率越限") + private double uharm8Overtime; + + @ApiModelProperty(value = "9次电压谐波含有率越限") + private double uharm9Overtime; + + @ApiModelProperty(value = "10次电压谐波含有率越限") + private double uharm10Overtime; + + @ApiModelProperty(value = "11次电压谐波含有率越限") + private double uharm11Overtime; + + @ApiModelProperty(value = "12次电压谐波含有率越限") + private double uharm12Overtime; + + @ApiModelProperty(value = "13次电压谐波含有率越限") + private double uharm13Overtime; + + @ApiModelProperty(value = "14次电压谐波含有率越限") + private double uharm14Overtime; + + @ApiModelProperty(value = "15次电压谐波含有率越限") + private double uharm15Overtime; + + @ApiModelProperty(value = "16次电压谐波含有率越限") + private double uharm16Overtime; + + @ApiModelProperty(value = "17次电压谐波含有率越限") + private double uharm17Overtime; + + + @ApiModelProperty(value = "18次电压谐波含有率越限") + private double uharm18Overtime; + + + @ApiModelProperty(value = "19次电压谐波含有率越限") + private double uharm19Overtime; + + + @ApiModelProperty(value = "20次电压谐波含有率越限") + private double uharm20Overtime; + + + @ApiModelProperty(value = "21次电压谐波含有率越限") + private double uharm21Overtime; + + @ApiModelProperty(value = "22次电压谐波含有率越限") + private double uharm22Overtime; + + + @ApiModelProperty(value = "23次电压谐波含有率越限") + private double uharm23Overtime; + + @ApiModelProperty(value = "24次电压谐波含有率越限") + private double uharm24Overtime; + + @ApiModelProperty(value = "25次电压谐波含有率越限") + private double uharm25Overtime; + + @ApiModelProperty(value = "2次电流谐波幅值越限") + private double iharm2Overtime; + + @ApiModelProperty(value = "3次电流谐波幅值越限") + private double iharm3Overtime; + + @ApiModelProperty(value = "4次电流谐波幅值越限") + private double iharm4Overtime; + + + @ApiModelProperty(value = "5次电流谐波幅值越限") + private double iharm5Overtime; + + + @ApiModelProperty(value = "6次电流谐波幅值越限") + private double iharm6Overtime; + + @ApiModelProperty(value = "7次电流谐波幅值越限") + private double iharm7Overtime; + + @ApiModelProperty(value = "8次电流谐波幅值越限") + private double iharm8Overtime; + + @ApiModelProperty(value = "9次电流谐波幅值越限") + private double iharm9Overtime; + + @ApiModelProperty(value = "10次电流谐波幅值越限") + private double iharm10Overtime; + + + @ApiModelProperty(value = "11次电流谐波幅值越限") + private double iharm11Overtime; + + + @ApiModelProperty(value = "12次电流谐波幅值越限") + private double iharm12Overtime; + + + @ApiModelProperty(value = "13次电流谐波幅值越限") + private double iharm13Overtime; + + + @ApiModelProperty(value = "14次电流谐波幅值越限") + private double iharm14Overtime; + + + @ApiModelProperty(value = "15次电流谐波幅值越限") + private double iharm15Overtime; + + + @ApiModelProperty(value = "16次电流谐波幅值越限") + private double iharm16Overtime; + + + @ApiModelProperty(value = "17次电流谐波幅值越限") + private double iharm17Overtime; + + + @ApiModelProperty(value = "18次电流谐波幅值越限") + private double iharm18Overtime; + + + @ApiModelProperty(value = "19次电流谐波幅值越限") + private double iharm19Overtime; + + + @ApiModelProperty(value = "20次电流谐波幅值越限") + private double iharm20Overtime; + + + @ApiModelProperty(value = "21次电流谐波幅值越限") + private double iharm21Overtime; + + + @ApiModelProperty(value = "22次电流谐波幅值越限") + private double iharm22Overtime; + + + @ApiModelProperty(value = "23次电流谐波幅值越限") + private double iharm23Overtime; + + + @ApiModelProperty(value = "24次电流谐波幅值越限") + private double iharm24Overtime; + + @ApiModelProperty(value = "25次电流谐波幅值越限") + private double iharm25Overtime; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitStatisticsVO.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitStatisticsVO.java new file mode 100644 index 0000000..25f3eef --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitStatisticsVO.java @@ -0,0 +1,15 @@ +package com.njcn.csharmonic.pojo.vo; + +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; +import lombok.EqualsAndHashCode; + +@EqualsAndHashCode(callSuper = true) +@Data +public class TotalLimitStatisticsVO extends TotalLimitTotalStatisticsVO { + + @ApiModelProperty("监测点ID") + private String lineId; + @ApiModelProperty("监测点名称") + private String lineName; +} diff --git a/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitTotalStatisticsVO.java b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitTotalStatisticsVO.java new file mode 100644 index 0000000..32c1d16 --- /dev/null +++ b/cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitTotalStatisticsVO.java @@ -0,0 +1,19 @@ +package com.njcn.csharmonic.pojo.vo; + +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +@Data +public class TotalLimitTotalStatisticsVO { + + @ApiModelProperty("闪变越限占比") + private double flicker; + @ApiModelProperty("谐波电压越限占比") + private double uharm; + @ApiModelProperty("谐波电流越限占比") + private double iharm; + @ApiModelProperty("电压偏差越限占比") + private double voltageDev; + @ApiModelProperty("三相不平衡越限占比") + private double ubalance; +} diff --git a/cs-harmonic/cs-harmonic-boot/pom.xml b/cs-harmonic/cs-harmonic-boot/pom.xml index 1367ad1..afad97a 100644 --- a/cs-harmonic/cs-harmonic-boot/pom.xml +++ b/cs-harmonic/cs-harmonic-boot/pom.xml @@ -135,11 +135,6 @@ message-api 1.0.0 - - com.njcn - harmonic-common - 1.0.0 - diff --git a/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/controller/RStatLimitRateDController.java b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/controller/RStatLimitRateDController.java new file mode 100644 index 0000000..4be5f9b --- /dev/null +++ b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/controller/RStatLimitRateDController.java @@ -0,0 +1,159 @@ +package com.njcn.csharmonic.controller; + + +import cn.hutool.core.util.StrUtil; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.njcn.common.pojo.annotation.OperateInfo; +import com.njcn.common.pojo.enums.common.LogEnum; +import com.njcn.common.pojo.enums.response.CommonResponseEnum; +import com.njcn.common.pojo.response.HttpResult; +import com.njcn.common.utils.HttpResultUtil; +import com.njcn.csharmonic.pojo.param.*; +import com.njcn.csharmonic.pojo.po.RStatLimitRateDPO; +import com.njcn.csharmonic.pojo.vo.*; +import com.njcn.csharmonic.service.IRStatLimitRateDService; +import com.njcn.web.controller.BaseController; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiImplicitParam; +import io.swagger.annotations.ApiImplicitParams; +import io.swagger.annotations.ApiOperation; +import lombok.RequiredArgsConstructor; +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.RequestParam; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +@Validated +@RestController +@RequiredArgsConstructor +@Api(tags = "合格率统计日表(越限次数)") +public class RStatLimitRateDController extends BaseController { + + private final IRStatLimitRateDService limitRateDService; + + /** + * 来源于RStatLimitController的monitorIdsGetLimitRateInfo + */ + @PostMapping("/limitRateD/monitorIdsGetLimitRateInfo") + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @ApiOperation("获取指定日期超标监测点详细信息") + public HttpResult> monitorIdsGetLimitRateInfo(@RequestBody RStatLimitQueryParam rStatLimitQueryParam) { + String methodDescribe = getMethodDescribe("monitorIdsGetLimitRateInfo"); + List result = limitRateDService.monitorIdsGetLimitRateInfo(rStatLimitQueryParam.getDate(), rStatLimitQueryParam.getIds()); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe); + } + + /** + * 来源于RStatLimitController的getOverData + */ + @PostMapping("/getOverData") + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @ApiOperation("查询单监测点超标数据") + @ApiImplicitParams({ + @ApiImplicitParam(name = "lineId", value = "监测点id"), + @ApiImplicitParam(name = "startTime", value = "开始时间"), + @ApiImplicitParam(name = "endTime", value = "结束时间"), + @ApiImplicitParam(name = "type", value = "指标"), + }) + public HttpResult> getOverData(@RequestParam("lineId") String lineId, @RequestParam("startTime") String startTime, @RequestParam("endTime") String endTime, @RequestParam("type") Integer type) { + String methodDescribe = getMethodDescribe("getOverData"); + List result = limitRateDService.getOverData(lineId, startTime, endTime, type); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe); + } + + + /** + * 来源于 HistoryResultController的getLinesRate + */ + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @PostMapping("/harmonic/getLinesRate") + @ApiOperation("获取越线监测点越线次数") + @ApiImplicitParam(name = "param", value = "获取越线监测点越线次数请求参数", required = true) + public HttpResult> getLinesRate(@RequestBody StatSubstationBizBaseParam param) { + String methodDescribe = getMethodDescribe("getLinesTarget"); + List list = limitRateDService.list(new LambdaQueryWrapper() + .in(RStatLimitRateDPO::getLineId, param.getIds()) + .eq(RStatLimitRateDPO::getPhasicType, "T") + .ge(StrUtil.isNotBlank(param.getStartTime()), RStatLimitRateDPO::getTime, param.getStartTime()) + .le(StrUtil.isNotBlank(param.getEndTime()), RStatLimitRateDPO::getTime, param.getEndTime()) + + ); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe); + } + + @PostMapping("/mainLine/list") + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @ApiOperation("获取主要监测点列表") + public HttpResult> mainLineList(@RequestBody MainLineQueryParam mainLineQueryParam) { + String methodDescribe = getMethodDescribe("mainLineList"); + Page list = limitRateDService.mainLineList(mainLineQueryParam); + + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe); + } + + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @PostMapping("/mainLine/statLimitRateDetails") + @ApiOperation("监测点指标越限详情") + @ApiImplicitParam(name = "param", value = "获取监测点指标越限详情请求参数", required = true) + public HttpResult> mainLineStatLimitRateDetails(@RequestBody MainLineStatLimitRateDetailsQueryParam param) { + String methodDescribe = getMethodDescribe("mainLineStatLimitRateDetails"); + List list = limitRateDService.mainLineStatLimitRateDetails(param); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe); + } + + + @PostMapping("/totalLimitStatistics/data") + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @ApiOperation("总体指标越限统计数据") + public HttpResult totalLimitTotalStatisticsData(@RequestBody TotalLimitStatisticsParam mainLineQueryParam) { + String methodDescribe = getMethodDescribe("totalLimitStatisticsList"); + TotalLimitTotalStatisticsVO data = limitRateDService.totalLimitTotalStatisticsData(mainLineQueryParam); + + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, data, methodDescribe); + } + + @PostMapping("/totalLimitStatistics/list") + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @ApiOperation("总体指标越限统计列表") + public HttpResult> totalLimitStatisticsList(@RequestBody TotalLimitStatisticsParam mainLineQueryParam) { + String methodDescribe = getMethodDescribe("totalLimitStatisticsList"); + List list = limitRateDService.totalLimitStatisticsList(mainLineQueryParam); + + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe); + } + + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @PostMapping("/totalLimitStatistics/details") + @ApiOperation("每日越限占比统计") + @ApiImplicitParam(name = "param", value = "每日越限占比统计请求参数", required = true) + public HttpResult> totalLimitStatisticsDetails(@RequestBody TotalLimitStatisticsDetailsQueryParam param) { + String methodDescribe = getMethodDescribe("totalLimitStatisticsDetails"); + List list = limitRateDService.totalLimitStatisticsDetails(param); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe); + } + + + @PostMapping("/gridSideLimitStatistics/data") + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @ApiOperation("电网侧指标越限统计数据") + public HttpResult gridSideLimitTotalStatisticsData(@RequestBody TotalLimitStatisticsParam mainLineQueryParam) { + String methodDescribe = getMethodDescribe("gridSideLimitTotalStatisticsData"); + TotalLimitTotalStatisticsVO data = limitRateDService.gridSideLimitTotalStatisticsData(mainLineQueryParam); + + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, data, methodDescribe); + } + + @PostMapping("/gridSideLimitStatistics/list") + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @ApiOperation("电网侧指标越限统计列表") + public HttpResult> gridSideLimitStatisticsList(@RequestBody TotalLimitStatisticsParam mainLineQueryParam) { + String methodDescribe = getMethodDescribe("gridSideLimitStatisticsList"); + List list = limitRateDService.gridSideLimitStatisticsList(mainLineQueryParam); + + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe); + } +} diff --git a/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/controller/RStatLimitRateDetailDController.java b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/controller/RStatLimitRateDetailDController.java new file mode 100644 index 0000000..96e0407 --- /dev/null +++ b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/controller/RStatLimitRateDetailDController.java @@ -0,0 +1,85 @@ +package com.njcn.csharmonic.controller; + + +import cn.hutool.json.JSONArray; +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.csharmonic.pojo.param.LimitCalendarQueryParam; +import com.njcn.csharmonic.pojo.param.LimitExtentDayQueryParam; +import com.njcn.csharmonic.pojo.param.LimitExtentQueryParam; +import com.njcn.csharmonic.pojo.param.LimitProbabilityQueryParam; +import com.njcn.csharmonic.pojo.vo.LimitCalendarVO; +import com.njcn.csharmonic.pojo.vo.LimitExtentVO; +import com.njcn.csharmonic.pojo.vo.LimitProbabilityVO; +import com.njcn.csharmonic.pojo.vo.LimitTimeProbabilityVO; +import com.njcn.csharmonic.service.IRStatLimitRateDetailDService; +import com.njcn.web.controller.BaseController; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.RequiredArgsConstructor; +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.RestController; + +import java.util.List; + +@Validated +@RestController +@RequiredArgsConstructor +@Api(tags = "合格率统计日表详细(越限详情)") +public class RStatLimitRateDetailDController extends BaseController { + + private final IRStatLimitRateDetailDService limitRateDetailDService; + + @PostMapping("/limitRateDetailD/limitExtentData") + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @ApiOperation("获取指标越限程度数据") + public HttpResult> limitExtentData(@RequestBody LimitExtentQueryParam queryParam) { + String methodDescribe = getMethodDescribe("limitExtentData"); + List result = limitRateDetailDService.limitExtentData(queryParam); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe); + } + + @PostMapping("/limitRateDetailD/limitExtentDayData") + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @ApiOperation("获取指标日趋势图数据") + public HttpResult limitExtentDayData(@RequestBody LimitExtentDayQueryParam queryParam) { + String methodDescribe = getMethodDescribe("limitExtentDayData"); + JSONArray result = limitRateDetailDService.limitExtentDayData(queryParam); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe); + } + + @PostMapping("/limitRateDetailD/limitCalendarData") + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @ApiOperation("获取指标越限明细日历数据") + public HttpResult> limitCalendarData(@RequestBody LimitCalendarQueryParam queryParam) { + String methodDescribe = getMethodDescribe("limitCalendarData"); + List result = limitRateDetailDService.limitCalendarData(queryParam); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe); + } + + + @PostMapping("/limitRateDetailD/limitProbabilityData") + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @ApiOperation("获取指标越限程度概率分布数据") + public HttpResult> limitProbabilityData(@RequestBody LimitProbabilityQueryParam queryParam) { + String methodDescribe = getMethodDescribe("limitProbabilityData"); + List result = limitRateDetailDService.limitProbabilityData(queryParam); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe); + } + + @PostMapping("/limitRateDetailD/limitTimeProbabilityData") + @OperateInfo(info = LogEnum.BUSINESS_COMMON) + @ApiOperation("获取指标越限时间概率分布数据") + public HttpResult> limitTimeProbabilityData(@RequestBody LimitProbabilityQueryParam queryParam) { + String methodDescribe = getMethodDescribe("limitTimeProbabilityData"); + List result = limitRateDetailDService.limitTimeProbabilityData(queryParam); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe); + } + + +} diff --git a/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/RStatLimitRateDMapper.java b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/RStatLimitRateDMapper.java new file mode 100644 index 0000000..05ec975 --- /dev/null +++ b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/RStatLimitRateDMapper.java @@ -0,0 +1,76 @@ +package com.njcn.csharmonic.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.njcn.csharmonic.pojo.po.RStatLimitRateDPO; +import com.njcn.csharmonic.pojo.vo.MonitorOverLimitVO; +import com.njcn.csharmonic.pojo.vo.RStatLimitRateDVO; +import org.apache.ibatis.annotations.Param; + +import java.util.List; + +/** + *

+ * 合格率统计日表(越限次数) Mapper 接口 + *

+ * + * @author wr + * @since 2023-04-03 + */ +public interface RStatLimitRateDMapper extends BaseMapper { + + List getSumPassRate( + @Param("ids") List lineIndexes, + @Param("statTime") String searchBeginTime, + @Param("endTime") String searchEndTime); + + + List getSumLimitRateByLineIndexes( + @Param("ids") List lineIndexes, + @Param("statTime") String searchBeginTime, + @Param("endTime") String searchEndTime); + + Page getSumLimitRatePage(Page p, + @Param("ids") List lineIndexes, + @Param("statTime") String searchBeginTime, + @Param("endTime") String searchEndTime); + + List getPercentages( + @Param("ids") List lineIndexes, + @Param("statTime") String searchBeginTime, + @Param("endTime") String searchEndTime); + + + /** + * 数据查询 + * @param list + * @param startTime + * @param endTime + * @return + */ + List getSumPassRateList( @Param("ids") List list, + @Param("statTime") String startTime, + @Param("endTime") String endTime); + + /** + * 获取综合评估下的指标完整率 + * @param list + * @param startTime + * @param endTime + * @return111 + */ + List getAssessTargetRate( @Param("ids") List list, + @Param("statTime") String startTime, + @Param("endTime") String endTime); + + /** + * 获取监测点的超标次数 + * @param list + * @param startTime + * @param endTime + * @return + */ + List getAllOverTimes( @Param("ids") List list, + @Param("statTime") String startTime, + @Param("endTime") String endTime); +} diff --git a/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/RStatLimitRateDetailDMapper.java b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/RStatLimitRateDetailDMapper.java new file mode 100644 index 0000000..f478079 --- /dev/null +++ b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/RStatLimitRateDetailDMapper.java @@ -0,0 +1,9 @@ +package com.njcn.csharmonic.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.njcn.csharmonic.pojo.po.RStatLimitRateDetailDPO; + + +public interface RStatLimitRateDetailDMapper extends BaseMapper { + +} diff --git a/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/mapping/RStatLimitRateDMapper.xml b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/mapping/RStatLimitRateDMapper.xml new file mode 100644 index 0000000..f8c9738 --- /dev/null +++ b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/mapping/RStatLimitRateDMapper.xml @@ -0,0 +1,475 @@ + + + + + + + + + + + + + + + + + diff --git a/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/mapping/RStatLimitRateDetailDMapper.xml b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/mapping/RStatLimitRateDetailDMapper.xml new file mode 100644 index 0000000..256567c --- /dev/null +++ b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/mapping/RStatLimitRateDetailDMapper.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/IRStatLimitRateDService.java b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/IRStatLimitRateDService.java new file mode 100644 index 0000000..7b284f9 --- /dev/null +++ b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/IRStatLimitRateDService.java @@ -0,0 +1,48 @@ +package com.njcn.csharmonic.service; + +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.IService; +import com.njcn.csharmonic.pojo.param.MainLineQueryParam; +import com.njcn.csharmonic.pojo.param.MainLineStatLimitRateDetailsQueryParam; +import com.njcn.csharmonic.pojo.param.TotalLimitStatisticsDetailsQueryParam; +import com.njcn.csharmonic.pojo.param.TotalLimitStatisticsParam; +import com.njcn.csharmonic.pojo.po.RStatLimitRateDPO; +import com.njcn.csharmonic.pojo.vo.*; + +import java.util.List; + +/** + *

+ * 合格率统计日表(越限次数) 服务类 + *

+ * + * @author wr + * @since 2023-04-03 + */ +public interface IRStatLimitRateDService extends IService { + + /** + * 获取指定日期的监测点超标详情 + * + * @author cdf + * @date 2024/2/28 + */ + List monitorIdsGetLimitRateInfo(String date, List monitorIds); + + List getOverData(String lineId, String startTime, String endTime, Integer type); + + Page mainLineList(MainLineQueryParam param); + + List mainLineStatLimitRateDetails(MainLineStatLimitRateDetailsQueryParam param); + + TotalLimitTotalStatisticsVO totalLimitTotalStatisticsData(TotalLimitStatisticsParam param); + + List totalLimitStatisticsList(TotalLimitStatisticsParam param); + + List totalLimitStatisticsDetails(TotalLimitStatisticsDetailsQueryParam param); + + TotalLimitTotalStatisticsVO gridSideLimitTotalStatisticsData(TotalLimitStatisticsParam param); + + List gridSideLimitStatisticsList(TotalLimitStatisticsParam param); + +} diff --git a/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/IRStatLimitRateDetailDService.java b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/IRStatLimitRateDetailDService.java new file mode 100644 index 0000000..6d9939c --- /dev/null +++ b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/IRStatLimitRateDetailDService.java @@ -0,0 +1,30 @@ +package com.njcn.csharmonic.service; + +import cn.hutool.json.JSONArray; +import com.baomidou.mybatisplus.extension.service.IService; +import com.njcn.csharmonic.pojo.param.LimitCalendarQueryParam; +import com.njcn.csharmonic.pojo.param.LimitExtentDayQueryParam; +import com.njcn.csharmonic.pojo.param.LimitExtentQueryParam; +import com.njcn.csharmonic.pojo.param.LimitProbabilityQueryParam; +import com.njcn.csharmonic.pojo.po.RStatLimitRateDetailDPO; +import com.njcn.csharmonic.pojo.vo.LimitCalendarVO; +import com.njcn.csharmonic.pojo.vo.LimitExtentVO; +import com.njcn.csharmonic.pojo.vo.LimitProbabilityVO; +import com.njcn.csharmonic.pojo.vo.LimitTimeProbabilityVO; + +import java.util.List; + + +public interface IRStatLimitRateDetailDService extends IService { + + + List limitExtentData(LimitExtentQueryParam param); + + JSONArray limitExtentDayData(LimitExtentDayQueryParam param); + + List limitCalendarData(LimitCalendarQueryParam param); + + List limitProbabilityData(LimitProbabilityQueryParam param); + + List limitTimeProbabilityData(LimitProbabilityQueryParam param); +} diff --git a/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/impl/RStatLimitRateDServiceImpl.java b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/impl/RStatLimitRateDServiceImpl.java new file mode 100644 index 0000000..cf16f2c --- /dev/null +++ b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/impl/RStatLimitRateDServiceImpl.java @@ -0,0 +1,600 @@ +package com.njcn.csharmonic.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import cn.hutool.core.collection.CollUtil; +import cn.hutool.core.util.StrUtil; +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.baomidou.dynamic.datasource.annotation.DS; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.njcn.common.pojo.response.HttpResult; +import com.njcn.csdevice.api.CsLineFeignClient; +import com.njcn.csdevice.pojo.po.CsLinePO; +import com.njcn.csharmonic.mapper.RStatLimitRateDMapper; +import com.njcn.csharmonic.pojo.param.MainLineQueryParam; +import com.njcn.csharmonic.pojo.param.MainLineStatLimitRateDetailsQueryParam; +import com.njcn.csharmonic.pojo.param.TotalLimitStatisticsDetailsQueryParam; +import com.njcn.csharmonic.pojo.param.TotalLimitStatisticsParam; +import com.njcn.csharmonic.pojo.po.RStatLimitRateDPO; +import com.njcn.csharmonic.pojo.vo.*; +import com.njcn.csharmonic.service.IRStatLimitRateDService; +import com.njcn.system.api.DicDataFeignClient; +import com.njcn.system.pojo.po.DictData; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.text.DecimalFormat; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +/** + *

+ * 合格率统计日表(越限次数) 服务实现类 + *

+ * + * @author wr + * @since 2023-04-03 + */ +@DS("sjzx") +@RequiredArgsConstructor +@Service +public class RStatLimitRateDServiceImpl extends ServiceImpl implements IRStatLimitRateDService { + + private final CsLineFeignClient csLineFeignClient; + private final DicDataFeignClient dicDataFeignClient; + private final DecimalFormat df = new DecimalFormat("#0.00"); + + private final String GRID_SIDE_DICT_CODE = "Grid_Side"; + + @Override + public List monitorIdsGetLimitRateInfo(String date, List monitorIds) { + return this.baseMapper.selectList(new LambdaQueryWrapper() + .in(RStatLimitRateDPO::getLineId, monitorIds).eq(RStatLimitRateDPO::getTime, date).eq(RStatLimitRateDPO::getPhasicType, "T")); + } + + + @Override + public List getOverData(String lineId, String startTime, String endTime, Integer type) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.lambda() + .eq(RStatLimitRateDPO::getLineId, lineId) + .between(RStatLimitRateDPO::getTime, startTime, endTime) + .groupBy(RStatLimitRateDPO::getTime); + //频率偏差 + if (type == 1) { + queryWrapper.select("time_id time,max(freq_dev_overtime) freq_dev_overtime"); + queryWrapper.lambda().gt(RStatLimitRateDPO::getFreqDevOvertime, 0); + } + //电压偏差 + else if (type == 2) { + queryWrapper.select("time_id time,max(voltage_dev_overtime) voltage_dev_overtime"); + queryWrapper.lambda().gt(RStatLimitRateDPO::getVoltageDevOvertime, 0); + } + //长时闪变 + else if (type == 3) { + queryWrapper.select("time_id time,max(flicker_overtime) flicker_overtime"); + queryWrapper.lambda().gt(RStatLimitRateDPO::getFlickerOvertime, 0); + } + //电压总谐波畸变率 + else if (type == 4) { + queryWrapper.select("time_id time,max(uaberrance_overtime) uaberrance_overtime"); + queryWrapper.lambda().gt(RStatLimitRateDPO::getUaberranceOvertime, 0); + } + //负序电压不平衡度 + else if (type == 5) { + queryWrapper.select("time_id time,max(ubalance_overtime) ubalance_overtime"); + queryWrapper.lambda().gt(RStatLimitRateDPO::getUbalanceOvertime, 0); + } + //负序电流 + else if (type == 6) { + queryWrapper.select("time_id time,max(i_neg_overtime) i_neg_overtime"); + queryWrapper.lambda().gt(RStatLimitRateDPO::getINegOvertime, 0); + } + //谐波电压含有率 + else if (type == 7) { + StringBuilder selectSql = new StringBuilder(); + StringBuilder havingSql = new StringBuilder(); + for (int i = 2; i <= 25; i++) { + selectSql.append("max(uharm_").append(i).append("_overtime) uharm_").append(i).append("_overtime,"); + if (i == 25) { + havingSql.append("uharm_").append(i).append("_overtime"); + } else { + havingSql.append("uharm_").append(i).append("_overtime + "); + } + } + selectSql.append("time_id time"); + havingSql = new StringBuilder("sum(" + havingSql + ")"); + queryWrapper.select(selectSql.toString()).having(havingSql.toString(), 0); + } + //谐波电流 + else if (type == 8) { + StringBuilder selectSql = new StringBuilder(); + StringBuilder havingSql = new StringBuilder(); + for (int i = 2; i <= 25; i++) { + selectSql.append("max(iharm_").append(i).append("_overtime) iharm_").append(i).append("_overtime,"); + if (i == 25) { + havingSql.append("iharm_").append(i).append("_overtime"); + } else { + havingSql.append("iharm_").append(i).append("_overtime + "); + } + } + selectSql.append("time_id time"); + havingSql = new StringBuilder("sum(" + havingSql + ")"); + queryWrapper.select(selectSql.toString()).having(havingSql.toString(), 0); + } + //间谐波电压 + else if (type == 9) { + StringBuilder selectSql = new StringBuilder(); + StringBuilder havingSql = new StringBuilder(); + for (int i = 1; i <= 16; i++) { + selectSql.append("max(inuharm_").append(i).append("_overtime) inuharm_").append(i).append("_overtime,"); + if (i == 16) { + havingSql.append("inuharm_").append(i).append("_overtime"); + } else { + havingSql.append("inuharm_").append(i).append("_overtime + "); + } + } + selectSql.append("time_id time"); + havingSql = new StringBuilder("sum(" + havingSql + ")"); + queryWrapper.select(selectSql.toString()).having(havingSql.toString(), 0); + } + return this.baseMapper.selectList(queryWrapper); + } + + @Override + public Page mainLineList(MainLineQueryParam param) { + Page result = new Page<>(); + result.setCurrent(param.getPageNum()); + result.setSize(param.getPageSize()); + String keywords = param.getKeywords(); + List keywordsLineIds = new ArrayList<>(); + if (StrUtil.isNotBlank(keywords)) { + List lineList = csLineFeignClient.getLineByName(keywords).getData(); + if (CollUtil.isEmpty(lineList)) { + return result; + } + keywordsLineIds = lineList.stream().map(CsLinePO::getLineId).collect(Collectors.toList()); + } + // 根据监测点Id分组，再分页 + Page ratePage = this.page(new Page(param.getPageNum(), param.getPageSize()), new LambdaQueryWrapper() + .eq(RStatLimitRateDPO::getPhasicType, "T") + .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime()) + .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime()) + .in(CollUtil.isNotEmpty(keywordsLineIds), RStatLimitRateDPO::getLineId, keywordsLineIds) + .groupBy(RStatLimitRateDPO::getLineId) + .select(RStatLimitRateDPO::getLineId) + ); + BeanUtil.copyProperties(ratePage, result); + List records = ratePage.getRecords(); + if (CollUtil.isEmpty(records)) { + return result; + } + List list = new ArrayList<>(); + MainLineVO mainLineVO; + for (RStatLimitRateDPO record : records) { + String lineId = record.getLineId(); + CsLinePO linePO = csLineFeignClient.getById(lineId).getData(); + mainLineVO = new MainLineVO(); + mainLineVO.setLineId(lineId); + if (linePO != null) { + mainLineVO.setLineName(linePO.getName()); + if (linePO.getGovern().equals(0)) { + mainLineVO.setGovern("未治理"); + } + if (linePO.getGovern().equals(1)) { + mainLineVO.setGovern("已治理"); + } + mainLineVO.setObjType(linePO.getMonitorObj()); + DictData dictData = dicDataFeignClient.getDicDataById(linePO.getMonitorObj()).getData(); + if (dictData != null) { + mainLineVO.setObjType(dictData.getName()); + } + } + MainLineStatLimitRateDetailsQueryParam detailsQueryParam = new MainLineStatLimitRateDetailsQueryParam(); + detailsQueryParam.setLineId(lineId); + detailsQueryParam.setSearchBeginTime(param.getSearchBeginTime()); + detailsQueryParam.setSearchEndTime(param.getSearchEndTime()); + List detailsList = this.mainLineStatLimitRateDetails(detailsQueryParam); + List problemList = new ArrayList<>(); + for (MainLineStatLimitRateDetailsVO details : detailsList) { + JSONObject entries = JSONUtil.parseObj(details); + for (Map.Entry entry : entries.entrySet()) { + String key = entry.getKey(); + if (key.endsWith("Overtime")) { + String value = entry.getValue().toString(); + // 值 >0 则表示该电能质量指标有问题 + Integer intValue = new Integer(value); + if (intValue > 0) { + String description = getDescription(key); + if (StrUtil.isNotBlank(description)) { + if (!problemList.contains(description)) { + problemList.add(description); + } + } + } + } + } + } + if (CollUtil.isEmpty(problemList)) { + mainLineVO.setProblems("所有指标都合格"); + } else { + mainLineVO.setProblems(CollUtil.join(problemList, "、")); + } + + list.add(mainLineVO); + } + result.setRecords(list); + return result; + } + + @Override + public List mainLineStatLimitRateDetails(MainLineStatLimitRateDetailsQueryParam param) { + + HttpResult lineResult = csLineFeignClient.getById(param.getLineId()); + CsLinePO linePO = lineResult.getData(); + if (linePO == null) { + return Collections.emptyList(); + } + List list = this.list(new LambdaQueryWrapper() + .eq(RStatLimitRateDPO::getLineId, param.getLineId()) + .eq(RStatLimitRateDPO::getPhasicType, "T") + .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime()) + .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime()) + .orderByAsc(RStatLimitRateDPO::getTime) + ); + return list.stream().map(item -> { + MainLineStatLimitRateDetailsVO vo = BeanUtil.copyProperties(item, MainLineStatLimitRateDetailsVO.class); + vo.setLineName(linePO.getName()); + Integer lineInterval = linePO.getLineInterval(); + JSONObject entries = JSONUtil.parseObj(vo); + for (Map.Entry entry : entries.entrySet()) { + String key = entry.getKey(); + if (key.endsWith("Overtime")) { + String value = entry.getValue().toString(); + Integer intValue = new Integer(value); + // 总分钟 = 越限次数 * 间隔时间 + int minutes = intValue * lineInterval; + entries.putOpt(key, minutes); + } + } + return BeanUtil.copyProperties(entries, MainLineStatLimitRateDetailsVO.class); + }).collect(Collectors.toList()); + } + + @Override + public TotalLimitTotalStatisticsVO totalLimitTotalStatisticsData(TotalLimitStatisticsParam param) { + List rateList = this.list(new LambdaQueryWrapper() + .eq(RStatLimitRateDPO::getPhasicType, "T") + .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime()) + .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime()) + .orderByAsc(RStatLimitRateDPO::getTime) + ); + + TotalLimitTotalStatisticsVO statisticsVO = new TotalLimitTotalStatisticsVO(); + int flickerTotalTime = rateList.stream().mapToInt(RStatLimitRateDPO::getFlickerOvertime).sum(); + int voltageDevTotalTime = rateList.stream().mapToInt(RStatLimitRateDPO::getVoltageDevOvertime).sum(); + int ubalanceTotalTime = rateList.stream().mapToInt(RStatLimitRateDPO::getUbalanceOvertime).sum(); + int iharmTotalTime = 0; + int uharmTotalTime = 0; + for (RStatLimitRateDPO rate : rateList) { + JSONObject entries = JSONUtil.parseObj(rate); + for (Map.Entry entry : entries.entrySet()) { + String key = entry.getKey(); + if (key.endsWith("Overtime")) { + String value = entry.getValue().toString(); + int intValue = new Integer(value); + if (key.startsWith("uharm")) { + uharmTotalTime += intValue; + } + if (key.startsWith("iharm")) { + iharmTotalTime += intValue; + } + } + } + + } + int totalTime = flickerTotalTime + voltageDevTotalTime + ubalanceTotalTime + iharmTotalTime + uharmTotalTime; + if (totalTime == 0) { + return statisticsVO; + } + statisticsVO.setFlicker(calculatePercentage(flickerTotalTime, totalTime)); + statisticsVO.setUharm(calculatePercentage(uharmTotalTime, totalTime)); + statisticsVO.setIharm(calculatePercentage(iharmTotalTime, totalTime)); + statisticsVO.setVoltageDev(calculatePercentage(voltageDevTotalTime, totalTime)); + statisticsVO.setUbalance(calculatePercentage(ubalanceTotalTime, totalTime)); + return statisticsVO; + } + + @Override + public List totalLimitStatisticsList(TotalLimitStatisticsParam param) { + List result = new ArrayList<>(); + + List rateList = this.list(new LambdaQueryWrapper() + .eq(RStatLimitRateDPO::getPhasicType, "T") + .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime()) + .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime()) + .orderByAsc(RStatLimitRateDPO::getTime) + ); + if (CollUtil.isEmpty(rateList)) { + return result; + } + Map> lineMap = rateList.stream().collect(Collectors.groupingBy(RStatLimitRateDPO::getLineId)); + + List linePOList = csLineFeignClient.queryLineById(new ArrayList<>(lineMap.keySet())).getData(); + if (CollUtil.isEmpty(linePOList)) { + return result; + } + TotalLimitStatisticsVO statisticsVO; + for (CsLinePO linePO : linePOList) { + statisticsVO = new TotalLimitStatisticsVO(); + statisticsVO.setLineId(linePO.getLineId()); + statisticsVO.setLineName(linePO.getName()); + List lineRateList = lineMap.get(linePO.getLineId()); + int totalTime = lineRateList.stream().mapToInt(RStatLimitRateDPO::getAllTime).sum(); + int flickerTotalTime = lineRateList.stream().mapToInt(RStatLimitRateDPO::getFlickerOvertime).sum(); + int voltageDevTotalTime = lineRateList.stream().mapToInt(RStatLimitRateDPO::getVoltageDevOvertime).sum(); + int ubalanceTotalTime = lineRateList.stream().mapToInt(RStatLimitRateDPO::getUbalanceOvertime).sum(); + int uharm = 0; + int iharm = 0; + for (RStatLimitRateDPO item : lineRateList) { + JSONObject entries = JSONUtil.parseObj(item); + List uharmList = new ArrayList<>(); + List iharmList = new ArrayList<>(); + for (Map.Entry entry : entries.entrySet()) { + String key = entry.getKey(); + if (key.endsWith("Overtime")) { + if (key.startsWith("uharm")) { + String value = entry.getValue().toString(); + Integer intValue = new Integer(value); + uharmList.add(intValue); + } + if (key.startsWith("iharm")) { + String value = entry.getValue().toString(); + Integer intValue = new Integer(value); + iharmList.add(intValue); + } + } + } + // 取最大值 + uharm += uharmList.stream().max(Integer::compareTo).orElse(0); + iharm += iharmList.stream().max(Integer::compareTo).orElse(0); + } + if (totalTime == 0) { + statisticsVO.setFlicker(0.0); + statisticsVO.setVoltageDev(0.0); + statisticsVO.setUbalance(0.0); + statisticsVO.setUharm(0.0); + statisticsVO.setIharm(0.0); + } else { + statisticsVO.setFlicker(calculatePercentage(flickerTotalTime, totalTime)); + statisticsVO.setVoltageDev(calculatePercentage(voltageDevTotalTime, totalTime)); + statisticsVO.setUbalance(calculatePercentage(ubalanceTotalTime, totalTime)); + statisticsVO.setUharm(calculatePercentage(uharm, totalTime)); + statisticsVO.setIharm(calculatePercentage(iharm, totalTime)); + } + result.add(statisticsVO); + + } + return result; + } + + @Override + public List totalLimitStatisticsDetails(TotalLimitStatisticsDetailsQueryParam param) { + + HttpResult lineResult = csLineFeignClient.getById(param.getLineId()); + CsLinePO linePO = lineResult.getData(); + if (linePO == null) { + return Collections.emptyList(); + } + List list = this.list(new LambdaQueryWrapper() + .eq(RStatLimitRateDPO::getLineId, param.getLineId()) + .eq(RStatLimitRateDPO::getPhasicType, "T") + .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime()) + .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime()) + .orderByAsc(RStatLimitRateDPO::getTime) + ); + return list.stream().map(item -> { + MainLineStatLimitRateDetailsVO vo = BeanUtil.copyProperties(item, MainLineStatLimitRateDetailsVO.class); + vo.setLineName(linePO.getName()); + Integer allTime = item.getAllTime(); + JSONObject entries = JSONUtil.parseObj(vo); + for (Map.Entry entry : entries.entrySet()) { + String key = entry.getKey(); + if (key.endsWith("Overtime") && allTime != 0) { + String value = entry.getValue().toString(); + int intValue = new Integer(value); + // 占比 = 越限次数 / 总次数 * 100 + double proportion = calculatePercentage(intValue, allTime); + entries.putOpt(key, proportion); + } + } + return BeanUtil.copyProperties(entries, TotalLimitStatisticsDetailsVO.class); + }).collect(Collectors.toList()); + } + + @Override + public TotalLimitTotalStatisticsVO gridSideLimitTotalStatisticsData(TotalLimitStatisticsParam param) { + TotalLimitTotalStatisticsVO statisticsVO = new TotalLimitTotalStatisticsVO(); + // 获取电网侧监测点 + DictData dictData = dicDataFeignClient.getDicDataByCode(GRID_SIDE_DICT_CODE).getData(); + CsLinePO queryParam = new CsLinePO(); + queryParam.setPosition(dictData.getId()); + List linePOList = csLineFeignClient.list(queryParam).getData(); + List lineIds = linePOList.stream().map(CsLinePO::getLineId).collect(Collectors.toList()); + if (CollUtil.isEmpty(lineIds)) { + return statisticsVO; + } + List rateList = this.list(new LambdaQueryWrapper() + .in(RStatLimitRateDPO::getLineId, lineIds) + .eq(RStatLimitRateDPO::getPhasicType, "T") + .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime()) + .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime()) + .orderByAsc(RStatLimitRateDPO::getTime) + ); + + + int flickerTotalTime = rateList.stream().mapToInt(RStatLimitRateDPO::getFlickerOvertime).sum(); + int voltageDevTotalTime = rateList.stream().mapToInt(RStatLimitRateDPO::getVoltageDevOvertime).sum(); + int ubalanceTotalTime = rateList.stream().mapToInt(RStatLimitRateDPO::getUbalanceOvertime).sum(); + int iharmTotalTime = 0; + int uharmTotalTime = 0; + for (RStatLimitRateDPO rate : rateList) { + JSONObject entries = JSONUtil.parseObj(rate); + for (Map.Entry entry : entries.entrySet()) { + String key = entry.getKey(); + if (key.endsWith("Overtime")) { + String value = entry.getValue().toString(); + int intValue = new Integer(value); + if (key.startsWith("uharm")) { + uharmTotalTime += intValue; + } + if (key.startsWith("iharm")) { + iharmTotalTime += intValue; + } + } + } + + } + int totalTime = flickerTotalTime + voltageDevTotalTime + ubalanceTotalTime + iharmTotalTime + uharmTotalTime; + if (totalTime == 0) { + return statisticsVO; + } + statisticsVO.setFlicker(calculatePercentage(flickerTotalTime, totalTime)); + statisticsVO.setUharm(calculatePercentage(uharmTotalTime, totalTime)); + statisticsVO.setIharm(calculatePercentage(iharmTotalTime, totalTime)); + statisticsVO.setVoltageDev(calculatePercentage(voltageDevTotalTime, totalTime)); + statisticsVO.setUbalance(calculatePercentage(ubalanceTotalTime, totalTime)); + return statisticsVO; + } + + @Override + public List gridSideLimitStatisticsList(TotalLimitStatisticsParam param) { + List result = new ArrayList<>(); + // 获取电网侧监测点 + DictData dictData = dicDataFeignClient.getDicDataByCode(GRID_SIDE_DICT_CODE).getData(); + CsLinePO queryParam = new CsLinePO(); + queryParam.setPosition(dictData.getId()); + List linePOList = csLineFeignClient.list(queryParam).getData(); + List lineIds = linePOList.stream().map(CsLinePO::getLineId).collect(Collectors.toList()); + if (CollUtil.isEmpty(lineIds)) { + return result; + } + List rateList = this.list(new LambdaQueryWrapper() + .in(RStatLimitRateDPO::getLineId, lineIds) + .eq(RStatLimitRateDPO::getPhasicType, "T") + .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime()) + .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime()) + .orderByAsc(RStatLimitRateDPO::getTime) + ); + if (CollUtil.isEmpty(rateList)) { + return result; + } + Map> lineMap = rateList.stream().collect(Collectors.groupingBy(RStatLimitRateDPO::getLineId)); + Map linePOMap = linePOList.stream().collect(Collectors.toMap(CsLinePO::getLineId, csLinePO -> csLinePO)); + List lineList = new ArrayList<>(); + for (String lineId : lineMap.keySet()) { + CsLinePO linePO = linePOMap.getOrDefault(lineId, null); + if (linePO != null) { + lineList.add(linePO); + } + } + if (CollUtil.isEmpty(lineList)) { + return result; + } + TotalLimitStatisticsVO statisticsVO; + for (CsLinePO linePO : lineList) { + statisticsVO = new TotalLimitStatisticsVO(); + statisticsVO.setLineId(linePO.getLineId()); + statisticsVO.setLineName(linePO.getName()); + List lineRateList = lineMap.get(linePO.getLineId()); + int totalTime = lineRateList.stream().mapToInt(RStatLimitRateDPO::getAllTime).sum(); + int flickerTotalTime = lineRateList.stream().mapToInt(RStatLimitRateDPO::getFlickerOvertime).sum(); + int voltageDevTotalTime = lineRateList.stream().mapToInt(RStatLimitRateDPO::getVoltageDevOvertime).sum(); + int ubalanceTotalTime = lineRateList.stream().mapToInt(RStatLimitRateDPO::getUbalanceOvertime).sum(); + int uharm = 0; + int iharm = 0; + for (RStatLimitRateDPO item : lineRateList) { + JSONObject entries = JSONUtil.parseObj(item); + List uharmList = new ArrayList<>(); + List iharmList = new ArrayList<>(); + for (Map.Entry entry : entries.entrySet()) { + String key = entry.getKey(); + if (key.endsWith("Overtime")) { + if (key.startsWith("uharm")) { + String value = entry.getValue().toString(); + Integer intValue = new Integer(value); + uharmList.add(intValue); + } + if (key.startsWith("iharm")) { + String value = entry.getValue().toString(); + Integer intValue = new Integer(value); + iharmList.add(intValue); + } + } + } + // 取最大值 + uharm += uharmList.stream().max(Integer::compareTo).orElse(0); + iharm += iharmList.stream().max(Integer::compareTo).orElse(0); + } + if (totalTime == 0) { + statisticsVO.setFlicker(0.0); + statisticsVO.setVoltageDev(0.0); + statisticsVO.setUbalance(0.0); + statisticsVO.setUharm(0.0); + statisticsVO.setIharm(0.0); + } else { + statisticsVO.setFlicker(calculatePercentage(flickerTotalTime, totalTime)); + statisticsVO.setVoltageDev(calculatePercentage(voltageDevTotalTime, totalTime)); + statisticsVO.setUbalance(calculatePercentage(ubalanceTotalTime, totalTime)); + statisticsVO.setUharm(calculatePercentage(uharm, totalTime)); + statisticsVO.setIharm(calculatePercentage(iharm, totalTime)); + } + result.add(statisticsVO); + + } + return result; + } + + private String getDescription(String key) { + if (StrUtil.equals(key, "flickerOvertime")) { + return "闪变越限超标"; + } + if (StrUtil.equals(key, "freqDevOvertime")) { + return "频率偏差超标"; + } + if (StrUtil.equals(key, "voltageDevOvertime")) { + return "电压偏差超标"; + } + if (StrUtil.equals(key, "ubalanceOvertime")) { + return "三相电压不平衡超标"; + } + // 电压 + if (StrUtil.startWith(key, "uharm")) { + // 从 key 中提取数字 2 + String number = key.substring(5, key.indexOf("Overtime")); + return number + "次谐波电压"; + } + // 电流 + if (StrUtil.startWith(key, "iharm")) { + // 从 key 中提取数字 + String number = key.substring(5, key.indexOf("Overtime")); + return number + "次谐波电流"; + } + return null; + } + + + private double calculatePercentage(double part, double total) { + return Double.parseDouble(df.format(BigDecimal.valueOf(part / total * 100.0) + .setScale(2, RoundingMode.HALF_UP).doubleValue())); + } + +} diff --git a/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/impl/RStatLimitRateDetailDServiceImpl.java b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/impl/RStatLimitRateDetailDServiceImpl.java new file mode 100644 index 0000000..7a69435 --- /dev/null +++ b/cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/impl/RStatLimitRateDetailDServiceImpl.java @@ -0,0 +1,549 @@ +package com.njcn.csharmonic.service.impl; + +import cn.hutool.core.collection.CollUtil; +import cn.hutool.core.lang.Pair; +import cn.hutool.core.util.ObjectUtil; +import cn.hutool.core.util.StrUtil; +import cn.hutool.json.JSONArray; +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.baomidou.dynamic.datasource.annotation.DS; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.njcn.csdevice.api.CsLineFeignClient; +import com.njcn.csdevice.api.OverLimitClient; +import com.njcn.csdevice.pojo.po.CsLinePO; +import com.njcn.csdevice.pojo.po.Overlimit; +import com.njcn.csharmonic.mapper.RStatLimitRateDetailDMapper; +import com.njcn.csharmonic.pojo.param.LimitCalendarQueryParam; +import com.njcn.csharmonic.pojo.param.LimitExtentDayQueryParam; +import com.njcn.csharmonic.pojo.param.LimitExtentQueryParam; +import com.njcn.csharmonic.pojo.param.LimitProbabilityQueryParam; +import com.njcn.csharmonic.pojo.po.RStatLimitRateDetailDPO; +import com.njcn.csharmonic.pojo.vo.LimitCalendarVO; +import com.njcn.csharmonic.pojo.vo.LimitExtentVO; +import com.njcn.csharmonic.pojo.vo.LimitProbabilityVO; +import com.njcn.csharmonic.pojo.vo.LimitTimeProbabilityVO; +import com.njcn.csharmonic.service.IRStatLimitRateDetailDService; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.text.DecimalFormat; +import java.time.LocalDate; +import java.util.*; +import java.util.stream.Collectors; + +@DS("sjzx") +@RequiredArgsConstructor +@Service +public class RStatLimitRateDetailDServiceImpl extends ServiceImpl implements IRStatLimitRateDetailDService { + + private final CsLineFeignClient csLineFeignClient; + private final OverLimitClient overLimitClient; + + private final DecimalFormat df = new DecimalFormat("#0.00"); + + static Map indexMap = new HashMap<>(); + static List> timePeriodList = new ArrayList<>(); + static List> extentPeriodList = new ArrayList<>(); + + static { + indexMap.put("flicker", "闪变"); + indexMap.put("uharm", "谐波电压"); + indexMap.put("iharm", "谐波电流"); + indexMap.put("ubalance", "三相电压不平衡度"); + indexMap.put("voltageDev", "电压偏差"); + indexMap.put("freqDev", "频率偏差"); + + timePeriodList.add(Arrays.asList(0, 8)); + timePeriodList.add(Arrays.asList(8, 12)); + timePeriodList.add(Arrays.asList(12, 14)); + timePeriodList.add(Arrays.asList(14, 18)); + timePeriodList.add(Arrays.asList(18, 24)); + + extentPeriodList.add(Arrays.asList(0, 20)); + extentPeriodList.add(Arrays.asList(20, 40)); + extentPeriodList.add(Arrays.asList(40, 60)); + extentPeriodList.add(Arrays.asList(60, 80)); + extentPeriodList.add(Arrays.asList(80, 100)); + } + + @Override + public List limitExtentData(LimitExtentQueryParam param) { + List result = new ArrayList<>(); + LimitExtentVO flicker = new LimitExtentVO(); + flicker.setCode("flicker"); + flicker.setName(indexMap.get(flicker.getCode())); + LimitExtentVO uharm = new LimitExtentVO(); + uharm.setCode("uharm"); + uharm.setName(indexMap.get(uharm.getCode())); + LimitExtentVO iharm = new LimitExtentVO(); + iharm.setCode("iharm"); + iharm.setName(indexMap.get(iharm.getCode())); + LimitExtentVO voltageDev = new LimitExtentVO(); + voltageDev.setCode("voltageDev"); + voltageDev.setName(indexMap.get(voltageDev.getCode())); + LimitExtentVO ubalance = new LimitExtentVO(); + ubalance.setCode("ubalance"); + ubalance.setName(indexMap.get(ubalance.getCode())); + List detailList = this.list(new LambdaQueryWrapper() + .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDetailDPO::getTime, param.getSearchBeginTime()) + .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDetailDPO::getTime, param.getSearchEndTime()) + .orderByAsc(RStatLimitRateDetailDPO::getTime) + ); + if (CollUtil.isNotEmpty(detailList)) { + List lineIds = detailList.stream().map(RStatLimitRateDetailDPO::getLineId).distinct().collect(Collectors.toList()); + List overlimitList = overLimitClient.getOverLimitByLineIds(lineIds).getData(); + + Map> findResult = findMaxValueHandle(detailList); + // 闪变 + Pair flickerResult = findResult.get(flicker.getCode()); + setLimitExtentInfo(flicker, flickerResult); + // 电压偏差 + Pair voltageDevResult = findResult.get(voltageDev.getCode()); + setLimitExtentInfo(voltageDev, voltageDevResult); + // 谐波电压 + String uharmKey = findResult.keySet().stream().filter(code -> code.startsWith("uharm")).findFirst().orElse("uharm"); + Pair uharmResult = findResult.get(uharmKey); + setLimitExtentInfo(uharm, uharmResult); + uharm.setCode(uharmKey); + String iharmKey = findResult.keySet().stream().filter(code -> code.startsWith("iharm")).findFirst().orElse("iharm"); + // 谐波电流 + Pair iharmResult = findResult.get(iharmKey); + setLimitExtentInfo(iharm, iharmResult); + iharm.setCode(iharmKey); + // 电压三相不平衡 + Pair ubalanceResult = findResult.get(ubalance.getCode()); + setLimitExtentInfo(ubalance, ubalanceResult); + + if (CollUtil.isNotEmpty(overlimitList)) { + // 取所有监测点中的最大闪变限值，作为闪变国际限值 + float flickerMaxOverlimit = (float) overlimitList.stream().mapToDouble(Overlimit::getFlicker).max().orElse(0.0F); + float voltageDevMaxOverlimit = (float) overlimitList.stream().mapToDouble(Overlimit::getVoltageDev).max().orElse(0.0F); + float ubalanceMaxOverlimit = (float) overlimitList.stream().mapToDouble(Overlimit::getUbalance).max().orElse(0.0F); + float iharmMaxOverlimit = 0.0F; + float uharmMaxOverlimit = 0.0F; + for (Overlimit overlimit : overlimitList) { + JSONObject entries = JSONUtil.parseObj(overlimit); + for (Map.Entry entry : entries.entrySet()) { + String key = entry.getKey(); + if (key.startsWith("uharm")) { + Object value = entry.getValue(); + if (value instanceof Number) { + uharmMaxOverlimit = Math.max(uharmMaxOverlimit, ((Number) value).floatValue()); + } + } else if (key.startsWith("iharm")) { + Object value = entry.getValue(); + if (value instanceof Number) { + iharmMaxOverlimit = Math.max(iharmMaxOverlimit, ((Number) value).floatValue()); + } + } + + } + } + flicker.setInternationalValue(flickerMaxOverlimit); + voltageDev.setInternationalValue(voltageDevMaxOverlimit); + ubalance.setInternationalValue(ubalanceMaxOverlimit); + iharm.setInternationalValue(iharmMaxOverlimit); + uharm.setInternationalValue(uharmMaxOverlimit); + } + } + result.add(flicker); + result.add(uharm); + result.add(iharm); + result.add(voltageDev); + result.add(ubalance); + return result; + } + + @Override + public JSONArray limitExtentDayData(LimitExtentDayQueryParam param) { + List records = this.page(new Page<>(1, 1), + new LambdaQueryWrapper() + .eq(RStatLimitRateDetailDPO::getLineId, param.getLineId()) + .eq(RStatLimitRateDetailDPO::getTime, param.getTime()) + + ).getRecords(); + String code = param.getCode(); + if (CollUtil.isNotEmpty(records)) { + RStatLimitRateDetailDPO detail = records.get(0); + JSONObject entries = JSONUtil.parseObj(detail); + for (Map.Entry entry : entries.entrySet()) { + String key = entry.getKey(); + if (key.endsWith("Overtime")) { + Object value = entry.getValue(); + if (StrUtil.equals(code, key)) { + return JSONUtil.parseArray(value); + } else if (key.startsWith(code)) { + return JSONUtil.parseArray(value); + } + + } + } + } + return JSONUtil.createArray(); + } + + @Override + public List limitCalendarData(LimitCalendarQueryParam param) { + List result = new ArrayList<>(); + List detailList = this.list(new LambdaQueryWrapper() + .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDetailDPO::getTime, param.getSearchBeginTime()) + .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDetailDPO::getTime, param.getSearchEndTime()) + .orderByAsc(RStatLimitRateDetailDPO::getTime) + ); + if (CollUtil.isEmpty(detailList)) { + return result; + } + Map> detailMap = detailList.stream().collect(Collectors.groupingBy(RStatLimitRateDetailDPO::getTime)); + LimitCalendarVO calendarVO; + for (Map.Entry> entry : detailMap.entrySet()) { + calendarVO = new LimitCalendarVO(); + LocalDate time = entry.getKey(); + calendarVO.setTime(time); + int status = 0; + List items = new ArrayList<>(); + List dayDetailList = entry.getValue(); + for (RStatLimitRateDetailDPO detail : dayDetailList) { + String lineId = detail.getLineId(); + List overlimitList = overLimitClient.getOverLimitByLineIds(Collections.singletonList(lineId)).getData(); + Overlimit overlimit = overlimitList.stream().findFirst().orElse(null); + JSONObject entries = JSONUtil.parseObj(detail); + for (Map.Entry dayEntry : entries.entrySet()) { + String key = dayEntry.getKey(); + if (key.endsWith("Overtime")) { + Object data = dayEntry.getValue(); + // 有数据有越限 + if (ObjectUtil.isNotEmpty(data)) { + status = 1; + String description = getDescription(key); + if (StrUtil.isNotBlank(description) && !items.contains(description)) { + items.add(description); + } + float maxValue = parseMaxValueFromJsonArray(data); + if (overlimit != null) { + JSONObject overlimitJSON = JSONUtil.parseObj(overlimit); + String itemKey = StrUtil.sub(key, 0, key.length() - 8); + float limitValue = overlimitJSON.getFloat(itemKey); + if (limitValue != 0) { + double overlimitPercent = calculatePercentage(maxValue - limitValue, limitValue); + if (overlimitPercent >= 80) { + status = 2; + } + } + } + } + } + } + } + calendarVO.setItems(items); + calendarVO.setStatus(status); + result.add(calendarVO); + } + result.sort(Comparator.comparing(LimitCalendarVO::getTime)); + return result; + } + + @Override + public List limitProbabilityData(LimitProbabilityQueryParam param) { + List result = new ArrayList<>(); + List detailList = this.list(new LambdaQueryWrapper() + .eq(RStatLimitRateDetailDPO::getLineId, param.getLineId()) + .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDetailDPO::getTime, param.getSearchBeginTime()) + .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDetailDPO::getTime, param.getSearchEndTime()) + .orderByAsc(RStatLimitRateDetailDPO::getTime) + ); + CsLinePO linePO = csLineFeignClient.getById(param.getLineId()).getData(); + List overlimitList = overLimitClient.getOverLimitByLineIds(Collections.singletonList(linePO.getLineId())).getData(); + JSONObject overlimitJSON = null; + if (CollUtil.isNotEmpty(overlimitList)) { + overlimitJSON = JSONUtil.parseObj(overlimitList.get(0)); + } + LimitProbabilityVO probabilityVO; + for (Map.Entry indexEntry : indexMap.entrySet()) { + String indexCode = indexEntry.getKey(); + probabilityVO = new LimitProbabilityVO(); + probabilityVO.setIndexName(indexEntry.getValue()); + probabilityVO.setIndexCode(indexCode); + probabilityVO.setLineId(linePO.getLineId()); + probabilityVO.setLineName(linePO.getName()); + // 计算越限程度 + List extentValuesList = new ArrayList<>(); + for (RStatLimitRateDetailDPO detail : detailList) { + JSONObject entries = JSONUtil.parseObj(detail); + for (Map.Entry dayEntry : entries.entrySet()) { + String key = dayEntry.getKey(); + if (key.endsWith("Overtime") && key.startsWith(indexCode)) { + double extentValue = 0; + Object data = dayEntry.getValue(); + // 有数据有越限 + if (ObjectUtil.isNotEmpty(data)) { + float maxValue = parseMaxValueFromJsonArray(data); + if (overlimitJSON != null) { + String itemKey = StrUtil.sub(key, 0, key.length() - 8); + double limitValue = overlimitJSON.getDouble(itemKey); + if (limitValue != 0) { + extentValue = calculatePercentage(maxValue - limitValue, limitValue); + + } + } + } + extentValuesList.add(extentValue); + } + } + + } + List> extentGrades = new ArrayList<>(); + for (int i = 0; i < extentPeriodList.size(); i++) { + Map grade = new HashMap<>(); + int times = 0; + for (Double extentValue : extentValuesList) { + List period = extentPeriodList.get(i); + Integer start = period.get(0); + Integer end = period.get(1); + if (extentValue > start && extentValue <= end) { + times++; + } + } + grade.put(i, times); + extentGrades.add(grade); + } + probabilityVO.setExtentGrades(extentGrades); + result.add(probabilityVO); + } + return result; + } + + @Override + public List limitTimeProbabilityData(LimitProbabilityQueryParam param) { + + List result = new ArrayList<>(); + List detailList = this.list(new LambdaQueryWrapper() + .eq(RStatLimitRateDetailDPO::getLineId, param.getLineId()) + .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDetailDPO::getTime, param.getSearchBeginTime()) + .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDetailDPO::getTime, param.getSearchEndTime()) + .orderByAsc(RStatLimitRateDetailDPO::getTime) + ); + CsLinePO linePO = csLineFeignClient.getById(param.getLineId()).getData(); + + LimitTimeProbabilityVO timeProbabilityVO; + JSONArray detailJSONArray = null; + if (CollUtil.isNotEmpty(detailList)) { + detailJSONArray = JSONUtil.parseArray(detailList); + } + for (Map.Entry entry : indexMap.entrySet()) { + String indexCode = entry.getKey(); + for (List period : timePeriodList) { + timeProbabilityVO = new LimitTimeProbabilityVO(); + timeProbabilityVO.setLineId(linePO.getLineId()); + timeProbabilityVO.setLineName(linePO.getName()); + timeProbabilityVO.setIndexName(entry.getValue()); + timeProbabilityVO.setIndexCode(indexCode); + int start = period.get(0); + int end = period.get(1); + timeProbabilityVO.setTimePeriod(start + "时-" + end + "时"); + int times = 0; + if (CollUtil.isNotEmpty(detailJSONArray)) { + for (int i = 0; i < detailJSONArray.size(); i++) { + JSONObject detail = detailJSONArray.getJSONObject(i); + // 获取包含的指标key + List includeKeys = detail.keySet().stream().filter(f -> f.startsWith(indexCode)).collect(Collectors.toList()); + for (String key : includeKeys) { + // 获取指标越限数据 + // [{"time": "17:10:00,17:20:00,17:30:00", "value": "7.1092,7.1092,7.1093", "phasic": "A", "valueType": "CP95"}, {"time": "17:10:00,17:20:00,17:30:00", "value": "7.8081,7.808,7.8081", "phasic": "C", "valueType": "CP95"}, {"time": "17:10:00,17:20:00,17:30:00", "value": "7.5095,7.5095,7.5095", "phasic": "B", "valueType": "CP95"}] + JSONArray values = detail.getJSONArray(key); + if (CollUtil.isNotEmpty(values)) { + // 取出第一个数据 + JSONObject value = values.getJSONObject(0); + // 获取时间 + String time = value.getStr("time"); + for (String t : StrUtil.split(time, StrUtil.COMMA)) { + // 判断在时间段内，次数加一 + int hour = Integer.parseInt(t.substring(0, 2)); + if (hour >= start && hour < end) { + times++; + } + } + } + } + } + } + timeProbabilityVO.setTimes(times); + result.add(timeProbabilityVO); + } + } + + return result; + } + + /** + * 设置LimitExtentVO的最大值和相关信息 + */ + private void setLimitExtentInfo(LimitExtentVO limitExtentVO, Pair result) { + float maxValue = result.getKey(); + limitExtentVO.setMaxValue(maxValue); + RStatLimitRateDetailDPO maxDetail = result.getValue(); + if (maxDetail != null) { + limitExtentVO.setTime(maxDetail.getTime()); + CsLinePO maxLinePO = csLineFeignClient.getById(maxDetail.getLineId()).getData(); + if (maxLinePO != null) { + limitExtentVO.setLineName(maxLinePO.getName()); + limitExtentVO.setLineId(maxLinePO.getLineId()); + } + } + } + + /** + * 查找数据中的最大值及其对应的记录 + * + * @param detailList 数据列表 + * @return 包含最大值和对应记录的Pair对象 + */ + private Map> findMaxValueHandle(List detailList) { + + Map> result = new HashMap<>(); + + RStatLimitRateDetailDPO flickerMaxDetail = null; + float flickerMaxValue = 0.0000F; + + RStatLimitRateDetailDPO voltageDevMaxDetail = null; + float voltageDevMaxValue = 0.0000F; + RStatLimitRateDetailDPO ubalanceMaxDetail = null; + float ubalanceMaxValue = 0.0000F; + + RStatLimitRateDetailDPO uharmMaxDetail = null; + float uharmMaxValue = 0.0000F; + String uharmMaxKey = ""; // 记录uharm最大值对应的key + RStatLimitRateDetailDPO iharmMaxDetail = null; + float iharmMaxValue = 0.0000F; + String iharmMaxKey = ""; // 记录iharm最大值对应的key + + for (RStatLimitRateDetailDPO po : detailList) { + String flickerOvertime = po.getFlickerOvertime(); + String voltageDevOvertime = po.getVoltageDevOvertime(); + String ubalanceOvertime = po.getUbalanceOvertime(); + if (StrUtil.isNotBlank(flickerOvertime)) { + float dayFlickerMaxValue = parseMaxValueFromJsonArray(flickerOvertime); + if (dayFlickerMaxValue > flickerMaxValue) { + flickerMaxValue = dayFlickerMaxValue; + flickerMaxDetail = po; + } + } + if (StrUtil.isNotBlank(voltageDevOvertime)) { + float dayVoltageDevMaxValue = parseMaxValueFromJsonArray(voltageDevOvertime); + if (dayVoltageDevMaxValue > voltageDevMaxValue) { + voltageDevMaxValue = dayVoltageDevMaxValue; + voltageDevMaxDetail = po; + } + } + if (StrUtil.isNotBlank(ubalanceOvertime)) { + float dayUbalanceMaxValue = parseMaxValueFromJsonArray(ubalanceOvertime); + if (dayUbalanceMaxValue > ubalanceMaxValue) { + ubalanceMaxValue = dayUbalanceMaxValue; + ubalanceMaxDetail = po; + } + } + JSONObject entries = JSONUtil.parseObj(po); + float dayUharmMaxValue = 0.0000F; + String dayUharmMaxKey = ""; // 当前记录中uharm的最大值key + float dayIharmMaxValue = 0.0000F; + String dayIharmMaxKey = ""; // 当前记录中iharm的最大值key + + for (Map.Entry entry : entries.entrySet()) { + String key = entry.getKey(); + if (key.endsWith("Overtime")) { + if (key.startsWith("uharm")) { + Object value = entry.getValue(); + if (ObjectUtil.isNotEmpty(value)) { + float timeMaxValue = parseMaxValueFromJsonArray(value); + // 取次数最大的未当天的最大值 + dayUharmMaxValue = Math.max(dayUharmMaxValue, timeMaxValue); + dayUharmMaxKey = key; + } + } + if (key.startsWith("iharm")) { + Object value = entry.getValue(); + if (ObjectUtil.isNotEmpty(value)) { + float timeMaxValue = parseMaxValueFromJsonArray(value); + // 取次数最大的为当天的最大值 + dayIharmMaxValue = Math.max(dayIharmMaxValue, timeMaxValue); + dayIharmMaxKey = key; + } + } + } + } + if (dayUharmMaxValue > uharmMaxValue) { + uharmMaxValue = dayUharmMaxValue; + uharmMaxDetail = po; + uharmMaxKey = dayUharmMaxKey; // 记录产生最大值的key + } + if (dayIharmMaxValue > iharmMaxValue) { + iharmMaxValue = dayIharmMaxValue; + iharmMaxDetail = po; + iharmMaxKey = dayIharmMaxKey; // 记录产生最大值的key + } + } + result.put("flicker", Pair.of(flickerMaxValue, flickerMaxDetail)); + result.put("voltageDev", Pair.of(voltageDevMaxValue, voltageDevMaxDetail)); + result.put("ubalance", Pair.of(ubalanceMaxValue, ubalanceMaxDetail)); + result.put(uharmMaxKey.isEmpty() ? "uharm" : uharmMaxKey, Pair.of(uharmMaxValue, uharmMaxDetail)); + result.put(iharmMaxKey.isEmpty() ? "iharm" : iharmMaxKey, Pair.of(iharmMaxValue, iharmMaxDetail)); + + return result; + } + + /** + * 从JSON数组字符串中解析出最大值 + * + * @param value JSON数组字符串 + * @return 解析出的最大值 + */ + private float parseMaxValueFromJsonArray(Object value) { + JSONArray overtimeArray = JSONUtil.parseArray(value); + float maxValue = 0.0000F; + for (Object data : overtimeArray) { + JSONObject entries = JSONUtil.parseObj(data); + String values = entries.getStr("value"); + float currentValue = (float) StrUtil.split(values, StrUtil.COMMA) + .stream() + .mapToDouble(Float::parseFloat) + .max() + .orElse(0.0000F); + maxValue = Math.max(maxValue, currentValue); + } + + return maxValue; + } + + private String getDescription(String key) { + if (StrUtil.equals(key, "flickerOvertime")) { + return "闪变越限"; + } + if (StrUtil.equals(key, "freqDevOvertime")) { + return "频率偏差越限"; + } + if (StrUtil.equals(key, "voltageDevOvertime")) { + return "电压偏差越限"; + } + if (StrUtil.equals(key, "ubalanceOvertime")) { + return "三相电压不平衡越限"; + } + // 电压 + if (StrUtil.startWith(key, "uharm")) { + return "谐波电压越限"; + } + // 电流 + if (StrUtil.startWith(key, "iharm")) { + return "谐波电流越限"; + } + return null; + } + + private double calculatePercentage(double part, double total) { + return Double.parseDouble(df.format(BigDecimal.valueOf(part / total * 100.0) + .setScale(2, RoundingMode.HALF_UP).doubleValue())); + } +}