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

Merge remote-tracking branch 'origin/main'

Browse Source
This commit is contained in:
wr
2025-11-26 16:04:33 +08:00
parent 075dfc19d6 ff1351b107
commit b523a24e5b
27 changed files with 1890 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
pqs-common/common-db/pom.xml
View File

@@ -57,6 +57,11 @@
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!--vastbase驱动用postgresql-->
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
</dependency>
<!--达梦驱动-->
<dependency>
<groupId>com.dameng</groupId>

9
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitCalendarQueryParam.java Normal file
View File

@@ -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 {
}

23
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitExtentDayQueryParam.java Normal file
View File

@@ -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;
}

9
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitExtentQueryParam.java Normal file
View File

@@ -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 {
}

9
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/LimitProbabilityQueryParam.java Normal file
View File

@@ -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 {
}

6
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/MainLineStatLimitRateDetailsQueryParam.java
View File

@@ -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")

594
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/day/RStatLimitRateDetailDPO.java Normal file
View File

@@ -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;
}

23
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitCalendarVO.java Normal file
View File

@@ -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<String> items;
@ApiModelProperty("越限程度， 0:无 1:一般（超过限值80%以下）2:严重（超过限值80%以上）")
private int status;
}

49
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitExtentVO.java Normal file
View File

@@ -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;
}
}

22
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitProbabilityVO.java Normal file
View File

@@ -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<Map<Integer, Integer>> extentGrades;
}

21
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/LimitTimeProbabilityVO.java Normal file
View File

@@ -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;
}

204
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java
View File

@@ -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;
}

10
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/TotalLimitTotalStatisticsVO.java
View File

@@ -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;
}

21
pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDController.java
View File

@@ -135,4 +135,25 @@ public class RStatLimitRateDController extends BaseController {
List<TotalLimitStatisticsDetailsVO> list = limitRateDService.totalLimitStatisticsDetails(param);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe);
}
@PostMapping("/gridSideLimitStatistics/data")
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@ApiOperation("电网侧指标越限统计数据")
public HttpResult<TotalLimitTotalStatisticsVO> 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<List<TotalLimitStatisticsVO>> gridSideLimitStatisticsList(@RequestBody TotalLimitStatisticsParam mainLineQueryParam) {
String methodDescribe = getMethodDescribe("gridSideLimitStatisticsList");
List<TotalLimitStatisticsVO> list = limitRateDService.gridSideLimitStatisticsList(mainLineQueryParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe);
}
}

85
pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/controller/RStatLimitRateDetailDController.java Normal file
View File

