diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitCalendarQueryParam.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitCalendarQueryParam.java new file mode 100644 index 000000000..b7910a5a2 --- /dev/null +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitCalendarQueryParam.java @@ -0,0 +1,9 @@ +package com.njcn.harmonic.pojo.param; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +@EqualsAndHashCode(callSuper = true) +@Data +public class LimitCalendarQueryParam extends TotalLimitStatisticsParam { +} diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitExtentDayQueryParam.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitExtentDayQueryParam.java new file mode 100644 index 000000000..f0d543d55 --- /dev/null +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitExtentDayQueryParam.java @@ -0,0 +1,23 @@ +package com.njcn.harmonic.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/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitExtentQueryParam.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitExtentQueryParam.java new file mode 100644 index 000000000..ede668cff --- /dev/null +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitExtentQueryParam.java @@ -0,0 +1,9 @@ +package com.njcn.harmonic.pojo.param; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +@EqualsAndHashCode(callSuper = true) +@Data +public class LimitExtentQueryParam extends TotalLimitStatisticsParam { +} diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/MainLineStatLimitRateDetailsQueryParam.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/MainLineStatLimitRateDetailsQueryParam.java index 30fc1eeb7..2c4c9cb19 100644 --- a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/MainLineStatLimitRateDetailsQueryParam.java +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/MainLineStatLimitRateDetailsQueryParam.java @@ -2,17 +2,11 @@ package com.njcn.harmonic.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 MainLineStatLimitRateDetailsQueryParam { @NotBlank(message = "监测点ID不可为空") @ApiModelProperty("监测点ID") diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/day/RStatLimitRateDetailDPO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/day/RStatLimitRateDetailDPO.java new file mode 100644 index 000000000..180bdc6cf --- /dev/null +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/day/RStatLimitRateDetailDPO.java @@ -0,0 +1,594 @@ +package com.njcn.harmonic.pojo.po.day; + +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.harmonic.annotaion.HarCurrent; +import com.njcn.harmonic.annotaion.HarVoltage; +import com.njcn.harmonic.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/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitCalendarVO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitCalendarVO.java new file mode 100644 index 000000000..acf549607 --- /dev/null +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitCalendarVO.java @@ -0,0 +1,23 @@ +package com.njcn.harmonic.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/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitExtentVO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitExtentVO.java new file mode 100644 index 000000000..5a77d872e --- /dev/null +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitExtentVO.java @@ -0,0 +1,49 @@ +package com.njcn.harmonic.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/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDetailDController.java b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDetailDController.java new file mode 100644 index 000000000..735d1ca54 --- /dev/null +++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDetailDController.java @@ -0,0 +1,62 @@ +package com.njcn.harmonic.rstatlimitrate.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.harmonic.pojo.param.LimitCalendarQueryParam; +import com.njcn.harmonic.pojo.param.LimitExtentDayQueryParam; +import com.njcn.harmonic.pojo.param.LimitExtentQueryParam; +import com.njcn.harmonic.pojo.vo.LimitCalendarVO; +import com.njcn.harmonic.pojo.vo.LimitExtentVO; +import com.njcn.harmonic.rstatlimitrate.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); + } + +} diff --git a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/mapper/RStatLimitRateDetailDMapper.java b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/mapper/RStatLimitRateDetailDMapper.java new file mode 100644 index 000000000..8b38a9e02 --- /dev/null +++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/mapper/RStatLimitRateDetailDMapper.java @@ -0,0 +1,9 @@ +package com.njcn.harmonic.rstatlimitrate.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.njcn.harmonic.pojo.po.day.RStatLimitRateDetailDPO; + + +public interface RStatLimitRateDetailDMapper extends BaseMapper { + +} diff --git a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/mapper/mapping/RStatLimitRateDetailDMapper.xml b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/mapper/mapping/RStatLimitRateDetailDMapper.xml new file mode 100644 index 000000000..5ad9fb75b --- /dev/null +++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/mapper/mapping/RStatLimitRateDetailDMapper.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDetailDService.java b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDetailDService.java new file mode 100644 index 000000000..2e4069f0f --- /dev/null +++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDetailDService.java @@ -0,0 +1,23 @@ +package com.njcn.harmonic.rstatlimitrate.service; + +import cn.hutool.json.JSONArray; +import com.baomidou.mybatisplus.extension.service.IService; +import com.njcn.harmonic.pojo.param.LimitCalendarQueryParam; +import com.njcn.harmonic.pojo.param.LimitExtentDayQueryParam; +import com.njcn.harmonic.pojo.param.LimitExtentQueryParam; +import com.njcn.harmonic.pojo.po.day.RStatLimitRateDetailDPO; +import com.njcn.harmonic.pojo.vo.LimitCalendarVO; +import com.njcn.harmonic.pojo.vo.LimitExtentVO; + +import java.util.List; + + +public interface IRStatLimitRateDetailDService extends IService { + + + List limitExtentData(LimitExtentQueryParam param); + + JSONArray limitExtentDayData(LimitExtentDayQueryParam param); + + List limitCalendarData(LimitCalendarQueryParam param); +} diff --git a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDetailDServiceImpl.java b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDetailDServiceImpl.java new file mode 100644 index 000000000..2867c6628 --- /dev/null +++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDetailDServiceImpl.java @@ -0,0 +1,379 @@ +package com.njcn.harmonic.rstatlimitrate.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.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.pojo.po.CsLinePO; +import com.njcn.device.biz.pojo.po.Overlimit; +import com.njcn.device.pq.api.OverLimitClient; +import com.njcn.harmonic.pojo.param.LimitCalendarQueryParam; +import com.njcn.harmonic.pojo.param.LimitExtentDayQueryParam; +import com.njcn.harmonic.pojo.param.LimitExtentQueryParam; +import com.njcn.harmonic.pojo.po.day.RStatLimitRateDetailDPO; +import com.njcn.harmonic.pojo.vo.LimitCalendarVO; +import com.njcn.harmonic.pojo.vo.LimitExtentVO; +import com.njcn.harmonic.rstatlimitrate.mapper.RStatLimitRateDetailDMapper; +import com.njcn.harmonic.rstatlimitrate.service.IRStatLimitRateDetailDService; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; + +import java.time.LocalDate; +import java.util.*; +import java.util.stream.Collectors; + + +@RequiredArgsConstructor +@Service +public class RStatLimitRateDetailDServiceImpl extends ServiceImpl implements IRStatLimitRateDetailDService { + + private final CsLineFeignClient csLineFeignClient; + private final OverLimitClient overLimitClient; + + + @Override + public List limitExtentData(LimitExtentQueryParam param) { + List result = new ArrayList<>(); + LimitExtentVO flicker = new LimitExtentVO(); + flicker.setCode("flicker"); + flicker.setName("闪变"); + LimitExtentVO uharm = new LimitExtentVO(); + uharm.setCode("uharm"); + uharm.setName("谐波电压"); + LimitExtentVO iharm = new LimitExtentVO(); + iharm.setCode("iharm"); + iharm.setName("谐波电流"); + LimitExtentVO voltageDev = new LimitExtentVO(); + voltageDev.setCode("voltageDev"); + voltageDev.setName("电压偏差"); + LimitExtentVO ubalance = new LimitExtentVO(); + ubalance.setCode("ubalance"); + ubalance.setName("电压三相不平衡"); + 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) { + float overlimitPercent = (maxValue - limitValue) / limitValue * 100; + if (overlimitPercent >= 80) { + status = 2; + } + } + } + } + } + } + } + calendarVO.setItems(items); + calendarVO.setStatus(status); + result.add(calendarVO); + } + result.sort(Comparator.comparing(LimitCalendarVO::getTime)); + 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; + } +}