diff --git a/pqs-common/common-db/pom.xml b/pqs-common/common-db/pom.xml index 9bd677ae6..399d07938 100644 --- a/pqs-common/common-db/pom.xml +++ b/pqs-common/common-db/pom.xml @@ -57,6 +57,11 @@ mysql mysql-connector-java + + + org.postgresql + postgresql + com.dameng 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/LimitProbabilityQueryParam.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitProbabilityQueryParam.java new file mode 100644 index 000000000..07e221227 --- /dev/null +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitProbabilityQueryParam.java @@ -0,0 +1,9 @@ +package com.njcn.harmonic.pojo.param; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +@EqualsAndHashCode(callSuper = true) +@Data +public class LimitProbabilityQueryParam extends MainLineStatLimitRateDetailsQueryParam { +} 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-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitProbabilityVO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitProbabilityVO.java new file mode 100644 index 000000000..ea7c687a4 --- /dev/null +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitProbabilityVO.java @@ -0,0 +1,22 @@ +package com.njcn.harmonic.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/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitTimeProbabilityVO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitTimeProbabilityVO.java new file mode 100644 index 000000000..c3e677d08 --- /dev/null +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitTimeProbabilityVO.java @@ -0,0 +1,21 @@ +package com.njcn.harmonic.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/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java index a615cd2b1..82ad347c7 100644 --- a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java @@ -1,9 +1,207 @@ package com.njcn.harmonic.pojo.vo; +import com.fasterxml.jackson.annotation.JsonFormat; +import io.swagger.annotations.ApiModelProperty; import lombok.Data; -import lombok.EqualsAndHashCode; -@EqualsAndHashCode(callSuper = true) +import java.time.LocalDate; + @Data -public class TotalLimitStatisticsDetailsVO extends MainLineStatLimitRateDetailsVO { +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/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitTotalStatisticsVO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitTotalStatisticsVO.java index 7a8eccddf..02a073d9f 100644 --- a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitTotalStatisticsVO.java +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitTotalStatisticsVO.java @@ -7,13 +7,13 @@ import lombok.Data; public class TotalLimitTotalStatisticsVO { @ApiModelProperty("闪变越限占比") - private int flicker; + private double flicker; @ApiModelProperty("谐波电压越限占比") - private int uharm; + private double uharm; @ApiModelProperty("谐波电流越限占比") - private int iharm; + private double iharm; @ApiModelProperty("电压偏差越限占比") - private int voltageDev; + private double voltageDev; @ApiModelProperty("三相不平衡越限占比") - private int ubalance; + private double ubalance; } diff --git a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDController.java b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDController.java index 3b080a080..3afe0eb66 100644 --- a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDController.java +++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDController.java @@ -135,4 +135,25 @@ public class RStatLimitRateDController extends BaseController { 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/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..da76a8ee7 --- /dev/null +++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDetailDController.java @@ -0,0 +1,85 @@ +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.param.LimitProbabilityQueryParam; +import com.njcn.harmonic.pojo.vo.LimitCalendarVO; +import com.njcn.harmonic.pojo.vo.LimitExtentVO; +import com.njcn.harmonic.pojo.vo.LimitProbabilityVO; +import com.njcn.harmonic.pojo.vo.LimitTimeProbabilityVO; +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); + } + + + @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/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/IRStatLimitRateDService.java b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDService.java index b246ff3d9..b2f4e4a55 100644 --- a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDService.java +++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDService.java @@ -40,4 +40,9 @@ public interface IRStatLimitRateDService extends IService { List totalLimitStatisticsList(TotalLimitStatisticsParam param); List totalLimitStatisticsDetails(TotalLimitStatisticsDetailsQueryParam param); + + TotalLimitTotalStatisticsVO gridSideLimitTotalStatisticsData(TotalLimitStatisticsParam param); + + List gridSideLimitStatisticsList(TotalLimitStatisticsParam param); + } 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..1645dda1d --- /dev/null +++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDetailDService.java @@ -0,0 +1,30 @@ +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.param.LimitProbabilityQueryParam; +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.pojo.vo.LimitProbabilityVO; +import com.njcn.harmonic.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/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDServiceImpl.java b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDServiceImpl.java index 3233c23f8..a44b99187 100644 --- a/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDServiceImpl.java +++ b/pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDServiceImpl.java @@ -25,6 +25,9 @@ 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; @@ -45,6 +48,9 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl monitorIdsGetLimitRateInfo(String date, List monitorIds) { @@ -282,7 +288,7 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl 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 "闪变越限超标"; @@ -434,4 +589,10 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl implements IRStatLimitRateDetailDService { + + private final CsLineFeignClient csLineFeignClient; + private final OverLimitClient overLimitClient; + private final IRStatLimitRateDService rStatLimitRateDService; + + 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())); + } +} diff --git a/pqs-system/system-boot/src/main/java/com/njcn/system/controller/PqDashboardPageController.java b/pqs-system/system-boot/src/main/java/com/njcn/system/controller/PqDashboardPageController.java index d2bc967aa..ad843a207 100644 --- a/pqs-system/system-boot/src/main/java/com/njcn/system/controller/PqDashboardPageController.java +++ b/pqs-system/system-boot/src/main/java/com/njcn/system/controller/PqDashboardPageController.java @@ -4,12 +4,14 @@ 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.exception.BusinessException; import com.njcn.common.pojo.response.HttpResult; import com.njcn.common.utils.HttpResultUtil; import com.njcn.system.pojo.param.PqDashboardPageParam; import com.njcn.system.pojo.po.PqDashboardPage; import com.njcn.system.pojo.vo.PqDashboardPageVO; import com.njcn.system.service.PqDashboardPageService; +import com.njcn.user.enums.UserResponseEnum; import com.njcn.web.controller.BaseController; import io.swagger.annotations.Api; import io.swagger.annotations.ApiImplicitParam; @@ -21,6 +23,7 @@ import org.springframework.beans.BeanUtils; import org.springframework.web.bind.annotation.*; import java.util.List; +import java.util.Objects; /** * Description: @@ -94,6 +97,9 @@ public class PqDashboardPageController extends BaseController { String methodDescribe = getMethodDescribe("queryActivatePage"); PqDashboardPageVO vo = new PqDashboardPageVO(); PqDashboardPage result = pqDashboardPageService.lambdaQuery().eq(PqDashboardPage::getState,1).one(); + if(Objects.isNull(result)){ + throw new BusinessException("暂无激活的驾驶舱页面"); + } BeanUtils.copyProperties(result,vo); return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, vo, methodDescribe); } diff --git a/pqs-system/system-boot/src/main/java/com/njcn/system/service/impl/SysDicTreePOServiceImpl.java b/pqs-system/system-boot/src/main/java/com/njcn/system/service/impl/SysDicTreePOServiceImpl.java index 2c80e034f..40a8ed9c2 100644 --- a/pqs-system/system-boot/src/main/java/com/njcn/system/service/impl/SysDicTreePOServiceImpl.java +++ b/pqs-system/system-boot/src/main/java/com/njcn/system/service/impl/SysDicTreePOServiceImpl.java @@ -192,7 +192,7 @@ public class SysDicTreePOServiceImpl extends ServiceImpl queryWrapper = new LambdaQueryWrapper<>(); queryWrapper.eq(SysDicTreePO::getPid,vo.getId()) .eq(SysDicTreePO::getStatus,0) - .orderByDesc(SysDicTreePO::getSort); + .orderByAsc(SysDicTreePO::getSort); char lastChar = lineId.charAt(lineId.length() - 1); //治理APF指标 if (Objects.equals(lastChar,'0')) { diff --git a/pqs-user/user-api/src/main/java/com/njcn/user/enums/AppRoleEnum.java b/pqs-user/user-api/src/main/java/com/njcn/user/enums/AppRoleEnum.java index 6fb7dbfba..1ec0f50d1 100644 --- a/pqs-user/user-api/src/main/java/com/njcn/user/enums/AppRoleEnum.java +++ b/pqs-user/user-api/src/main/java/com/njcn/user/enums/AppRoleEnum.java @@ -16,6 +16,7 @@ public enum AppRoleEnum { APP_VIP_USER("app_vip_user","移动端正式用户"), MARKET_USER("market_user","营销角色"), ENGINEERING_USER("engineering_user","工程角色"), + BXS_USER("bxs_user","便携式正式用户"), ROOT("root","超级管理员"), OPERATION_MANAGER("operation_manager","运维管理员"), ; diff --git a/pqs-user/user-boot/src/main/java/com/njcn/user/controller/UserController.java b/pqs-user/user-boot/src/main/java/com/njcn/user/controller/UserController.java index f470b0631..0d3c453d1 100644 --- a/pqs-user/user-boot/src/main/java/com/njcn/user/controller/UserController.java +++ b/pqs-user/user-boot/src/main/java/com/njcn/user/controller/UserController.java @@ -511,6 +511,15 @@ public class UserController extends BaseController { return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, users, methodDescribe); } + @OperateInfo(info = LogEnum.SYSTEM_COMMON) + @PostMapping("/getFormalUserList") + @ApiOperation("获取移动端、便携式正式用户列表") + public HttpResult> getFormalUserList() { + String methodDescribe = getMethodDescribe("getFormalUserList"); + List users = userService.getFormalUserList(); + return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, users, methodDescribe); + } + /** * 获取同级部门用户，以及下级部门所有用户 diff --git a/pqs-user/user-boot/src/main/java/com/njcn/user/service/IUserService.java b/pqs-user/user-boot/src/main/java/com/njcn/user/service/IUserService.java index e94288857..053f43f4b 100644 --- a/pqs-user/user-boot/src/main/java/com/njcn/user/service/IUserService.java +++ b/pqs-user/user-boot/src/main/java/com/njcn/user/service/IUserService.java @@ -175,13 +175,12 @@ public interface IUserService extends IService { boolean activateUser(String id); - List getMarketList(); + List getFormalUserList(); List getUserListByDeptId(String deptId); - boolean updateAppUser(UserInfoParm userInfoParm); String uploadImage(MultipartFile issuesFile); diff --git a/pqs-user/user-boot/src/main/java/com/njcn/user/service/impl/UserServiceImpl.java b/pqs-user/user-boot/src/main/java/com/njcn/user/service/impl/UserServiceImpl.java index 5d47b086b..3a933cc9e 100644 --- a/pqs-user/user-boot/src/main/java/com/njcn/user/service/impl/UserServiceImpl.java +++ b/pqs-user/user-boot/src/main/java/com/njcn/user/service/impl/UserServiceImpl.java @@ -15,12 +15,10 @@ import com.njcn.common.pojo.constant.LogInfo; import com.njcn.common.pojo.enums.common.DataStateEnum; 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.common.utils.PubUtils; import com.njcn.common.utils.sm.DesUtils; import com.njcn.common.utils.sm.Sm4Utils; import com.njcn.db.constant.DbConstant; -import com.njcn.device.pq.pojo.po.PqsTerminalLogs; import com.njcn.oss.constant.OssPath; import com.njcn.oss.utils.FileStorageUtil; import com.njcn.poi.excel.ExcelUtil; @@ -28,8 +26,6 @@ import com.njcn.redis.pojo.enums.RedisKeyEnum; import com.njcn.redis.utils.RedisUtil; import com.njcn.system.api.AreaFeignClient; import com.njcn.system.api.DicDataFeignClient; -import com.njcn.system.enums.DicDataEnum; -import com.njcn.system.pojo.po.DictData; import com.njcn.user.enums.AppRoleEnum; import com.njcn.user.enums.UserResponseEnum; import com.njcn.user.enums.UserStatusEnum; @@ -489,6 +485,25 @@ public class UserServiceImpl extends ServiceImpl implements IU return this.listByIds(collect); } + @Override + public List getFormalUserList() { + List users = new ArrayList<>(); + Role roleByCode1 = roleService.getRoleByCode(AppRoleEnum.APP_VIP_USER.getCode()); + Role roleByCode2 = roleService.getRoleByCode(AppRoleEnum.BXS_USER.getCode()); + List userRoles = userRoleMapper.selectUserRole(Stream.of(roleByCode1.getId(),roleByCode2.getId()).collect(Collectors.toList())); + List collect = userRoles.stream().map(UserRole::getUserId).distinct().collect(Collectors.toList()); + List users1 = this.listByIds(collect); + if (CollectionUtil.isNotEmpty(users1)) { + users1.forEach(item->{ + UserVO userVO = new UserVO(); + userVO.setId(item.getId()); + userVO.setName(item.getName()); + users.add(userVO); + }); + } + return users; + } + @Override public List getUserListByDeptId(String deptId) { LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();