@@ -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<List<LimitExtentVO>> limitExtentData(@RequestBody LimitExtentQueryParam queryParam) {
String methodDescribe = getMethodDescribe("limitExtentData");
List<LimitExtentVO> result = limitRateDetailDService.limitExtentData(queryParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
}
@PostMapping("/limitRateDetailD/limitExtentDayData")
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@ApiOperation("获取指标日趋势图数据")
public HttpResult<JSONArray> 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<List<LimitCalendarVO>> limitCalendarData(@RequestBody LimitCalendarQueryParam queryParam) {
String methodDescribe = getMethodDescribe("limitCalendarData");
List<LimitCalendarVO> result = limitRateDetailDService.limitCalendarData(queryParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
}
@PostMapping("/limitRateDetailD/limitProbabilityData")
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@ApiOperation("获取指标越限程度概率分布数据")
public HttpResult<List<LimitProbabilityVO>> limitProbabilityData(@RequestBody LimitProbabilityQueryParam queryParam) {
String methodDescribe = getMethodDescribe("limitProbabilityData");
List<LimitProbabilityVO> result = limitRateDetailDService.limitProbabilityData(queryParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
}
@PostMapping("/limitRateDetailD/limitTimeProbabilityData")
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@ApiOperation("获取指标越限时间概率分布数据")
public HttpResult<List<LimitTimeProbabilityVO>> limitTimeProbabilityData(@RequestBody LimitProbabilityQueryParam queryParam) {
String methodDescribe = getMethodDescribe("limitTimeProbabilityData");
List<LimitTimeProbabilityVO> result = limitRateDetailDService.limitTimeProbabilityData(queryParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
}
}

9
pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/mapper/RStatLimitRateDetailDMapper.java Normal file
View File

@@ -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<RStatLimitRateDetailDPO> {
}

6
pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/mapper/mapping/RStatLimitRateDetailDMapper.xml Normal file
View File

@@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.njcn.harmonic.rstatlimitrate.mapper.RStatLimitRateDetailDMapper">
</mapper>

5
pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDService.java
View File

@@ -40,4 +40,9 @@ public interface IRStatLimitRateDService extends IService<RStatLimitRateDPO> {
List<TotalLimitStatisticsVO> totalLimitStatisticsList(TotalLimitStatisticsParam param);
List<TotalLimitStatisticsDetailsVO> totalLimitStatisticsDetails(TotalLimitStatisticsDetailsQueryParam param);
TotalLimitTotalStatisticsVO gridSideLimitTotalStatisticsData(TotalLimitStatisticsParam param);
List<TotalLimitStatisticsVO> gridSideLimitStatisticsList(TotalLimitStatisticsParam param);
}

30
pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/IRStatLimitRateDetailDService.java Normal file
View File

@@ -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<RStatLimitRateDetailDPO> {
List<LimitExtentVO> limitExtentData(LimitExtentQueryParam param);
JSONArray limitExtentDayData(LimitExtentDayQueryParam param);
List<LimitCalendarVO> limitCalendarData(LimitCalendarQueryParam param);
List<LimitProbabilityVO> limitProbabilityData(LimitProbabilityQueryParam param);
List<LimitTimeProbabilityVO> limitTimeProbabilityData(LimitProbabilityQueryParam param);
}

193
pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDServiceImpl.java
View File

@@ -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<RStatLimitRateDMappe
private final CsLineFeignClient csLineFeignClient;
private final DicDataFeignClient dicDataFeignClient;
private final DecimalFormat df = new DecimalFormat("#0.00");
private final String GRID_SIDE_DICT_CODE = "Grid_Side";
@Override
public List<RStatLimitRateDPO> monitorIdsGetLimitRateInfo(String date, List<String> monitorIds) {
@@ -282,7 +288,7 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
String key = entry.getKey();
if (key.endsWith("Overtime")) {
String value = entry.getValue().toString();
Integer intValue = new Integer(value);
int intValue = new Integer(value);
if (key.startsWith("uharm")) {
uharmTotalTime += intValue;
}
@@ -297,11 +303,11 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
if (totalTime == 0) {
return statisticsVO;
}
statisticsVO.setFlicker(flickerTotalTime / totalTime * 100);
statisticsVO.setUharm(uharmTotalTime / totalTime * 100);
statisticsVO.setIharm(iharmTotalTime / totalTime * 100);
statisticsVO.setVoltageDev(voltageDevTotalTime / totalTime * 100);
statisticsVO.setUbalance(ubalanceTotalTime / totalTime * 100);
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;
}
@@ -356,15 +362,21 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
}
}
// 取最大值
uharm += uharmList.stream().max(Integer::compareTo).get();
iharm += iharmList.stream().max(Integer::compareTo).get();
uharm += uharmList.stream().max(Integer::compareTo).orElse(0);
iharm += iharmList.stream().max(Integer::compareTo).orElse(0);
}
if (totalTime != 0) {
statisticsVO.setFlicker(flickerTotalTime / totalTime * 100);
statisticsVO.setVoltageDev(voltageDevTotalTime / totalTime * 100);
statisticsVO.setUbalance(ubalanceTotalTime / totalTime * 100);
statisticsVO.setUharm(uharm / totalTime * 100);
statisticsVO.setIharm(iharm / totalTime * 100);
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);
@@ -396,9 +408,9 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
String key = entry.getKey();
if (key.endsWith("Overtime") && allTime != 0) {
String value = entry.getValue().toString();
Integer intValue = new Integer(value);
int intValue = new Integer(value);
// 占比 = 越限次数 / 总次数 * 100
int proportion = intValue / allTime * 100;
double proportion = calculatePercentage(intValue, allTime);
entries.putOpt(key, proportion);
}
}
@@ -406,6 +418,149 @@ public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMappe
}).collect(Collectors.toList());
}
@Override
public TotalLimitTotalStatisticsVO gridSideLimitTotalStatisticsData(TotalLimitStatisticsParam param) {
TotalLimitTotalStatisticsVO statisticsVO = new TotalLimitTotalStatisticsVO();
// 获取电网侧监测点
DictData dictData = dicDataFeignClient.getDicDataByCode(GRID_SIDE_DICT_CODE).getData();
CsLinePO queryParam = new CsLinePO();
queryParam.setPosition(dictData.getId());
List<CsLinePO> linePOList = csLineFeignClient.list(queryParam).getData();
List<String> lineIds = linePOList.stream().map(CsLinePO::getLineId).collect(Collectors.toList());
if (CollUtil.isEmpty(lineIds)) {
return statisticsVO;
}
List<RStatLimitRateDPO> rateList = this.list(new LambdaQueryWrapper<RStatLimitRateDPO>()
.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<String, Object> 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<TotalLimitStatisticsVO> gridSideLimitStatisticsList(TotalLimitStatisticsParam param) {
List<TotalLimitStatisticsVO> result = new ArrayList<>();
// 获取电网侧监测点
DictData dictData = dicDataFeignClient.getDicDataByCode(GRID_SIDE_DICT_CODE).getData();
CsLinePO queryParam = new CsLinePO();
queryParam.setPosition(dictData.getId());
List<CsLinePO> linePOList = csLineFeignClient.list(queryParam).getData();
List<String> lineIds = linePOList.stream().map(CsLinePO::getLineId).collect(Collectors.toList());
if (CollUtil.isEmpty(lineIds)) {
return result;
}
List<RStatLimitRateDPO> rateList = this.list(new LambdaQueryWrapper<RStatLimitRateDPO>()
.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<String, List<RStatLimitRateDPO>> lineMap = rateList.stream().collect(Collectors.groupingBy(RStatLimitRateDPO::getLineId));
Map<String, CsLinePO> linePOMap = linePOList.stream().collect(Collectors.toMap(CsLinePO::getLineId, csLinePO -> csLinePO));
List<CsLinePO> 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<RStatLimitRateDPO> 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<Integer> uharmList = new ArrayList<>();
List<Integer> iharmList = new ArrayList<>();
for (Map.Entry<String, Object> 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<RStatLimitRateDMappe
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()));
}
}

550
pqs-harmonic/harmonic-common/src/main/java/com/njcn/harmonic/rstatlimitrate/service/impl/RStatLimitRateDetailDServiceImpl.java Normal file
View File

@@ -0,0 +1,550 @@
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.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 com.njcn.harmonic.rstatlimitrate.mapper.RStatLimitRateDetailDMapper;
import com.njcn.harmonic.rstatlimitrate.service.IRStatLimitRateDService;
import com.njcn.harmonic.rstatlimitrate.service.IRStatLimitRateDetailDService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;
@RequiredArgsConstructor
@Service
public class RStatLimitRateDetailDServiceImpl extends ServiceImpl<RStatLimitRateDetailDMapper, RStatLimitRateDetailDPO> implements IRStatLimitRateDetailDService {
private final CsLineFeignClient csLineFeignClient;
private final OverLimitClient overLimitClient;
private final IRStatLimitRateDService rStatLimitRateDService;
private final DecimalFormat df = new DecimalFormat("#0.00");
static Map<String, String> indexMap = new HashMap<>();
static List<List<Integer>> timePeriodList = new ArrayList<>();
static List<List<Integer>> 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<LimitExtentVO> limitExtentData(LimitExtentQueryParam param) {
List<LimitExtentVO> 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<RStatLimitRateDetailDPO> detailList = this.list(new LambdaQueryWrapper<RStatLimitRateDetailDPO>()
.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<String> lineIds = detailList.stream().map(RStatLimitRateDetailDPO::getLineId).distinct().collect(Collectors.toList());
List<Overlimit> overlimitList = overLimitClient.getOverLimitByLineIds(lineIds).getData();
Map<String, Pair<Float, RStatLimitRateDetailDPO>> findResult = findMaxValueHandle(detailList);
// 闪变
Pair<Float, RStatLimitRateDetailDPO> flickerResult = findResult.get(flicker.getCode());
setLimitExtentInfo(flicker, flickerResult);
// 电压偏差
Pair<Float, RStatLimitRateDetailDPO> voltageDevResult = findResult.get(voltageDev.getCode());
setLimitExtentInfo(voltageDev, voltageDevResult);
// 谐波电压
String uharmKey = findResult.keySet().stream().filter(code -> code.startsWith("uharm")).findFirst().orElse("uharm");
Pair<Float, RStatLimitRateDetailDPO> uharmResult = findResult.get(uharmKey);
setLimitExtentInfo(uharm, uharmResult);
uharm.setCode(uharmKey);
String iharmKey = findResult.keySet().stream().filter(code -> code.startsWith("iharm")).findFirst().orElse("iharm");
// 谐波电流
Pair<Float, RStatLimitRateDetailDPO> iharmResult = findResult.get(iharmKey);
setLimitExtentInfo(iharm, iharmResult);
iharm.setCode(iharmKey);
// 电压三相不平衡
Pair<Float, RStatLimitRateDetailDPO> 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<String, Object> 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<RStatLimitRateDetailDPO> records = this.page(new Page<>(1, 1),
new LambdaQueryWrapper<RStatLimitRateDetailDPO>()
.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<String, Object> 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<LimitCalendarVO> limitCalendarData(LimitCalendarQueryParam param) {
List<LimitCalendarVO> result = new ArrayList<>();
List<RStatLimitRateDetailDPO> detailList = this.list(new LambdaQueryWrapper<RStatLimitRateDetailDPO>()
.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<LocalDate, List<RStatLimitRateDetailDPO>> detailMap = detailList.stream().collect(Collectors.groupingBy(RStatLimitRateDetailDPO::getTime));
LimitCalendarVO calendarVO;
for (Map.Entry<LocalDate, List<RStatLimitRateDetailDPO>> entry : detailMap.entrySet()) {
calendarVO = new LimitCalendarVO();
LocalDate time = entry.getKey();
calendarVO.setTime(time);
int status = 0;
List<String> items = new ArrayList<>();
List<RStatLimitRateDetailDPO> dayDetailList = entry.getValue();
for (RStatLimitRateDetailDPO detail : dayDetailList) {
String lineId = detail.getLineId();
List<Overlimit> overlimitList = overLimitClient.getOverLimitByLineIds(Collections.singletonList(lineId)).getData();
Overlimit overlimit = overlimitList.stream().findFirst().orElse(null);
JSONObject entries = JSONUtil.parseObj(detail);
for (Map.Entry<String, Object> 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<LimitProbabilityVO> limitProbabilityData(LimitProbabilityQueryParam param) {
List<LimitProbabilityVO> result = new ArrayList<>();
List<RStatLimitRateDetailDPO> detailList = this.list(new LambdaQueryWrapper<RStatLimitRateDetailDPO>()
.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<Overlimit> 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<String, String> 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<Double> extentValuesList = new ArrayList<>();
for (RStatLimitRateDetailDPO detail : detailList) {
JSONObject entries = JSONUtil.parseObj(detail);
for (Map.Entry<String, Object> 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<Map<Integer, Integer>> extentGrades = new ArrayList<>();
for (int i = 0; i < extentPeriodList.size(); i++) {
Map<Integer, Integer> grade = new HashMap<>();
int times = 0;
for (Double extentValue : extentValuesList) {
List<Integer> 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<LimitTimeProbabilityVO> limitTimeProbabilityData(LimitProbabilityQueryParam param) {
List<LimitTimeProbabilityVO> result = new ArrayList<>();
List<RStatLimitRateDetailDPO> detailList = this.list(new LambdaQueryWrapper<RStatLimitRateDetailDPO>()
.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<String, String> entry : indexMap.entrySet()) {
String indexCode = entry.getKey();
for (List<Integer> 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<String> 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<Float, RStatLimitRateDetailDPO> 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<String, Pair<Float, RStatLimitRateDetailDPO>> findMaxValueHandle(List<RStatLimitRateDetailDPO> detailList) {
Map<String, Pair<Float, RStatLimitRateDetailDPO>> 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<String, Object> 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()));
}
}

6
pqs-system/system-boot/src/main/java/com/njcn/system/controller/PqDashboardPageController.java
View File

@@ -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);
}

2
pqs-system/system-boot/src/main/java/com/njcn/system/service/impl/SysDicTreePOServiceImpl.java
View File

@@ -192,7 +192,7 @@ public class SysDicTreePOServiceImpl extends ServiceImpl<SysDicTreePOMapper, Sys
LambdaQueryWrapper<SysDicTreePO> 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')) {

1
pqs-user/user-api/src/main/java/com/njcn/user/enums/AppRoleEnum.java
View File

@@ -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","运维管理员"),
;

9
pqs-user/user-boot/src/main/java/com/njcn/user/controller/UserController.java
View File

@@ -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<List<UserVO>> getFormalUserList() {
String methodDescribe = getMethodDescribe("getFormalUserList");
List<UserVO> users = userService.getFormalUserList();
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, users, methodDescribe);
}
/**
* 获取同级部门用户，以及下级部门所有用户

3
pqs-user/user-boot/src/main/java/com/njcn/user/service/IUserService.java
View File

@@ -175,13 +175,12 @@ public interface IUserService extends IService<User> {
boolean activateUser(String id);
List<User> getMarketList();
List<UserVO> getFormalUserList();
List<User> getUserListByDeptId(String deptId);
boolean updateAppUser(UserInfoParm userInfoParm);
String uploadImage(MultipartFile issuesFile);

23
pqs-user/user-boot/src/main/java/com/njcn/user/service/impl/UserServiceImpl.java
View File

@@ -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<UserMapper, User> implements IU
return this.listByIds(collect);
}
@Override
public List<UserVO> getFormalUserList() {
List<UserVO> users = new ArrayList<>();
Role roleByCode1 = roleService.getRoleByCode(AppRoleEnum.APP_VIP_USER.getCode());
Role roleByCode2 = roleService.getRoleByCode(AppRoleEnum.BXS_USER.getCode());
List<UserRole> userRoles = userRoleMapper.selectUserRole(Stream.of(roleByCode1.getId(),roleByCode2.getId()).collect(Collectors.toList()));
List<String> collect = userRoles.stream().map(UserRole::getUserId).distinct().collect(Collectors.toList());
List<User> 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<User> getUserListByDeptId(String deptId) {
LambdaQueryWrapper<Dept> lambdaQueryWrapper = new LambdaQueryWrapper<>();