Merge remote-tracking branch 'origin/master'

# Conflicts:
#	cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/controller/line/CslineController.java

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/HarCurrent.java

@@ -0,0 +1,9 @@
+package com.njcn.csharmonic.annotaion;
+
+import java.lang.annotation.*;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface HarCurrent {
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/HarVoltage.java

@@ -0,0 +1,9 @@
+package com.njcn.csharmonic.annotaion;
+
+import java.lang.annotation.*;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface HarVoltage {
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/InterharVoltage.java

@@ -0,0 +1,11 @@
+package com.njcn.csharmonic.annotaion;
+
+import java.lang.annotation.*;
+
+
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface InterharVoltage {
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitCalendarQueryParam.java

@@ -0,0 +1,9 @@
+package com.njcn.csharmonic.pojo.param;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class LimitCalendarQueryParam extends TotalLimitStatisticsParam {
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitExtentDayQueryParam.java

@@ -0,0 +1,23 @@
+package com.njcn.csharmonic.pojo.param;
+
+import com.njcn.web.pojo.annotation.DateTimeStrValid;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotBlank;
+
+@Data
+public class LimitExtentDayQueryParam {
+
+    @ApiModelProperty(value = "发生时间")
+    @NotBlank(message = "发生日期不能为空")
+    @DateTimeStrValid(message = "发生日期格式出错")
+    private String time;
+
+    @ApiModelProperty(value = "监测点id")
+    @NotBlank(message = "监测点id不能为空")
+    private String lineId;
+    @ApiModelProperty(value = "指标编码")
+    @NotBlank(message = "指标编码不能为空")
+    private String code;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitExtentQueryParam.java

@@ -0,0 +1,9 @@
+package com.njcn.csharmonic.pojo.param;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class LimitExtentQueryParam extends TotalLimitStatisticsParam {
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/LimitProbabilityQueryParam.java

@@ -0,0 +1,9 @@
+package com.njcn.csharmonic.pojo.param;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class LimitProbabilityQueryParam extends MainLineStatLimitRateDetailsQueryParam {
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/MainLineQueryParam.java

@@ -0,0 +1,35 @@
+package com.njcn.csharmonic.pojo.param;
+
+import com.njcn.web.pojo.annotation.DateTimeStrValid;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import javax.validation.constraints.NotBlank;
+
+
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class MainLineQueryParam {
+    @ApiModelProperty("关键词")
+    private String keywords;
+
+    @ApiModelProperty(name = "searchBeginTime", value = "开始时间")
+    @NotBlank(message = "起始时间不可为空")
+    @DateTimeStrValid(message = "起始时间格式出错")
+    private String searchBeginTime;
+
+    @ApiModelProperty(name = "searchEndTime", value = "结束时间")
+    @NotBlank(message = "结束时间不可为空")
+    private String searchEndTime;
+
+    @ApiModelProperty(value = "页码", example = "1")
+    private int pageNum = 1;
+
+    @ApiModelProperty(value = "每页记录数", example = "10")
+    private int pageSize = 10;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/MainLineStatLimitRateDetailsQueryParam.java

@@ -0,0 +1,23 @@
+package com.njcn.csharmonic.pojo.param;
+
+import com.njcn.web.pojo.annotation.DateTimeStrValid;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotBlank;
+
+@Data
+public class MainLineStatLimitRateDetailsQueryParam {
+    @NotBlank(message = "监测点ID不可为空")
+    @ApiModelProperty("监测点ID")
+    private String lineId;
+
+    @ApiModelProperty(name = "searchBeginTime", value = "开始时间")
+    @NotBlank(message = "起始时间不可为空")
+    @DateTimeStrValid(message = "起始时间格式出错")
+    private String searchBeginTime;
+
+    @ApiModelProperty(name = "searchEndTime", value = "结束时间")
+    @NotBlank(message = "结束时间不可为空")
+    private String searchEndTime;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/RStatLimitQueryParam.java

@@ -0,0 +1,27 @@
+package com.njcn.csharmonic.pojo.param;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+/**
+ * pqs
+ *
+ * @author cdf
+ * @date 2024/2/28
+ */
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+public class RStatLimitQueryParam {
+
+    private List<String> ids;
+
+    private String date;
+
+    private String endDate;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/StatSubstationBizBaseParam.java

@@ -0,0 +1,39 @@
+package com.njcn.csharmonic.pojo.param;
+
+import com.njcn.common.pojo.param.StatisticsBizBaseParam;
+import com.njcn.web.constant.ValidMessage;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import org.hibernate.validator.constraints.Range;
+
+import java.util.List;
+
+/**
+ * <功能描述>
+ *
+ * @author 1754607820@qq.com
+ * @createTime: 2022-10-18
+ */
+@Data
+public class StatSubstationBizBaseParam extends StatisticsBizBaseParam {
+
+    @ApiModelProperty(value = "ids集合", required = true)
+    private List<String> ids;
+
+    @ApiModelProperty(value = "是否是国网监测点信息", required = true)
+    private Integer isUpToGrid;
+
+    @ApiModelProperty("页码")
+    private Integer pageNum;
+
+    @ApiModelProperty("页面尺寸")
+    private Integer pageSize;
+
+    /**
+     * 0-电网侧
+     * 1-非电网侧
+     */
+    @ApiModelProperty("电网侧标识")
+    @Range(min = 0, max = 2, message = "电网侧标识" + ValidMessage.PARAM_FORMAT_ERROR)
+    private Integer powerFlag;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/TotalLimitStatisticsDetailsQueryParam.java

@@ -0,0 +1,9 @@
+package com.njcn.csharmonic.pojo.param;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class TotalLimitStatisticsDetailsQueryParam extends MainLineStatLimitRateDetailsQueryParam {
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/TotalLimitStatisticsParam.java

@@ -0,0 +1,19 @@
+package com.njcn.csharmonic.pojo.param;
+
+import com.njcn.web.pojo.annotation.DateTimeStrValid;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotBlank;
+
+@Data
+public class TotalLimitStatisticsParam {
+    @ApiModelProperty(name = "searchBeginTime", value = "开始时间")
+    @NotBlank(message = "起始时间不可为空")
+    @DateTimeStrValid(message = "起始时间格式出错")
+    private String searchBeginTime;
+
+    @ApiModelProperty(name = "searchEndTime", value = "结束时间")
+    @NotBlank(message = "结束时间不可为空")
+    private String searchEndTime;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/po/RStatLimitRateDPO.java

@@ -0,0 +1,614 @@
+package com.njcn.csharmonic.pojo.po;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.github.jeffreyning.mybatisplus.anno.MppMultiId;
+import com.njcn.csharmonic.annotaion.HarCurrent;
+import com.njcn.csharmonic.annotaion.HarVoltage;
+import com.njcn.csharmonic.annotaion.InterharVoltage;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDate;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@TableName(value = "r_stat_limit_rate_d")
+public class RStatLimitRateDPO {
+    /**
+     * 监测点ID合格率的变电站/装置/母线/线路序号
+     */
+    @MppMultiId
+    @TableField(value = "my_index")
+    @ApiModelProperty(value = "监测点ID合格率的变电站/装置/母线/线路序号")
+    private String lineId;
+
+    /**
+     * 数据类型,’A’表示A相，’B’表示B相,’C’表示C相,’’M’表示ABC三项总和，T’表示总
+     */
+    @MppMultiId
+    @TableField(value = "phasic_type")
+    @ApiModelProperty(value = "数据类型,'A'表示A相，'B'表示B相,'C'表示C相,''M'表示ABC三项总和，T'表示总")
+    private String phasicType;
+
+    /**
+     * 合格率时间
+     */
+    @MppMultiId
+    @TableField(value = "time_id")
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+    @ApiModelProperty(value = "合格率时间")
+    private LocalDate time;
+
+    /**
+     * 总计算次数
+     */
+    @TableField(value = "all_time")
+    @ApiModelProperty(value = "总计算次数")
+    private Integer allTime;
+
+    /**
+     * 闪变越限次数
+     */
+    @TableField(value = "flicker_overtime")
+    @ApiModelProperty(value = "闪变越限次数")
+    private Integer flickerOvertime;
+
+    /**
+     * 闪变总计算次数
+     */
+    @TableField(value = "flicker_all_time")
+    @ApiModelProperty(value = "闪变总计算次数")
+    private Integer flickerAllTime;
+
+    /**
+     * 频率偏差越限次数
+     */
+    @TableField(value = "freq_dev_overtime")
+    @ApiModelProperty(value = "频率偏差越限次数")
+    private Integer freqDevOvertime;
+
+    /**
+     * 电压偏差越限次数
+     */
+    @TableField(value = "voltage_dev_overtime")
+    @ApiModelProperty(value = "电压偏差越限次数")
+    private Integer voltageDevOvertime;
+
+    /**
+     * 三相电压不平衡度越限次数
+     */
+    @TableField(value = "ubalance_overtime")
+    @ApiModelProperty(value = "三相电压不平衡度越限次数")
+    private Integer ubalanceOvertime;
+
+    /**
+     * 电压谐波畸变率越限次数
+     */
+    @TableField(value = "uaberrance_overtime")
+    @ApiModelProperty(value = "电压谐波畸变率越限次数")
+    private Integer uaberranceOvertime;
+
+    /**
+     * 负序电流限值次数
+     */
+    @TableField(value = "i_neg_overtime")
+    @ApiModelProperty(value = "负序电流限值次数")
+    private Integer iNegOvertime;
+
+    /**
+     * 2次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_2_overtime")
+    @ApiModelProperty(value = "2次电压谐波含有率越限次数")
+    private Integer uharm2Overtime;
+
+    /**
+     * 3次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_3_overtime")
+    @ApiModelProperty(value = "3次电压谐波含有率越限次数")
+    private Integer uharm3Overtime;
+
+    /**
+     * 4次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_4_overtime")
+    @ApiModelProperty(value = "4次电压谐波含有率越限次数")
+    private Integer uharm4Overtime;
+
+    /**
+     * 5次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_5_overtime")
+    @ApiModelProperty(value = "5次电压谐波含有率越限次数")
+    private Integer uharm5Overtime;
+
+    /**
+     * 6次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_6_overtime")
+    @ApiModelProperty(value = "6次电压谐波含有率越限次数")
+    private Integer uharm6Overtime;
+
+    /**
+     * 7次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_7_overtime")
+    @ApiModelProperty(value = "7次电压谐波含有率越限次数")
+    private Integer uharm7Overtime;
+
+    /**
+     * 8次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_8_overtime")
+    @ApiModelProperty(value = "8次电压谐波含有率越限次数")
+    private Integer uharm8Overtime;
+
+    /**
+     * 9次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_9_overtime")
+    @ApiModelProperty(value = "9次电压谐波含有率越限次数")
+    private Integer uharm9Overtime;
+
+    /**
+     * 10次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_10_overtime")
+    @ApiModelProperty(value = "10次电压谐波含有率越限次数")
+    private Integer uharm10Overtime;
+
+    /**
+     * 11次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_11_overtime")
+    @ApiModelProperty(value = "11次电压谐波含有率越限次数")
+    private Integer uharm11Overtime;
+
+    /**
+     * 12次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_12_overtime")
+    @ApiModelProperty(value = "12次电压谐波含有率越限次数")
+    private Integer uharm12Overtime;
+
+    /**
+     * 13次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_13_overtime")
+    @ApiModelProperty(value = "13次电压谐波含有率越限次数")
+    private Integer uharm13Overtime;
+
+    /**
+     * 14次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_14_overtime")
+    @ApiModelProperty(value = "14次电压谐波含有率越限次数")
+    private Integer uharm14Overtime;
+
+    /**
+     * 15次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_15_overtime")
+    @ApiModelProperty(value = "15次电压谐波含有率越限次数")
+    private Integer uharm15Overtime;
+
+    /**
+     * 16次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_16_overtime")
+    @ApiModelProperty(value = "16次电压谐波含有率越限次数")
+    private Integer uharm16Overtime;
+
+    /**
+     * 17次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_17_overtime")
+    @ApiModelProperty(value = "17次电压谐波含有率越限次数")
+    private Integer uharm17Overtime;
+
+    /**
+     * 18次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_18_overtime")
+    @ApiModelProperty(value = "18次电压谐波含有率越限次数")
+    private Integer uharm18Overtime;
+
+    /**
+     * 19次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_19_overtime")
+    @ApiModelProperty(value = "19次电压谐波含有率越限次数")
+    private Integer uharm19Overtime;
+
+    /**
+     * 20次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_20_overtime")
+    @ApiModelProperty(value = "20次电压谐波含有率越限次数")
+    private Integer uharm20Overtime;
+
+    /**
+     * 21次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_21_overtime")
+    @ApiModelProperty(value = "21次电压谐波含有率越限次数")
+    private Integer uharm21Overtime;
+
+    /**
+     * 22次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_22_overtime")
+    @ApiModelProperty(value = "22次电压谐波含有率越限次数")
+    private Integer uharm22Overtime;
+
+    /**
+     * 23次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_23_overtime")
+    @ApiModelProperty(value = "23次电压谐波含有率越限次数")
+    private Integer uharm23Overtime;
+
+    /**
+     * 24次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_24_overtime")
+    @ApiModelProperty(value = "24次电压谐波含有率越限次数")
+    private Integer uharm24Overtime;
+
+    /**
+     * 25次电压谐波含有率越限次数
+     */
+    @HarVoltage
+    @TableField(value = "uharm_25_overtime")
+    @ApiModelProperty(value = "25次电压谐波含有率越限次数")
+    private Integer uharm25Overtime;
+
+    /**
+     * 2次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_2_overtime")
+    @ApiModelProperty(value = "2次电流谐波幅值越限次数")
+    private Integer iharm2Overtime;
+
+    /**
+     * 3次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_3_overtime")
+    @ApiModelProperty(value = "3次电流谐波幅值越限次数")
+    private Integer iharm3Overtime;
+
+    /**
+     * 4次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_4_overtime")
+    @ApiModelProperty(value = "4次电流谐波幅值越限次数")
+    private Integer iharm4Overtime;
+
+    /**
+     * 5次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_5_overtime")
+    @ApiModelProperty(value = "5次电流谐波幅值越限次数")
+    private Integer iharm5Overtime;
+
+    /**
+     * 6次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_6_overtime")
+    @ApiModelProperty(value = "6次电流谐波幅值越限次数")
+    private Integer iharm6Overtime;
+
+    /**
+     * 7次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_7_overtime")
+    @ApiModelProperty(value = "7次电流谐波幅值越限次数")
+    private Integer iharm7Overtime;
+
+    /**
+     * 8次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_8_overtime")
+    @ApiModelProperty(value = "8次电流谐波幅值越限次数")
+    private Integer iharm8Overtime;
+
+    /**
+     * 9次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_9_overtime")
+    @ApiModelProperty(value = "9次电流谐波幅值越限次数")
+    private Integer iharm9Overtime;
+
+    /**
+     * 10次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_10_overtime")
+    @ApiModelProperty(value = "10次电流谐波幅值越限次数")
+    private Integer iharm10Overtime;
+
+    /**
+     * 11次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_11_overtime")
+    @ApiModelProperty(value = "11次电流谐波幅值越限次数")
+    private Integer iharm11Overtime;
+
+    /**
+     * 12次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_12_overtime")
+    @ApiModelProperty(value = "12次电流谐波幅值越限次数")
+    private Integer iharm12Overtime;
+
+    /**
+     * 13次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_13_overtime")
+    @ApiModelProperty(value = "13次电流谐波幅值越限次数")
+    private Integer iharm13Overtime;
+
+    /**
+     * 14次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_14_overtime")
+    @ApiModelProperty(value = "14次电流谐波幅值越限次数")
+    private Integer iharm14Overtime;
+
+    /**
+     * 15次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_15_overtime")
+    @ApiModelProperty(value = "15次电流谐波幅值越限次数")
+    private Integer iharm15Overtime;
+
+    /**
+     * 16次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_16_overtime")
+    @ApiModelProperty(value = "16次电流谐波幅值越限次数")
+    private Integer iharm16Overtime;
+
+    /**
+     * 17次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_17_overtime")
+    @ApiModelProperty(value = "17次电流谐波幅值越限次数")
+    private Integer iharm17Overtime;
+
+    /**
+     * 18次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_18_overtime")
+    @ApiModelProperty(value = "18次电流谐波幅值越限次数")
+    private Integer iharm18Overtime;
+
+    /**
+     * 19次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_19_overtime")
+    @ApiModelProperty(value = "19次电流谐波幅值越限次数")
+    private Integer iharm19Overtime;
+
+    /**
+     * 20次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_20_overtime")
+    @ApiModelProperty(value = "20次电流谐波幅值越限次数")
+    private Integer iharm20Overtime;
+
+    /**
+     * 21次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_21_overtime")
+    @ApiModelProperty(value = "21次电流谐波幅值越限次数")
+    private Integer iharm21Overtime;
+
+    /**
+     * 22次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_22_overtime")
+    @ApiModelProperty(value = "22次电流谐波幅值越限次数")
+    private Integer iharm22Overtime;
+
+    /**
+     * 23次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_23_overtime")
+    @ApiModelProperty(value = "23次电流谐波幅值越限次数")
+    private Integer iharm23Overtime;
+
+    /**
+     * 24次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_24_overtime")
+    @ApiModelProperty(value = "24次电流谐波幅值越限次数")
+    private Integer iharm24Overtime;
+
+    /**
+     * 25次电流谐波幅值越限次数
+     */
+    @HarCurrent
+    @TableField(value = "iharm_25_overtime")
+    @ApiModelProperty(value = "25次电流谐波幅值越限次数")
+    private Integer iharm25Overtime;
+
+    /**
+     * 0.5次间谐波电压限值次数
+     */
+    @TableField(value = "inuharm_1_overtime")
+    @InterharVoltage
+    @ApiModelProperty(value = "0.5次间谐波电压限值次数")
+    private Integer inuharm1Overtime;
+
+    /**
+     * 1.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_2_overtime")
+    @ApiModelProperty(value = "1.5次间谐波电压限值次数")
+    private Integer inuharm2Overtime;
+
+    /**
+     * 2.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_3_overtime")
+    @ApiModelProperty(value = "2.5次间谐波电压限值次数")
+    private Integer inuharm3Overtime;
+
+    /**
+     * 3.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_4_overtime")
+    @ApiModelProperty(value = "3.5次间谐波电压限值次数")
+    private Integer inuharm4Overtime;
+
+    /**
+     * 4.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_5_overtime")
+    @ApiModelProperty(value = "4.5次间谐波电压限值次数")
+    private Integer inuharm5Overtime;
+
+    /**
+     * 5.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_6_overtime")
+    @ApiModelProperty(value = "5.5次间谐波电压限值次数")
+    private Integer inuharm6Overtime;
+
+    /**
+     * 6.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_7_overtime")
+    @ApiModelProperty(value = "6.5次间谐波电压限值次数")
+    private Integer inuharm7Overtime;
+
+    /**
+     * 7.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_8_overtime")
+    @ApiModelProperty(value = "7.5次间谐波电压限值次数")
+    private Integer inuharm8Overtime;
+
+    /**
+     * 8.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_9_overtime")
+    @ApiModelProperty(value = "8.5次间谐波电压限值次数")
+    private Integer inuharm9Overtime;
+
+    /**
+     * 9.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_10_overtime")
+    @ApiModelProperty(value = "9.5次间谐波电压限值次数")
+    private Integer inuharm10Overtime;
+
+    /**
+     * 10.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_11_overtime")
+    @ApiModelProperty(value = "10.5次间谐波电压限值次数")
+    private Integer inuharm11Overtime;
+
+    /**
+     * 11.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_12_overtime")
+    @ApiModelProperty(value = "11.5次间谐波电压限值次数")
+    private Integer inuharm12Overtime;
+
+    /**
+     * 12.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_13_overtime")
+    @ApiModelProperty(value = "12.5次间谐波电压限值次数")
+    private Integer inuharm13Overtime;
+
+    /**
+     * 13.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_14_overtime")
+    @ApiModelProperty(value = "13.5次间谐波电压限值次数")
+    private Integer inuharm14Overtime;
+
+    /**
+     * 14.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_15_overtime")
+    @ApiModelProperty(value = "14.5次间谐波电压限值次数")
+    private Integer inuharm15Overtime;
+
+    /**
+     * 15.5次间谐波电压限值次数
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_16_overtime")
+    @ApiModelProperty(value = "15.5次间谐波电压限值次数")
+    private Integer inuharm16Overtime;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/po/RStatLimitRateDetailDPO.java

@@ -0,0 +1,594 @@
+package com.njcn.csharmonic.pojo.po;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.github.jeffreyning.mybatisplus.anno.MppMultiId;
+import com.njcn.csharmonic.annotaion.HarCurrent;
+import com.njcn.csharmonic.annotaion.HarVoltage;
+import com.njcn.csharmonic.annotaion.InterharVoltage;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDate;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+@TableName(value = "r_stat_limit_rate_detail_d")
+public class RStatLimitRateDetailDPO {
+
+    /**
+     * 合格率时间
+     */
+    @MppMultiId
+    @TableField(value = "time_id")
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+    @ApiModelProperty(value = "合格率时间")
+    private LocalDate time;
+
+    /**
+     * 监测点ID合格率的变电站/装置/母线/线路序号
+     */
+    @MppMultiId
+    @TableField(value = "my_index")
+    @ApiModelProperty(value = "监测点ID合格率的变电站/装置/母线/线路序号")
+    private String lineId;
+
+
+    /**
+     * 频率偏差越限数据
+     */
+    @TableField(value = "freq_dev_overtime")
+    @ApiModelProperty(value = "频率偏差越限数据")
+    private String freqDevOvertime;
+
+    /**
+     * 电压偏差越限数据
+     */
+    @TableField(value = "voltage_dev_overtime")
+    @ApiModelProperty(value = "电压偏差越限数据")
+    private String voltageDevOvertime;
+
+    /**
+     * 三相电压不平衡度越限数据
+     */
+    @TableField(value = "ubalance_overtime")
+    @ApiModelProperty(value = "三相电压不平衡度越限数据")
+    private String ubalanceOvertime;
+    /**
+     * 闪变越限数据
+     */
+    @TableField(value = "flicker_overtime")
+    @ApiModelProperty(value = "闪变越限数据")
+    private String flickerOvertime;
+
+
+    /**
+     * 电压谐波畸变率越限数据
+     */
+    @TableField(value = "uaberrance_overtime")
+    @ApiModelProperty(value = "电压谐波畸变率越限数据")
+    private String uaberranceOvertime;
+
+    /**
+     * 负序电流限值数据
+     */
+    @TableField(value = "i_neg_overtime")
+    @ApiModelProperty(value = "负序电流限值数据")
+    private String iNegOvertime;
+
+    /**
+     * 2次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_2_overtime")
+    @ApiModelProperty(value = "2次电压谐波含有率越限数据")
+    private String uharm2Overtime;
+
+    /**
+     * 3次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_3_overtime")
+    @ApiModelProperty(value = "3次电压谐波含有率越限数据")
+    private String uharm3Overtime;
+
+    /**
+     * 4次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_4_overtime")
+    @ApiModelProperty(value = "4次电压谐波含有率越限数据")
+    private String uharm4Overtime;
+
+    /**
+     * 5次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_5_overtime")
+    @ApiModelProperty(value = "5次电压谐波含有率越限数据")
+    private String uharm5Overtime;
+
+    /**
+     * 6次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_6_overtime")
+    @ApiModelProperty(value = "6次电压谐波含有率越限数据")
+    private String uharm6Overtime;
+
+    /**
+     * 7次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_7_overtime")
+    @ApiModelProperty(value = "7次电压谐波含有率越限数据")
+    private String uharm7Overtime;
+
+    /**
+     * 8次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_8_overtime")
+    @ApiModelProperty(value = "8次电压谐波含有率越限数据")
+    private String uharm8Overtime;
+
+    /**
+     * 9次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_9_overtime")
+    @ApiModelProperty(value = "9次电压谐波含有率越限数据")
+    private String uharm9Overtime;
+
+    /**
+     * 10次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_10_overtime")
+    @ApiModelProperty(value = "10次电压谐波含有率越限数据")
+    private String uharm10Overtime;
+
+    /**
+     * 11次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_11_overtime")
+    @ApiModelProperty(value = "11次电压谐波含有率越限数据")
+    private String uharm11Overtime;
+
+    /**
+     * 12次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_12_overtime")
+    @ApiModelProperty(value = "12次电压谐波含有率越限数据")
+    private String uharm12Overtime;
+
+    /**
+     * 13次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_13_overtime")
+    @ApiModelProperty(value = "13次电压谐波含有率越限数据")
+    private String uharm13Overtime;
+
+    /**
+     * 14次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_14_overtime")
+    @ApiModelProperty(value = "14次电压谐波含有率越限数据")
+    private String uharm14Overtime;
+
+    /**
+     * 15次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_15_overtime")
+    @ApiModelProperty(value = "15次电压谐波含有率越限数据")
+    private String uharm15Overtime;
+
+    /**
+     * 16次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_16_overtime")
+    @ApiModelProperty(value = "16次电压谐波含有率越限数据")
+    private String uharm16Overtime;
+
+    /**
+     * 17次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_17_overtime")
+    @ApiModelProperty(value = "17次电压谐波含有率越限数据")
+    private String uharm17Overtime;
+
+    /**
+     * 18次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_18_overtime")
+    @ApiModelProperty(value = "18次电压谐波含有率越限数据")
+    private String uharm18Overtime;
+
+    /**
+     * 19次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_19_overtime")
+    @ApiModelProperty(value = "19次电压谐波含有率越限数据")
+    private String uharm19Overtime;
+
+    /**
+     * 20次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_20_overtime")
+    @ApiModelProperty(value = "20次电压谐波含有率越限数据")
+    private String uharm20Overtime;
+
+    /**
+     * 21次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_21_overtime")
+    @ApiModelProperty(value = "21次电压谐波含有率越限数据")
+    private String uharm21Overtime;
+
+    /**
+     * 22次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_22_overtime")
+    @ApiModelProperty(value = "22次电压谐波含有率越限数据")
+    private String uharm22Overtime;
+
+    /**
+     * 23次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_23_overtime")
+    @ApiModelProperty(value = "23次电压谐波含有率越限数据")
+    private String uharm23Overtime;
+
+    /**
+     * 24次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_24_overtime")
+    @ApiModelProperty(value = "24次电压谐波含有率越限数据")
+    private String uharm24Overtime;
+
+    /**
+     * 25次电压谐波含有率越限数据
+     */
+    @HarVoltage
+    @TableField(value = "uharm_25_overtime")
+    @ApiModelProperty(value = "25次电压谐波含有率越限数据")
+    private String uharm25Overtime;
+
+    /**
+     * 2次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_2_overtime")
+    @ApiModelProperty(value = "2次电流谐波幅值越限数据")
+    private String iharm2Overtime;
+
+    /**
+     * 3次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_3_overtime")
+    @ApiModelProperty(value = "3次电流谐波幅值越限数据")
+    private String iharm3Overtime;
+
+    /**
+     * 4次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_4_overtime")
+    @ApiModelProperty(value = "4次电流谐波幅值越限数据")
+    private String iharm4Overtime;
+
+    /**
+     * 5次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_5_overtime")
+    @ApiModelProperty(value = "5次电流谐波幅值越限数据")
+    private String iharm5Overtime;
+
+    /**
+     * 6次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_6_overtime")
+    @ApiModelProperty(value = "6次电流谐波幅值越限数据")
+    private String iharm6Overtime;
+
+    /**
+     * 7次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_7_overtime")
+    @ApiModelProperty(value = "7次电流谐波幅值越限数据")
+    private String iharm7Overtime;
+
+    /**
+     * 8次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_8_overtime")
+    @ApiModelProperty(value = "8次电流谐波幅值越限数据")
+    private String iharm8Overtime;
+
+    /**
+     * 9次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_9_overtime")
+    @ApiModelProperty(value = "9次电流谐波幅值越限数据")
+    private String iharm9Overtime;
+
+    /**
+     * 10次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_10_overtime")
+    @ApiModelProperty(value = "10次电流谐波幅值越限数据")
+    private String iharm10Overtime;
+
+    /**
+     * 11次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_11_overtime")
+    @ApiModelProperty(value = "11次电流谐波幅值越限数据")
+    private String iharm11Overtime;
+
+    /**
+     * 12次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_12_overtime")
+    @ApiModelProperty(value = "12次电流谐波幅值越限数据")
+    private String iharm12Overtime;
+
+    /**
+     * 13次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_13_overtime")
+    @ApiModelProperty(value = "13次电流谐波幅值越限数据")
+    private String iharm13Overtime;
+
+    /**
+     * 14次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_14_overtime")
+    @ApiModelProperty(value = "14次电流谐波幅值越限数据")
+    private String iharm14Overtime;
+
+    /**
+     * 15次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_15_overtime")
+    @ApiModelProperty(value = "15次电流谐波幅值越限数据")
+    private String iharm15Overtime;
+
+    /**
+     * 16次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_16_overtime")
+    @ApiModelProperty(value = "16次电流谐波幅值越限数据")
+    private String iharm16Overtime;
+
+    /**
+     * 17次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_17_overtime")
+    @ApiModelProperty(value = "17次电流谐波幅值越限数据")
+    private String iharm17Overtime;
+
+    /**
+     * 18次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_18_overtime")
+    @ApiModelProperty(value = "18次电流谐波幅值越限数据")
+    private String iharm18Overtime;
+
+    /**
+     * 19次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_19_overtime")
+    @ApiModelProperty(value = "19次电流谐波幅值越限数据")
+    private String iharm19Overtime;
+
+    /**
+     * 20次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_20_overtime")
+    @ApiModelProperty(value = "20次电流谐波幅值越限数据")
+    private String iharm20Overtime;
+
+    /**
+     * 21次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_21_overtime")
+    @ApiModelProperty(value = "21次电流谐波幅值越限数据")
+    private String iharm21Overtime;
+
+    /**
+     * 22次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_22_overtime")
+    @ApiModelProperty(value = "22次电流谐波幅值越限数据")
+    private String iharm22Overtime;
+
+    /**
+     * 23次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_23_overtime")
+    @ApiModelProperty(value = "23次电流谐波幅值越限数据")
+    private String iharm23Overtime;
+
+    /**
+     * 24次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_24_overtime")
+    @ApiModelProperty(value = "24次电流谐波幅值越限数据")
+    private String iharm24Overtime;
+
+    /**
+     * 25次电流谐波幅值越限数据
+     */
+    @HarCurrent
+    @TableField(value = "iharm_25_overtime")
+    @ApiModelProperty(value = "25次电流谐波幅值越限数据")
+    private String iharm25Overtime;
+
+    /**
+     * 0.5次间谐波电压限值数据
+     */
+    @TableField(value = "inuharm_1_overtime")
+    @InterharVoltage
+    @ApiModelProperty(value = "0.5次间谐波电压限值数据")
+    private String inuharm1Overtime;
+
+    /**
+     * 1.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_2_overtime")
+    @ApiModelProperty(value = "1.5次间谐波电压限值数据")
+    private String inuharm2Overtime;
+
+    /**
+     * 2.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_3_overtime")
+    @ApiModelProperty(value = "2.5次间谐波电压限值数据")
+    private String inuharm3Overtime;
+
+    /**
+     * 3.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_4_overtime")
+    @ApiModelProperty(value = "3.5次间谐波电压限值数据")
+    private String inuharm4Overtime;
+
+    /**
+     * 4.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_5_overtime")
+    @ApiModelProperty(value = "4.5次间谐波电压限值数据")
+    private String inuharm5Overtime;
+
+    /**
+     * 5.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_6_overtime")
+    @ApiModelProperty(value = "5.5次间谐波电压限值数据")
+    private String inuharm6Overtime;
+
+    /**
+     * 6.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_7_overtime")
+    @ApiModelProperty(value = "6.5次间谐波电压限值数据")
+    private String inuharm7Overtime;
+
+    /**
+     * 7.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_8_overtime")
+    @ApiModelProperty(value = "7.5次间谐波电压限值数据")
+    private String inuharm8Overtime;
+
+    /**
+     * 8.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_9_overtime")
+    @ApiModelProperty(value = "8.5次间谐波电压限值数据")
+    private String inuharm9Overtime;
+
+    /**
+     * 9.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_10_overtime")
+    @ApiModelProperty(value = "9.5次间谐波电压限值数据")
+    private String inuharm10Overtime;
+
+    /**
+     * 10.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_11_overtime")
+    @ApiModelProperty(value = "10.5次间谐波电压限值数据")
+    private String inuharm11Overtime;
+
+    /**
+     * 11.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_12_overtime")
+    @ApiModelProperty(value = "11.5次间谐波电压限值数据")
+    private String inuharm12Overtime;
+
+    /**
+     * 12.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_13_overtime")
+    @ApiModelProperty(value = "12.5次间谐波电压限值数据")
+    private String inuharm13Overtime;
+
+    /**
+     * 13.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_14_overtime")
+    @ApiModelProperty(value = "13.5次间谐波电压限值数据")
+    private String inuharm14Overtime;
+
+    /**
+     * 14.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_15_overtime")
+    @ApiModelProperty(value = "14.5次间谐波电压限值数据")
+    private String inuharm15Overtime;
+
+    /**
+     * 15.5次间谐波电压限值数据
+     */
+    @InterharVoltage
+    @TableField(value = "inuharm_16_overtime")
+    @ApiModelProperty(value = "15.5次间谐波电压限值数据")
+    private String inuharm16Overtime;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitCalendarVO.java

@@ -0,0 +1,23 @@
+package com.njcn.csharmonic.pojo.vo;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.time.LocalDate;
+import java.util.List;
+
+@Data
+public class LimitCalendarVO {
+    @ApiModelProperty("发生日期")
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+    private LocalDate time;
+
+    @ApiModelProperty("越限项")
+    private List<String> items;
+    
+    @ApiModelProperty("越限程度， 0:无  1:一般（超过限值80%以下）2:严重（超过限值80%以上）")
+    private int status;
+
+
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitExtentVO.java

@@ -0,0 +1,49 @@
+package com.njcn.csharmonic.pojo.vo;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.time.LocalDate;
+
+@Data
+public class LimitExtentVO {
+
+    @ApiModelProperty("指标编码")
+    private String code;
+    @ApiModelProperty("指标名称")
+    private String name;
+
+    @ApiModelProperty("越限最大值")
+    private float maxValue;
+
+    @ApiModelProperty("国际限值")
+    private float internationalValue;
+
+    @ApiModelProperty("越限程度")
+    private float extent;
+
+    @ApiModelProperty("发生日期")
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+    private LocalDate time;
+
+    @ApiModelProperty(value = "监测点ID合格率的变电站/装置/母线/线路序号")
+    private String lineId;
+    @ApiModelProperty("监测点名称")
+    private String lineName;
+
+
+    public float getExtent() {
+        if (internationalValue == 0) {
+            return 0.00F;
+        }
+        if (maxValue == 0) {
+            return 0.00F;
+        }
+        if (maxValue < internationalValue) {
+            return 0.00F;
+        }
+        return (maxValue - internationalValue) / internationalValue * 100;
+    }
+
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitProbabilityVO.java

@@ -0,0 +1,22 @@
+package com.njcn.csharmonic.pojo.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+@Data
+public class LimitProbabilityVO {
+
+    @ApiModelProperty("监测点id")
+    private String lineId;
+    @ApiModelProperty("监测点名称")
+    private String lineName;
+    @ApiModelProperty("指标名称")
+    private String indexName;
+    @ApiModelProperty("指标编码")
+    private String indexCode;
+    @ApiModelProperty("越限程度档级对应次数")
+    private List<Map<Integer, Integer>> extentGrades;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/LimitTimeProbabilityVO.java

@@ -0,0 +1,21 @@
+package com.njcn.csharmonic.pojo.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+@Data
+public class LimitTimeProbabilityVO {
+
+    @ApiModelProperty("时间段")
+    private String timePeriod;
+    @ApiModelProperty("次数")
+    private int times;
+    @ApiModelProperty("监测点id")
+    private String lineId;
+    @ApiModelProperty("监测点名称")
+    private String lineName;
+    @ApiModelProperty("指标名称")
+    private String indexName;
+    @ApiModelProperty("指标编码")
+    private String indexCode;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MainLineStatLimitRateDetailsVO.java

@@ -0,0 +1,11 @@
+package com.njcn.csharmonic.pojo.vo;
+
+import com.njcn.csharmonic.pojo.po.RStatLimitRateDPO;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+@Data
+public class MainLineStatLimitRateDetailsVO extends RStatLimitRateDPO {
+    @ApiModelProperty("监测点名称")
+    private String lineName;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MainLineVO.java

@@ -0,0 +1,21 @@
+package com.njcn.csharmonic.pojo.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.io.Serializable;
+
+
+@Data
+public class MainLineVO implements Serializable {
+    @ApiModelProperty("监测点ID")
+    private String lineId;
+    @ApiModelProperty("监测点名称")
+    private String lineName;
+    @ApiModelProperty("监测对象类型")
+    private String objType;
+    @ApiModelProperty("是否治理")
+    private String govern;
+    @ApiModelProperty("主要存在的电能质量问题")
+    private String problems;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MonitorOverLimitVO.java

@@ -0,0 +1,145 @@
+package com.njcn.csharmonic.pojo.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+/**
+ * 类的介绍：
+ *
+ * @author xuyang
+ * @version 1.0.0
+ * @createTime 2022/5/9 11:23
+ */
+@Data
+public class MonitorOverLimitVO {
+
+    @ApiModelProperty("监测点id")
+    private String id;
+
+    @ApiModelProperty("省公司")
+    private String provinceCompany;
+
+    @ApiModelProperty("地市公司")
+    private String cityCompany;
+
+    @ApiModelProperty("监测点名称")
+    private String lineName;
+
+    @ApiModelProperty("干扰源类型")
+    private String loadType;
+
+    @ApiModelProperty("监测点对象名称")
+    private String lineObjectName;
+
+    @ApiModelProperty("监测点电压等级")
+    private String lineScale;
+
+    @ApiModelProperty("厂家")
+    private String manufacturer;
+
+    @ApiModelProperty("变电站名称")
+    private String subName;
+
+    @ApiModelProperty("变电站电压等级")
+    private String subScale;
+
+    @ApiModelProperty("超标天数")
+    private Integer overDay;
+
+    @ApiModelProperty("频率偏差超标天数")
+    private Integer freqOverDay;
+
+    @ApiModelProperty("电压偏差超标天数")
+    private Integer volDevOverDay;
+
+    @ApiModelProperty("谐波电压超标天数")
+    private Integer harmVolOverDay;
+
+    @ApiModelProperty("电压总谐波畸变率超标天数")
+    private Integer volDisOverDay;
+    @ApiModelProperty("谐波电压含有率超标天数")
+    private Integer volContainOverDay;
+    @ApiModelProperty("谐波电流超标天数")
+    private Integer harmCurOverDay;
+
+    /**
+     *各次谐波电压含有率
+     */
+    @ApiModelProperty("3次")
+    private Integer overVolThreeTimes;
+
+    @ApiModelProperty("5次")
+    private Integer overVolFiveTimes;
+
+    @ApiModelProperty("7次")
+    private Integer overVolSevenTimes;
+
+    @ApiModelProperty("11次")
+    private Integer overVolElevenTimes;
+
+    @ApiModelProperty("13次")
+    private Integer overVolThirteenTimes;
+
+    @ApiModelProperty("23次")
+    private Integer overVolTwentyThreeTimes;
+
+    @ApiModelProperty("25次")
+    private Integer overVolTwentyFiveTimes;
+
+    @ApiModelProperty("其他次")
+    private Integer overVolOtherTimes;
+
+    /**
+     *各次谐波电流含量
+     */
+    @ApiModelProperty("3次")
+    private Integer overCurThreeTimes;
+
+    @ApiModelProperty("5次")
+    private Integer overCurFiveTimes;
+
+    @ApiModelProperty("7次")
+    private Integer overCurSevenTimes;
+
+    @ApiModelProperty("11次")
+    private Integer overCurElevenTimes;
+
+    @ApiModelProperty("13次")
+    private Integer overCurThirteenTimes;
+
+    @ApiModelProperty("23次")
+    private Integer overCurTwentyThreeTimes;
+
+    @ApiModelProperty("25次")
+    private Integer overCurTwentyFiveTimes;
+
+    @ApiModelProperty("其他次")
+    private Integer overCurOtherTimes;
+
+    @ApiModelProperty("间谐波电压含有率超标天数")
+    private Integer intHarmOverDay;
+
+    @ApiModelProperty("三相电压不平衡度超标天数")
+    private Integer threeUnbalance;
+
+    @ApiModelProperty("负序电流超标天数")
+    private Integer negativeOverDay;
+
+    @ApiModelProperty("闪变超标天数")
+    private Integer flickerOverDay;
+
+    @ApiModelProperty("监测点编号")
+    private String monitorNumber;
+
+    @Data
+    public static class DataVO {
+        private static final long serialVersionUID = 1L;
+
+        @ApiModelProperty("日期")
+        private String time;
+
+        @ApiModelProperty("数据")
+        private Double data;
+
+    }
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/RStatLimitRateDVO.java

@@ -0,0 +1,34 @@
+package com.njcn.csharmonic.pojo.vo;
+
+import lombok.Data;
+
+/**
+ * <功能描述>
+ *
+ * @author wr
+ * @createTime: 2023-04-03
+ */
+@Data
+public class RStatLimitRateDVO {
+    private static final long serialVersionUID = 1L;
+
+    private Integer alltime;
+
+    private Integer frequency;
+
+    private Integer uBalance;
+
+    private Integer iNeg;
+
+    private Integer harmElec;
+
+    private Integer harmVoltage;
+
+    private Integer flicker;
+
+    private Integer allFlicker;
+
+    private Integer voltageDeviation;
+
+    private Integer inUharm;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java

@@ -0,0 +1,207 @@
+package com.njcn.csharmonic.pojo.vo;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.time.LocalDate;
+
+@Data
+public class TotalLimitStatisticsDetailsVO {
+    @ApiModelProperty("监测点名称")
+    private String lineName;
+
+    @ApiModelProperty(value = "监测点ID合格率的变电站/装置/母线/线路序号")
+    private String lineId;
+
+    @JsonFormat(pattern = "yyyy-MM-dd", timezone = "GMT+8")
+    @ApiModelProperty(value = "合格率时间")
+    private LocalDate time;
+
+    @ApiModelProperty(value = "总计算次数")
+    private Integer allTime;
+
+    @ApiModelProperty(value = "闪变越限次数")
+    private Integer flickerOvertime;
+
+
+    @ApiModelProperty(value = "频率偏差越限")
+    private double freqDevOvertime;
+
+    @ApiModelProperty(value = "电压偏差越限")
+    private double voltageDevOvertime;
+
+    @ApiModelProperty(value = "三相电压不平衡度越限")
+    private double ubalanceOvertime;
+
+    @ApiModelProperty(value = "电压谐波畸变率越限")
+    private double uaberranceOvertime;
+
+    @ApiModelProperty(value = "负序电流限值")
+    private double iNegOvertime;
+
+    @ApiModelProperty(value = "2次电压谐波含有率越限")
+    private double uharm2Overtime;
+
+    @ApiModelProperty(value = "3次电压谐波含有率越限")
+    private double uharm3Overtime;
+
+    @ApiModelProperty(value = "4次电压谐波含有率越限")
+    private double uharm4Overtime;
+
+    @ApiModelProperty(value = "5次电压谐波含有率越限")
+    private double uharm5Overtime;
+
+    @ApiModelProperty(value = "6次电压谐波含有率越限")
+    private double uharm6Overtime;
+
+    @ApiModelProperty(value = "7次电压谐波含有率越限")
+    private double uharm7Overtime;
+
+    @ApiModelProperty(value = "8次电压谐波含有率越限")
+    private double uharm8Overtime;
+
+    @ApiModelProperty(value = "9次电压谐波含有率越限")
+    private double uharm9Overtime;
+
+    @ApiModelProperty(value = "10次电压谐波含有率越限")
+    private double uharm10Overtime;
+
+    @ApiModelProperty(value = "11次电压谐波含有率越限")
+    private double uharm11Overtime;
+
+    @ApiModelProperty(value = "12次电压谐波含有率越限")
+    private double uharm12Overtime;
+
+    @ApiModelProperty(value = "13次电压谐波含有率越限")
+    private double uharm13Overtime;
+
+    @ApiModelProperty(value = "14次电压谐波含有率越限")
+    private double uharm14Overtime;
+
+    @ApiModelProperty(value = "15次电压谐波含有率越限")
+    private double uharm15Overtime;
+
+    @ApiModelProperty(value = "16次电压谐波含有率越限")
+    private double uharm16Overtime;
+
+    @ApiModelProperty(value = "17次电压谐波含有率越限")
+    private double uharm17Overtime;
+
+
+    @ApiModelProperty(value = "18次电压谐波含有率越限")
+    private double uharm18Overtime;
+
+
+    @ApiModelProperty(value = "19次电压谐波含有率越限")
+    private double uharm19Overtime;
+
+
+    @ApiModelProperty(value = "20次电压谐波含有率越限")
+    private double uharm20Overtime;
+
+
+    @ApiModelProperty(value = "21次电压谐波含有率越限")
+    private double uharm21Overtime;
+
+    @ApiModelProperty(value = "22次电压谐波含有率越限")
+    private double uharm22Overtime;
+
+
+    @ApiModelProperty(value = "23次电压谐波含有率越限")
+    private double uharm23Overtime;
+
+    @ApiModelProperty(value = "24次电压谐波含有率越限")
+    private double uharm24Overtime;
+
+    @ApiModelProperty(value = "25次电压谐波含有率越限")
+    private double uharm25Overtime;
+
+    @ApiModelProperty(value = "2次电流谐波幅值越限")
+    private double iharm2Overtime;
+
+    @ApiModelProperty(value = "3次电流谐波幅值越限")
+    private double iharm3Overtime;
+
+    @ApiModelProperty(value = "4次电流谐波幅值越限")
+    private double iharm4Overtime;
+
+
+    @ApiModelProperty(value = "5次电流谐波幅值越限")
+    private double iharm5Overtime;
+
+
+    @ApiModelProperty(value = "6次电流谐波幅值越限")
+    private double iharm6Overtime;
+
+    @ApiModelProperty(value = "7次电流谐波幅值越限")
+    private double iharm7Overtime;
+
+    @ApiModelProperty(value = "8次电流谐波幅值越限")
+    private double iharm8Overtime;
+
+    @ApiModelProperty(value = "9次电流谐波幅值越限")
+    private double iharm9Overtime;
+
+    @ApiModelProperty(value = "10次电流谐波幅值越限")
+    private double iharm10Overtime;
+
+
+    @ApiModelProperty(value = "11次电流谐波幅值越限")
+    private double iharm11Overtime;
+
+
+    @ApiModelProperty(value = "12次电流谐波幅值越限")
+    private double iharm12Overtime;
+
+
+    @ApiModelProperty(value = "13次电流谐波幅值越限")
+    private double iharm13Overtime;
+
+
+    @ApiModelProperty(value = "14次电流谐波幅值越限")
+    private double iharm14Overtime;
+
+
+    @ApiModelProperty(value = "15次电流谐波幅值越限")
+    private double iharm15Overtime;
+
+
+    @ApiModelProperty(value = "16次电流谐波幅值越限")
+    private double iharm16Overtime;
+
+
+    @ApiModelProperty(value = "17次电流谐波幅值越限")
+    private double iharm17Overtime;
+
+
+    @ApiModelProperty(value = "18次电流谐波幅值越限")
+    private double iharm18Overtime;
+
+
+    @ApiModelProperty(value = "19次电流谐波幅值越限")
+    private double iharm19Overtime;
+
+
+    @ApiModelProperty(value = "20次电流谐波幅值越限")
+    private double iharm20Overtime;
+
+
+    @ApiModelProperty(value = "21次电流谐波幅值越限")
+    private double iharm21Overtime;
+
+
+    @ApiModelProperty(value = "22次电流谐波幅值越限")
+    private double iharm22Overtime;
+
+
+    @ApiModelProperty(value = "23次电流谐波幅值越限")
+    private double iharm23Overtime;
+
+
+    @ApiModelProperty(value = "24次电流谐波幅值越限")
+    private double iharm24Overtime;
+
+    @ApiModelProperty(value = "25次电流谐波幅值越限")
+    private double iharm25Overtime;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitStatisticsVO.java

@@ -0,0 +1,15 @@
+package com.njcn.csharmonic.pojo.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class TotalLimitStatisticsVO extends TotalLimitTotalStatisticsVO {
+
+    @ApiModelProperty("监测点ID")
+    private String lineId;
+    @ApiModelProperty("监测点名称")
+    private String lineName;
+}

cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitTotalStatisticsVO.java

@@ -0,0 +1,19 @@
+package com.njcn.csharmonic.pojo.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+@Data
+public class TotalLimitTotalStatisticsVO {
+
+    @ApiModelProperty("闪变越限占比")
+    private double flicker;
+    @ApiModelProperty("谐波电压越限占比")
+    private double uharm;
+    @ApiModelProperty("谐波电流越限占比")
+    private double iharm;
+    @ApiModelProperty("电压偏差越限占比")
+    private double voltageDev;
+    @ApiModelProperty("三相不平衡越限占比")
+    private double ubalance;
+}

cs-harmonic/cs-harmonic-boot/pom.xml

@@ -135,11 +135,6 @@
             <artifactId>message-api</artifactId>
             <version>1.0.0</version>
         </dependency>
-        <dependency>
-            <groupId>com.njcn</groupId>
-            <artifactId>harmonic-common</artifactId>
-            <version>1.0.0</version>
-        </dependency>
     </dependencies>
 
     <build>

cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/controller/RStatLimitRateDController.java

@@ -0,0 +1,159 @@
+package com.njcn.csharmonic.controller;
+
+
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.enums.common.LogEnum;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.common.utils.HttpResultUtil;
+import com.njcn.csharmonic.pojo.param.*;
+import com.njcn.csharmonic.pojo.po.RStatLimitRateDPO;
+import com.njcn.csharmonic.pojo.vo.*;
+import com.njcn.csharmonic.service.IRStatLimitRateDService;
+import com.njcn.web.controller.BaseController;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiImplicitParams;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@Validated
+@RestController
+@RequiredArgsConstructor
+@Api(tags = "合格率统计日表(越限次数)")
+public class RStatLimitRateDController extends BaseController {
+
+    private final IRStatLimitRateDService limitRateDService;
+
+    /**
+     * 来源于RStatLimitController的monitorIdsGetLimitRateInfo
+     */
+    @PostMapping("/limitRateD/monitorIdsGetLimitRateInfo")
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @ApiOperation("获取指定日期超标监测点详细信息")
+    public HttpResult<List<RStatLimitRateDPO>> monitorIdsGetLimitRateInfo(@RequestBody RStatLimitQueryParam rStatLimitQueryParam) {
+        String methodDescribe = getMethodDescribe("monitorIdsGetLimitRateInfo");
+        List<RStatLimitRateDPO> result = limitRateDService.monitorIdsGetLimitRateInfo(rStatLimitQueryParam.getDate(), rStatLimitQueryParam.getIds());
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
+    }
+
+    /**
+     * 来源于RStatLimitController的getOverData
+     */
+    @PostMapping("/getOverData")
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @ApiOperation("查询单监测点超标数据")
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "lineId", value = "监测点id"),
+            @ApiImplicitParam(name = "startTime", value = "开始时间"),
+            @ApiImplicitParam(name = "endTime", value = "结束时间"),
+            @ApiImplicitParam(name = "type", value = "指标"),
+    })
+    public HttpResult<List<RStatLimitRateDPO>> getOverData(@RequestParam("lineId") String lineId, @RequestParam("startTime") String startTime, @RequestParam("endTime") String endTime, @RequestParam("type") Integer type) {
+        String methodDescribe = getMethodDescribe("getOverData");
+        List<RStatLimitRateDPO> result = limitRateDService.getOverData(lineId, startTime, endTime, type);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
+    }
+
+
+    /**
+     * 来源于 HistoryResultController的getLinesRate
+     */
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/harmonic/getLinesRate")
+    @ApiOperation("获取越线监测点越线次数")
+    @ApiImplicitParam(name = "param", value = "获取越线监测点越线次数请求参数", required = true)
+    public HttpResult<List<RStatLimitRateDPO>> getLinesRate(@RequestBody StatSubstationBizBaseParam param) {
+        String methodDescribe = getMethodDescribe("getLinesTarget");
+        List<RStatLimitRateDPO> list = limitRateDService.list(new LambdaQueryWrapper<RStatLimitRateDPO>()
+                .in(RStatLimitRateDPO::getLineId, param.getIds())
+                .eq(RStatLimitRateDPO::getPhasicType, "T")
+                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatLimitRateDPO::getTime, param.getStartTime())
+                .le(StrUtil.isNotBlank(param.getEndTime()), RStatLimitRateDPO::getTime, param.getEndTime())
+
+        );
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe);
+    }
+
+    @PostMapping("/mainLine/list")
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @ApiOperation("获取主要监测点列表")
+    public HttpResult<Page<MainLineVO>> mainLineList(@RequestBody MainLineQueryParam mainLineQueryParam) {
+        String methodDescribe = getMethodDescribe("mainLineList");
+        Page<MainLineVO> list = limitRateDService.mainLineList(mainLineQueryParam);
+
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe);
+    }
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/mainLine/statLimitRateDetails")
+    @ApiOperation("监测点指标越限详情")
+    @ApiImplicitParam(name = "param", value = "获取监测点指标越限详情请求参数", required = true)
+    public HttpResult<List<MainLineStatLimitRateDetailsVO>> mainLineStatLimitRateDetails(@RequestBody MainLineStatLimitRateDetailsQueryParam param) {
+        String methodDescribe = getMethodDescribe("mainLineStatLimitRateDetails");
+        List<MainLineStatLimitRateDetailsVO> list = limitRateDService.mainLineStatLimitRateDetails(param);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe);
+    }
+
+
+    @PostMapping("/totalLimitStatistics/data")
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @ApiOperation("总体指标越限统计数据")
+    public HttpResult<TotalLimitTotalStatisticsVO> totalLimitTotalStatisticsData(@RequestBody TotalLimitStatisticsParam mainLineQueryParam) {
+        String methodDescribe = getMethodDescribe("totalLimitStatisticsList");
+        TotalLimitTotalStatisticsVO data = limitRateDService.totalLimitTotalStatisticsData(mainLineQueryParam);
+
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, data, methodDescribe);
+    }
+
+    @PostMapping("/totalLimitStatistics/list")
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @ApiOperation("总体指标越限统计列表")
+    public HttpResult<List<TotalLimitStatisticsVO>> totalLimitStatisticsList(@RequestBody TotalLimitStatisticsParam mainLineQueryParam) {
+        String methodDescribe = getMethodDescribe("totalLimitStatisticsList");
+        List<TotalLimitStatisticsVO> list = limitRateDService.totalLimitStatisticsList(mainLineQueryParam);
+
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe);
+    }
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @PostMapping("/totalLimitStatistics/details")
+    @ApiOperation("每日越限占比统计")
+    @ApiImplicitParam(name = "param", value = "每日越限占比统计请求参数", required = true)
+    public HttpResult<List<TotalLimitStatisticsDetailsVO>> totalLimitStatisticsDetails(@RequestBody TotalLimitStatisticsDetailsQueryParam param) {
+        String methodDescribe = getMethodDescribe("totalLimitStatisticsDetails");
+        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);
+    }
+}

cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/controller/RStatLimitRateDetailDController.java

@@ -0,0 +1,85 @@
+package com.njcn.csharmonic.controller;
+
+
+import cn.hutool.json.JSONArray;
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.enums.common.LogEnum;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.common.utils.HttpResultUtil;
+import com.njcn.csharmonic.pojo.param.LimitCalendarQueryParam;
+import com.njcn.csharmonic.pojo.param.LimitExtentDayQueryParam;
+import com.njcn.csharmonic.pojo.param.LimitExtentQueryParam;
+import com.njcn.csharmonic.pojo.param.LimitProbabilityQueryParam;
+import com.njcn.csharmonic.pojo.vo.LimitCalendarVO;
+import com.njcn.csharmonic.pojo.vo.LimitExtentVO;
+import com.njcn.csharmonic.pojo.vo.LimitProbabilityVO;
+import com.njcn.csharmonic.pojo.vo.LimitTimeProbabilityVO;
+import com.njcn.csharmonic.service.IRStatLimitRateDetailDService;
+import com.njcn.web.controller.BaseController;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@Validated
+@RestController
+@RequiredArgsConstructor
+@Api(tags = "合格率统计日表详细(越限详情)")
+public class RStatLimitRateDetailDController extends BaseController {
+
+    private final IRStatLimitRateDetailDService limitRateDetailDService;
+
+    @PostMapping("/limitRateDetailD/limitExtentData")
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @ApiOperation("获取指标越限程度数据")
+    public HttpResult<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);
+    }
+
+
+}

cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/RStatLimitRateDMapper.java

@@ -0,0 +1,76 @@
+package com.njcn.csharmonic.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.njcn.csharmonic.pojo.po.RStatLimitRateDPO;
+import com.njcn.csharmonic.pojo.vo.MonitorOverLimitVO;
+import com.njcn.csharmonic.pojo.vo.RStatLimitRateDVO;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 合格率统计日表(越限次数) Mapper 接口
+ * </p>
+ *
+ * @author wr
+ * @since 2023-04-03
+ */
+public interface RStatLimitRateDMapper extends BaseMapper<RStatLimitRateDPO> {
+
+    List<RStatLimitRateDVO> getSumPassRate(
+            @Param("ids") List<String> lineIndexes,
+            @Param("statTime") String searchBeginTime,
+            @Param("endTime") String searchEndTime);
+
+
+    List<MonitorOverLimitVO> getSumLimitRateByLineIndexes(
+            @Param("ids") List<String> lineIndexes,
+            @Param("statTime") String searchBeginTime,
+            @Param("endTime") String searchEndTime);
+
+    Page<MonitorOverLimitVO> getSumLimitRatePage(Page<RStatLimitRateDPO> p,
+                                                 @Param("ids") List<String> lineIndexes,
+                                                 @Param("statTime") String searchBeginTime,
+                                                 @Param("endTime") String searchEndTime);
+
+    List<MonitorOverLimitVO.DataVO> getPercentages(
+                                                    @Param("ids") List<String> lineIndexes,
+                                                    @Param("statTime") String searchBeginTime,
+                                                    @Param("endTime") String searchEndTime);
+
+
+    /**
+     * 数据查询
+     * @param list
+     * @param startTime
+     * @param endTime
+     * @return
+     */
+    List<RStatLimitRateDPO> getSumPassRateList( @Param("ids") List<String> list,
+                                                @Param("statTime") String startTime,
+                                                @Param("endTime") String endTime);
+
+    /**
+     * 获取综合评估下的指标完整率
+     * @param list
+     * @param startTime
+     * @param endTime
+     * @return111
+     */
+    List<RStatLimitRateDPO> getAssessTargetRate( @Param("ids") List<String> list,
+                                                @Param("statTime") String startTime,
+                                                @Param("endTime") String endTime);
+
+    /**
+     * 获取监测点的超标次数
+     * @param list
+     * @param startTime
+     * @param endTime
+     * @return
+     */
+    List<RStatLimitRateDPO> getAllOverTimes( @Param("ids") List<String> list,
+                                                 @Param("statTime") String startTime,
+                                                 @Param("endTime") String endTime);
+}

cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/RStatLimitRateDetailDMapper.java

@@ -0,0 +1,9 @@
+package com.njcn.csharmonic.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.njcn.csharmonic.pojo.po.RStatLimitRateDetailDPO;
+
+
+public interface RStatLimitRateDetailDMapper extends BaseMapper<RStatLimitRateDetailDPO> {
+
+}

cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/mapping/RStatLimitRateDMapper.xml

@@ -0,0 +1,475 @@
+<?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.csharmonic.mapper.RStatLimitRateDMapper">
+
+    <select id="getSumPassRate" resultType="com.njcn.csharmonic.pojo.vo.RStatLimitRateDVO">
+        SELECT
+            SUM( all_time ) AS alltime,
+            SUM( freq_dev_overtime ) AS frequency,
+            SUM( ubalance_overtime ) AS uBalance,
+            SUM( i_neg_overtime ) AS iNeg,
+            SUM( iharm_13_overtime ) AS harmElec,
+            SUM( uharm_4_overtime ) AS harmVoltage,
+            SUM( flicker_overtime ) AS flicker,
+            SUM( flicker_all_time ) AS allFlicker,
+            SUM( voltage_dev_overtime ) AS voltageDeviation,
+            SUM( inuharm_9_overtime ) AS inUharm
+        FROM
+            r_stat_limit_rate_d
+        <where>
+            <if test=" ids != null and ids.size > 0">
+                AND my_index IN
+                <foreach collection='ids' item='item' index="index" open='(' separator=',' close=')'>
+                    #{item}
+                </foreach>
+            </if>
+            <if test=" statTime != null and statTime !=''">
+                AND  time_id >= #{statTime}
+            </if>
+            <if test="endTime != null and endTime != ''">
+                AND  time_id &lt;= #{endTime}
+            </if>
+        </where>
+    </select>
+    <select id="getSumLimitRateByLineIndexes" resultType="com.njcn.csharmonic.pojo.vo.MonitorOverLimitVO">
+        SELECT
+        my_index AS id,
+        SUM(all_time) AS overDay,
+        SUM(freq_dev_overtime) AS freqOverDay,
+        SUM(voltage_dev_overtime ) AS volDevOverDay,
+        SUM(flicker_overtime) AS flickerOverDay,
+        SUM(i_neg_overtime) AS negativeOverDay,
+        SUM(ubalance_overtime) AS threeUnbalance,
+        SUM(uaberrance_overtime) AS volDisOverDay,
+        SUM(uharm_3_overtime) AS overVolThreeTimes,
+        SUM(uharm_5_overtime) AS overVolFiveTimes,
+        SUM(uharm_7_overtime) AS overVolSevenTimes,
+        SUM(uharm_11_overtime) AS overVolElevenTimes,
+        SUM(uharm_13_overtime) AS overVolThirteenTimes,
+        SUM(uharm_23_overtime) AS overVolTwentyThreeTimes,
+        SUM(uharm_25_overtime) AS overVolTwentyFiveTimes,
+        SUM(uharm_2_overtime)
+        + SUM(uharm_4_overtime)
+        + SUM(uharm_6_overtime)
+        + SUM(uharm_8_overtime)
+        + SUM(uharm_9_overtime)
+        + SUM(uharm_10_overtime)
+        + SUM(uharm_12_overtime)
+        + SUM(uharm_14_overtime)
+        + SUM(uharm_15_overtime)
+        + SUM(uharm_16_overtime)
+        + SUM(uharm_17_overtime)
+        + SUM(uharm_18_overtime)
+        + SUM(uharm_19_overtime)
+        + SUM(uharm_20_overtime)
+        + SUM(uharm_21_overtime)
+        + SUM(uharm_22_overtime)
+        + SUM(uharm_24_overtime) AS overVolOtherTimes,
+        SUM(iharm_3_overtime) AS overCurThreeTimes,
+        SUM(iharm_5_overtime) AS overCurFiveTimes,
+        SUM(iharm_7_overtime) AS overCurSevenTimes,
+        SUM(iharm_11_overtime) AS overCurElevenTimes,
+        SUM(iharm_13_overtime) AS overCurThirteenTimes,
+        SUM(iharm_23_overtime) AS overCurTwentyThreeTimes,
+        SUM(iharm_25_overtime) AS overCurTwentyFiveTimes,
+        SUM(iharm_2_overtime)
+        + SUM(iharm_4_overtime)
+        + SUM(iharm_6_overtime)
+        + SUM(iharm_8_overtime)
+        + SUM(iharm_9_overtime)
+        + SUM(iharm_10_overtime)
+        + SUM(iharm_12_overtime)
+        + SUM(iharm_14_overtime)
+        + SUM(iharm_15_overtime)
+        + SUM(iharm_16_overtime)
+        + SUM(iharm_17_overtime)
+        + SUM(iharm_18_overtime)
+        + SUM(iharm_19_overtime)
+        + SUM(iharm_20_overtime)
+        + SUM(iharm_21_overtime)
+        + SUM(iharm_22_overtime)
+        + SUM(iharm_24_overtime) AS overCurOtherTimes
+        FROM
+        r_stat_limit_rate_d
+        <where>
+            <if test=" ids != null and ids.size > 0">
+                AND my_index IN
+                <foreach collection='ids' item='item' index="index" open='(' separator=',' close=')'>
+                    #{item}
+                </foreach>
+            </if>
+            <if test=" statTime != null and statTime !=''">
+                AND  time_id >= #{statTime}
+            </if>
+            <if test="endTime != null and endTime != ''">
+                AND  time_id &lt;= #{endTime}
+            </if>
+        </where>
+        GROUP BY my_index
+    </select>
+    <select id="getSumLimitRatePage" resultType="com.njcn.csharmonic.pojo.vo.MonitorOverLimitVO">
+        SELECT
+        my_index AS id,
+        SUM(all_time) AS overDay,
+        SUM(freq_dev_overtime) AS freqOverDay,
+        SUM(voltage_dev_overtime ) AS volDevOverDay,
+        SUM(flicker_overtime) AS flickerOverDay,
+        SUM(i_neg_overtime) AS negativeOverDay,
+        SUM(ubalance_overtime) AS threeUnbalance,
+        SUM(uaberrance_overtime) AS volDisOverDay,
+        SUM(uharm_3_overtime) AS overVolThreeTimes,
+        SUM(uharm_5_overtime) AS overVolFiveTimes,
+        SUM(uharm_7_overtime) AS overVolSevenTimes,
+        SUM(uharm_11_overtime) AS overVolElevenTimes,
+        SUM(uharm_13_overtime) AS overVolThirteenTimes,
+        SUM(uharm_23_overtime) AS overVolTwentyThreeTimes,
+        SUM(uharm_25_overtime) AS overVolTwentyFiveTimes,
+        SUM(uharm_2_overtime)
+        + SUM(uharm_4_overtime)
+        + SUM(uharm_6_overtime)
+        + SUM(uharm_8_overtime)
+        + SUM(uharm_9_overtime)
+        + SUM(uharm_10_overtime)
+        + SUM(uharm_12_overtime)
+        + SUM(uharm_14_overtime)
+        + SUM(uharm_15_overtime)
+        + SUM(uharm_16_overtime)
+        + SUM(uharm_17_overtime)
+        + SUM(uharm_18_overtime)
+        + SUM(uharm_19_overtime)
+        + SUM(uharm_20_overtime)
+        + SUM(uharm_21_overtime)
+        + SUM(uharm_22_overtime)
+        + SUM(uharm_24_overtime) AS overVolOtherTimes,
+        SUM(iharm_3_overtime) AS overCurThreeTimes,
+        SUM(iharm_5_overtime) AS overCurFiveTimes,
+        SUM(iharm_7_overtime) AS overCurSevenTimes,
+        SUM(iharm_11_overtime) AS overCurElevenTimes,
+        SUM(iharm_13_overtime) AS overCurThirteenTimes,
+        SUM(iharm_23_overtime) AS overCurTwentyThreeTimes,
+        SUM(iharm_25_overtime) AS overCurTwentyFiveTimes,
+        SUM(iharm_2_overtime)
+        + SUM(iharm_4_overtime)
+        + SUM(iharm_6_overtime)
+        + SUM(iharm_8_overtime)
+        + SUM(iharm_9_overtime)
+        + SUM(iharm_10_overtime)
+        + SUM(iharm_12_overtime)
+        + SUM(iharm_14_overtime)
+        + SUM(iharm_15_overtime)
+        + SUM(iharm_16_overtime)
+        + SUM(iharm_17_overtime)
+        + SUM(iharm_18_overtime)
+        + SUM(iharm_19_overtime)
+        + SUM(iharm_20_overtime)
+        + SUM(iharm_21_overtime)
+        + SUM(iharm_22_overtime)
+        + SUM(iharm_24_overtime) AS overCurOtherTimes
+        FROM
+        r_stat_limit_target_d
+        <where>
+            <if test=" ids != null and ids.size > 0">
+                AND my_index IN
+                <foreach collection='ids' item='item' index="index" open='(' separator=',' close=')'>
+                    #{item}
+                </foreach>
+            </if>
+            <if test=" statTime != null and statTime !=''">
+                AND  time_id >= #{statTime}
+            </if>
+            <if test="endTime != null and endTime != ''">
+                AND  time_id &lt;= #{endTime}
+            </if>
+        </where>
+        GROUP BY my_index
+    </select>
+
+    <select id="getPercentages" resultType="com.njcn.csharmonic.pojo.vo.MonitorOverLimitVO$DataVO">
+            SELECT
+            <choose>
+                <when test="_databaseId == 'mysql'">
+                    DATE_FORMAT(time_id, '%Y-%m-%d')
+                </when>
+                <otherwise>
+                    TO_CHAR(time_id, 'YYYY-MM-DD')
+                </otherwise>
+            </choose> AS time,
+            <choose>
+                <when test="_databaseId == 'mysql'">
+                    IFNULL(ROUND(
+                </when>
+                <otherwise>
+                    NVL(TRUNC(
+                </otherwise>
+            </choose>
+            CASE
+            WHEN SUM(all_time) = 0 THEN 0
+            ELSE (1 - (
+            -- 各类指标求和（保持原有逻辑不变）
+            SUM(flicker_overtime) + SUM(flicker_all_time) + SUM(freq_dev_overtime) +
+            SUM(voltage_dev_overtime) + SUM(ubalance_overtime) + SUM(uaberrance_overtime) +
+            SUM(i_neg_overtime) +
+            -- 电压谐波 (2-25)
+            SUM(uharm_2_overtime) + SUM(uharm_3_overtime) + SUM(uharm_4_overtime) + SUM(uharm_5_overtime) +
+            SUM(uharm_6_overtime) + SUM(uharm_7_overtime) + SUM(uharm_8_overtime) + SUM(uharm_9_overtime) +
+            SUM(uharm_10_overtime) + SUM(uharm_11_overtime) + SUM(uharm_12_overtime) + SUM(uharm_13_overtime) +
+            SUM(uharm_14_overtime) + SUM(uharm_15_overtime) + SUM(uharm_16_overtime) + SUM(uharm_17_overtime) +
+            SUM(uharm_18_overtime) + SUM(uharm_19_overtime) + SUM(uharm_20_overtime) + SUM(uharm_21_overtime) +
+            SUM(uharm_22_overtime) + SUM(uharm_23_overtime) + SUM(uharm_24_overtime) + SUM(uharm_25_overtime) +
+            -- 电流谐波 (2-25)
+            SUM(iharm_2_overtime) + SUM(iharm_3_overtime) + SUM(iharm_4_overtime) + SUM(iharm_5_overtime) +
+            SUM(iharm_6_overtime) + SUM(iharm_7_overtime) + SUM(iharm_8_overtime) + SUM(iharm_9_overtime) +
+            SUM(iharm_10_overtime) + SUM(iharm_11_overtime) + SUM(iharm_12_overtime) + SUM(iharm_13_overtime) +
+            SUM(iharm_14_overtime) + SUM(iharm_15_overtime) + SUM(iharm_16_overtime) + SUM(iharm_17_overtime) +
+            SUM(iharm_18_overtime) + SUM(iharm_19_overtime) + SUM(iharm_20_overtime) + SUM(iharm_21_overtime) +
+            SUM(iharm_22_overtime) + SUM(iharm_23_overtime) + SUM(iharm_24_overtime) + SUM(iharm_25_overtime) +
+            -- 间谐波 (1-16)
+            SUM(inuharm_1_overtime) + SUM(inuharm_2_overtime) + SUM(inuharm_3_overtime) + SUM(inuharm_4_overtime) +
+            SUM(inuharm_5_overtime) + SUM(inuharm_6_overtime) + SUM(inuharm_7_overtime) + SUM(inuharm_8_overtime) +
+            SUM(inuharm_9_overtime) + SUM(inuharm_10_overtime) + SUM(inuharm_11_overtime) + SUM(inuharm_12_overtime) +
+            SUM(inuharm_13_overtime) + SUM(inuharm_14_overtime) + SUM(inuharm_15_overtime) + SUM(inuharm_16_overtime)
+            ) / NULLIF(SUM(all_time) * 71, 0)) * 100
+            END, 2), 0) AS data
+            FROM
+            r_stat_limit_rate_d
+            <where>
+                phasic_type = 'T'
+                <if test="ids != null and ids.size > 0">
+                    AND my_index IN
+                    <foreach collection="ids" item="item" index="index" open="(" separator="," close=")">
+                        #{item}
+                    </foreach>
+                </if>
+                <if test="statTime != null and statTime != ''">
+                    AND time_id >= #{statTime}
+                </if>
+                <if test="endTime != null and endTime != ''">
+                    AND time_id &lt;= #{endTime}
+                </if>
+            </where>
+            GROUP BY
+            <choose>
+                <when test="_databaseId == 'mysql'">
+                    DATE_FORMAT(time_id, '%Y-%m-%d')
+                </when>
+                <otherwise>
+                    TO_CHAR(time_id, 'YYYY-MM-DD')
+                </otherwise>
+            </choose>
+            ORDER BY time
+    </select>
+
+
+    <select id="getSumPassRateList" resultType="com.njcn.csharmonic.pojo.po.RStatLimitRateDPO">
+        SELECT
+        my_index as lineId ,
+        sum(all_time) as all_time,
+        sum(flicker_all_time) as flicker_all_time,
+        sum(freq_dev_overtime) as freq_dev_overtime,
+        sum(voltage_dev_overtime) as voltage_dev_overtime,
+        sum(ubalance_overtime) as ubalance_overtime,
+        sum(flicker_overtime) as flicker_overtime,
+        sum(uaberrance_overtime) as uaberrance_overtime,
+        sum(uharm_2_overtime) as uharm_2_overtime,
+        sum(uharm_3_overtime) as uharm_3_overtime,
+        sum(uharm_4_overtime) as uharm_4_overtime,
+        sum(uharm_5_overtime) as uharm_5_overtime,
+        sum(uharm_6_overtime) as uharm_6_overtime,
+        sum(uharm_7_overtime) as uharm_7_overtime,
+        sum(uharm_8_overtime) as uharm_8_overtime,
+        sum(uharm_9_overtime) as uharm_9_overtime,
+        sum(uharm_10_overtime) as uharm_10_overtime,
+        sum(uharm_11_overtime) as uharm_11_overtime,
+        sum(uharm_12_overtime) as uharm_12_overtime,
+        sum(uharm_13_overtime) as uharm_13_overtime,
+        sum(uharm_14_overtime) as uharm_14_overtime,
+        sum(uharm_15_overtime) as uharm_15_overtime,
+        sum(uharm_16_overtime) as uharm_16_overtime,
+        sum(uharm_17_overtime) as uharm_17_overtime,
+        sum(uharm_18_overtime) as uharm_18_overtime,
+        sum(uharm_19_overtime) as uharm_19_overtime,
+        sum(uharm_20_overtime) as uharm_20_overtime,
+        sum(uharm_21_overtime) as uharm_21_overtime,
+        sum(uharm_22_overtime) as uharm_22_overtime,
+        sum(uharm_23_overtime) as uharm_23_overtime,
+        sum(uharm_24_overtime) as uharm_24_overtime,
+        sum(uharm_25_overtime) as uharm_25_overtime,
+        sum(iharm_2_overtime) as iharm_2_overtime,
+        sum(iharm_3_overtime) as iharm_3_overtime,
+        sum(iharm_4_overtime) as iharm_4_overtime,
+        sum(iharm_5_overtime) as iharm_5_overtime,
+        sum(iharm_6_overtime) as iharm_6_overtime,
+        sum(iharm_7_overtime) as iharm_7_overtime,
+        sum(iharm_8_overtime) as iharm_8_overtime,
+        sum(iharm_9_overtime) as iharm_9_overtime,
+        sum(iharm_10_overtime) as iharm_10_overtime,
+        sum(iharm_11_overtime) as iharm_11_overtime,
+        sum(iharm_12_overtime) as iharm_12_overtime,
+        sum(iharm_13_overtime) as iharm_13_overtime,
+        sum(iharm_14_overtime) as iharm_14_overtime,
+        sum(iharm_15_overtime) as iharm_15_overtime,
+        sum(iharm_16_overtime) as iharm_16_overtime,
+        sum(iharm_17_overtime) as iharm_17_overtime,
+        sum(iharm_18_overtime) as iharm_18_overtime,
+        sum(iharm_19_overtime) as iharm_19_overtime,
+        sum(iharm_20_overtime) as iharm_20_overtime,
+        sum(iharm_21_overtime) as iharm_21_overtime,
+        sum(iharm_22_overtime) as iharm_22_overtime,
+        sum(iharm_23_overtime) as iharm_23_overtime,
+        sum(iharm_24_overtime) as iharm_24_overtime,
+        sum(iharm_25_overtime) as iharm_25_overtime,
+        sum(inuharm_1_overtime) as inuharm_1_overtime,
+        sum(inuharm_2_overtime) as inuharm_2_overtime,
+        sum(inuharm_3_overtime) as inuharm_3_overtime,
+        sum(inuharm_4_overtime) as inuharm_4_overtime,
+        sum(inuharm_5_overtime) as inuharm_5_overtime,
+        sum(inuharm_6_overtime) as inuharm_6_overtime,
+        sum(inuharm_7_overtime) as inuharm_7_overtime,
+        sum(inuharm_8_overtime) as inuharm_8_overtime,
+        sum(inuharm_9_overtime) as inuharm_9_overtime,
+        sum(inuharm_10_overtime) as inuharm_10_overtime,
+        sum(inuharm_11_overtime) as inuharm_11_overtime,
+        sum(inuharm_12_overtime) as inuharm_12_overtime,
+        sum(inuharm_13_overtime) as inuharm_13_overtime,
+        sum(inuharm_14_overtime) as inuharm_14_overtime,
+        sum(inuharm_15_overtime) as inuharm_15_overtime,
+        sum(inuharm_16_overtime) as inuharm_16_overtime,
+        sum(i_neg_overtime) as i_neg_overtime
+        from
+            r_stat_limit_rate_d
+        <where>
+            phasic_type = 'T'
+            <if test=" ids != null and ids.size > 0">
+                AND my_index IN
+                <foreach collection='ids' item='item' index="index" open='(' separator=',' close=')'>
+                    #{item}
+                </foreach>
+            </if>
+            <if test=" statTime != null and statTime !=''">
+                AND  time_id >= #{statTime}
+            </if>
+            <if test="endTime != null and endTime != ''">
+                AND  time_id &lt;= #{endTime}
+            </if>
+        </where>
+        GROUP BY
+            my_index
+    </select>
+
+    <select id="getAssessTargetRate" resultType="com.njcn.csharmonic.pojo.po.RStatLimitRateDPO">
+        select
+            my_index as lineId,
+            SUM(all_time) as allTime,
+            SUM(flicker_all_time) as flickerAllTime,
+            SUM(freq_dev_overtime) as freqDevOvertime,
+            SUM(voltage_dev_overtime) as voltageDevOvertime,
+            SUM(flicker_overtime) as flickerOvertime,
+            SUM(ubalance_overtime) as ubalanceOvertime,
+            SUM(uaberrance_overtime) as uaberranceOvertime,
+            sum(uharm_2_overtime)  uharm2Overtime,
+            sum(uharm_3_overtime)  uharm3Overtime,
+            sum(uharm_4_overtime)  uharm4Overtime,
+            sum(uharm_5_overtime)  uharm5Overtime,
+            sum(uharm_6_overtime)  uharm6Overtime,
+            sum(uharm_7_overtime)  uharm7Overtime,
+            sum(uharm_8_overtime)  uharm8Overtime,
+            sum(uharm_9_overtime)  uharm9Overtime,
+            sum(uharm_10_overtime)  uharm10Overtime,
+            sum(uharm_11_overtime)  uharm11Overtime,
+            sum(uharm_12_overtime)  uharm12Overtime,
+            sum(uharm_13_overtime)  uharm13Overtime,
+            sum(uharm_14_overtime)  uharm14Overtime,
+            sum(uharm_15_overtime)  uharm15Overtime,
+            sum(uharm_16_overtime)  uharm16Overtime,
+            sum(uharm_17_overtime)  uharm17Overtime,
+            sum(uharm_18_overtime)  uharm18Overtime,
+            sum(uharm_19_overtime)  uharm19Overtime,
+            sum(uharm_20_overtime)  uharm20Overtime,
+            sum(uharm_21_overtime)  uharm21Overtime,
+            sum(uharm_22_overtime)  uharm22Overtime,
+            sum(uharm_23_overtime)  uharm23Overtime,
+            sum(uharm_24_overtime)  uharm24Overtime,
+            sum(uharm_25_overtime)  uharm25Overtime,
+            sum(iharm_2_overtime)  iharm2Overtime,
+            sum(iharm_3_overtime)  iharm3Overtime,
+            sum(iharm_4_overtime)  iharm4Overtime,
+            sum(iharm_5_overtime)  iharm5Overtime,
+            sum(iharm_6_overtime)  iharm6Overtime,
+            sum(iharm_7_overtime)  iharm7Overtime,
+            sum(iharm_8_overtime)  iharm8Overtime,
+            sum(iharm_9_overtime)  iharm9Overtime,
+            sum(iharm_10_overtime)  iharm10Overtime,
+            sum(iharm_11_overtime)  iharm11Overtime,
+            sum(iharm_12_overtime)  iharm12Overtime,
+            sum(iharm_13_overtime)  iharm13Overtime,
+            sum(iharm_14_overtime)  iharm14Overtime,
+            sum(iharm_15_overtime)  iharm15Overtime,
+            sum(iharm_16_overtime)  iharm16Overtime,
+            sum(iharm_17_overtime)  iharm17Overtime,
+            sum(iharm_18_overtime)  iharm18Overtime,
+            sum(iharm_19_overtime)  iharm19Overtime,
+            sum(iharm_20_overtime)  iharm20Overtime,
+            sum(iharm_21_overtime)  iharm21Overtime,
+            sum(iharm_22_overtime)  iharm22Overtime,
+            sum(iharm_23_overtime)  iharm23Overtime,
+            sum(iharm_24_overtime)  iharm24Overtime,
+            sum(iharm_25_overtime)  iharm25Overtime,
+            sum(inuharm_1_overtime) inuharm1Overtime,
+            sum(inuharm_2_overtime) inuharm2Overtime,
+            sum(inuharm_3_overtime) inuharm3Overtime,
+            sum(inuharm_4_overtime) inuharm4Overtime,
+            sum(inuharm_5_overtime) inuharm5Overtime,
+            sum(inuharm_6_overtime) inuharm6Overtime,
+            sum(inuharm_7_overtime) inuharm7Overtime,
+            sum(inuharm_8_overtime) inuharm8Overtime,
+            sum(inuharm_9_overtime) inuharm9Overtime,
+            sum(inuharm_10_overtime) inuharm10Overtime,
+            sum(inuharm_11_overtime) inuharm11Overtime,
+            sum(inuharm_12_overtime) inuharm12Overtime,
+            sum(inuharm_13_overtime) inuharm13Overtime,
+            sum(inuharm_14_overtime) inuharm14Overtime,
+            sum(inuharm_15_overtime) inuharm15Overtime,
+            sum(inuharm_16_overtime) inuharm16Overtime,
+            sum(i_neg_overtime)  iNegOvertime
+        from
+            r_stat_limit_rate_d
+        where
+            time_id between #{statTime} and #{endTime}
+            <if test=" ids != null and ids.size > 0">
+                AND my_index IN
+                <foreach collection='ids' item='item' index="index" open='(' separator=',' close=')'>
+                    #{item}
+                </foreach>
+            </if>
+        group by
+            my_index
+    </select>
+
+    <select id="getAllOverTimes" resultType="com.njcn.csharmonic.pojo.po.RStatLimitRateDPO">
+        select
+            my_index as lineId,
+            SUM(freq_dev_overtime
+                    + flicker_overtime
+                    + voltage_dev_overtime
+                    + ubalance_overtime
+                    + uaberrance_overtime
+                    + i_neg_overtime
+                    + uharm_2_overtime + uharm_3_overtime + uharm_4_overtime + uharm_5_overtime + uharm_6_overtime + uharm_7_overtime + uharm_8_overtime + uharm_9_overtime + uharm_10_overtime + uharm_11_overtime + uharm_12_overtime + uharm_13_overtime + uharm_14_overtime + uharm_15_overtime + uharm_16_overtime + uharm_17_overtime + uharm_18_overtime + uharm_19_overtime + uharm_20_overtime + uharm_21_overtime + uharm_22_overtime + uharm_23_overtime + uharm_24_overtime + uharm_25_overtime
+                    + iharm_2_overtime + iharm_3_overtime + iharm_4_overtime + iharm_5_overtime + iharm_6_overtime + iharm_7_overtime + iharm_8_overtime + iharm_9_overtime + iharm_10_overtime + iharm_11_overtime + iharm_12_overtime + iharm_13_overtime + iharm_14_overtime + iharm_15_overtime + iharm_16_overtime + iharm_17_overtime + iharm_18_overtime + iharm_19_overtime + iharm_20_overtime + iharm_21_overtime + iharm_22_overtime + iharm_23_overtime + iharm_24_overtime + iharm_25_overtime
+                    + inuharm_1_overtime + inuharm_2_overtime + inuharm_3_overtime + inuharm_4_overtime + inuharm_5_overtime + inuharm_6_overtime + inuharm_7_overtime + inuharm_8_overtime + inuharm_9_overtime + inuharm_10_overtime + inuharm_11_overtime + inuharm_12_overtime + inuharm_13_overtime + inuharm_14_overtime + inuharm_15_overtime + inuharm_16_overtime
+            ) as allTime
+        from
+            r_stat_limit_rate_d
+        <where>
+            and time_id between #{statTime} and #{endTime}
+            <if test=" ids != null and ids.size > 0">
+                AND my_index IN
+                <foreach collection='ids' item='item' index="index" open='(' separator=',' close=')'>
+                    #{item}
+                </foreach>
+            </if>
+        </where>
+        group by
+            my_index
+    </select>
+</mapper>

cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/mapping/RStatLimitRateDetailDMapper.xml

@@ -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.csharmonic.mapper.RStatLimitRateDetailDMapper">
+
+
+</mapper>

cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/IRStatLimitRateDService.java

@@ -0,0 +1,48 @@
+package com.njcn.csharmonic.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.csharmonic.pojo.param.MainLineQueryParam;
+import com.njcn.csharmonic.pojo.param.MainLineStatLimitRateDetailsQueryParam;
+import com.njcn.csharmonic.pojo.param.TotalLimitStatisticsDetailsQueryParam;
+import com.njcn.csharmonic.pojo.param.TotalLimitStatisticsParam;
+import com.njcn.csharmonic.pojo.po.RStatLimitRateDPO;
+import com.njcn.csharmonic.pojo.vo.*;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 合格率统计日表(越限次数) 服务类
+ * </p>
+ *
+ * @author wr
+ * @since 2023-04-03
+ */
+public interface IRStatLimitRateDService extends IService<RStatLimitRateDPO> {
+
+    /**
+     * 获取指定日期的监测点超标详情
+     *
+     * @author cdf
+     * @date 2024/2/28
+     */
+    List<RStatLimitRateDPO> monitorIdsGetLimitRateInfo(String date, List<String> monitorIds);
+
+    List<RStatLimitRateDPO> getOverData(String lineId, String startTime, String endTime, Integer type);
+
+    Page<MainLineVO> mainLineList(MainLineQueryParam param);
+
+    List<MainLineStatLimitRateDetailsVO> mainLineStatLimitRateDetails(MainLineStatLimitRateDetailsQueryParam param);
+
+    TotalLimitTotalStatisticsVO totalLimitTotalStatisticsData(TotalLimitStatisticsParam param);
+
+    List<TotalLimitStatisticsVO> totalLimitStatisticsList(TotalLimitStatisticsParam param);
+
+    List<TotalLimitStatisticsDetailsVO> totalLimitStatisticsDetails(TotalLimitStatisticsDetailsQueryParam param);
+
+    TotalLimitTotalStatisticsVO gridSideLimitTotalStatisticsData(TotalLimitStatisticsParam param);
+
+    List<TotalLimitStatisticsVO> gridSideLimitStatisticsList(TotalLimitStatisticsParam param);
+
+}

cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/IRStatLimitRateDetailDService.java

@@ -0,0 +1,30 @@
+package com.njcn.csharmonic.service;
+
+import cn.hutool.json.JSONArray;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.csharmonic.pojo.param.LimitCalendarQueryParam;
+import com.njcn.csharmonic.pojo.param.LimitExtentDayQueryParam;
+import com.njcn.csharmonic.pojo.param.LimitExtentQueryParam;
+import com.njcn.csharmonic.pojo.param.LimitProbabilityQueryParam;
+import com.njcn.csharmonic.pojo.po.RStatLimitRateDetailDPO;
+import com.njcn.csharmonic.pojo.vo.LimitCalendarVO;
+import com.njcn.csharmonic.pojo.vo.LimitExtentVO;
+import com.njcn.csharmonic.pojo.vo.LimitProbabilityVO;
+import com.njcn.csharmonic.pojo.vo.LimitTimeProbabilityVO;
+
+import java.util.List;
+
+
+public interface IRStatLimitRateDetailDService extends IService<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);
+}

cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/impl/RStatLimitRateDServiceImpl.java

@@ -0,0 +1,600 @@
+package com.njcn.csharmonic.service.impl;
+
+import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import com.baomidou.dynamic.datasource.annotation.DS;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.csdevice.api.CsLineFeignClient;
+import com.njcn.csdevice.pojo.po.CsLinePO;
+import com.njcn.csharmonic.mapper.RStatLimitRateDMapper;
+import com.njcn.csharmonic.pojo.param.MainLineQueryParam;
+import com.njcn.csharmonic.pojo.param.MainLineStatLimitRateDetailsQueryParam;
+import com.njcn.csharmonic.pojo.param.TotalLimitStatisticsDetailsQueryParam;
+import com.njcn.csharmonic.pojo.param.TotalLimitStatisticsParam;
+import com.njcn.csharmonic.pojo.po.RStatLimitRateDPO;
+import com.njcn.csharmonic.pojo.vo.*;
+import com.njcn.csharmonic.service.IRStatLimitRateDService;
+import com.njcn.system.api.DicDataFeignClient;
+import com.njcn.system.pojo.po.DictData;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 合格率统计日表(越限次数) 服务实现类
+ * </p>
+ *
+ * @author wr
+ * @since 2023-04-03
+ */
+@DS("sjzx")
+@RequiredArgsConstructor
+@Service
+public class RStatLimitRateDServiceImpl extends ServiceImpl<RStatLimitRateDMapper, RStatLimitRateDPO> implements IRStatLimitRateDService {
+
+    private final CsLineFeignClient csLineFeignClient;
+    private final DicDataFeignClient dicDataFeignClient;
+    private final DecimalFormat df = new DecimalFormat("#0.00");
+
+    private final String GRID_SIDE_DICT_CODE = "Grid_Side";
+
+    @Override
+    public List<RStatLimitRateDPO> monitorIdsGetLimitRateInfo(String date, List<String> monitorIds) {
+        return this.baseMapper.selectList(new LambdaQueryWrapper<RStatLimitRateDPO>()
+                .in(RStatLimitRateDPO::getLineId, monitorIds).eq(RStatLimitRateDPO::getTime, date).eq(RStatLimitRateDPO::getPhasicType, "T"));
+    }
+
+
+    @Override
+    public List<RStatLimitRateDPO> getOverData(String lineId, String startTime, String endTime, Integer type) {
+        QueryWrapper<RStatLimitRateDPO> queryWrapper = new QueryWrapper<>();
+        queryWrapper.lambda()
+                .eq(RStatLimitRateDPO::getLineId, lineId)
+                .between(RStatLimitRateDPO::getTime, startTime, endTime)
+                .groupBy(RStatLimitRateDPO::getTime);
+        //频率偏差
+        if (type == 1) {
+            queryWrapper.select("time_id time,max(freq_dev_overtime) freq_dev_overtime");
+            queryWrapper.lambda().gt(RStatLimitRateDPO::getFreqDevOvertime, 0);
+        }
+        //电压偏差
+        else if (type == 2) {
+            queryWrapper.select("time_id time,max(voltage_dev_overtime) voltage_dev_overtime");
+            queryWrapper.lambda().gt(RStatLimitRateDPO::getVoltageDevOvertime, 0);
+        }
+        //长时闪变
+        else if (type == 3) {
+            queryWrapper.select("time_id time,max(flicker_overtime) flicker_overtime");
+            queryWrapper.lambda().gt(RStatLimitRateDPO::getFlickerOvertime, 0);
+        }
+        //电压总谐波畸变率
+        else if (type == 4) {
+            queryWrapper.select("time_id time,max(uaberrance_overtime) uaberrance_overtime");
+            queryWrapper.lambda().gt(RStatLimitRateDPO::getUaberranceOvertime, 0);
+        }
+        //负序电压不平衡度
+        else if (type == 5) {
+            queryWrapper.select("time_id time,max(ubalance_overtime) ubalance_overtime");
+            queryWrapper.lambda().gt(RStatLimitRateDPO::getUbalanceOvertime, 0);
+        }
+        //负序电流
+        else if (type == 6) {
+            queryWrapper.select("time_id time,max(i_neg_overtime) i_neg_overtime");
+            queryWrapper.lambda().gt(RStatLimitRateDPO::getINegOvertime, 0);
+        }
+        //谐波电压含有率
+        else if (type == 7) {
+            StringBuilder selectSql = new StringBuilder();
+            StringBuilder havingSql = new StringBuilder();
+            for (int i = 2; i <= 25; i++) {
+                selectSql.append("max(uharm_").append(i).append("_overtime) uharm_").append(i).append("_overtime,");
+                if (i == 25) {
+                    havingSql.append("uharm_").append(i).append("_overtime");
+                } else {
+                    havingSql.append("uharm_").append(i).append("_overtime + ");
+                }
+            }
+            selectSql.append("time_id time");
+            havingSql = new StringBuilder("sum(" + havingSql + ")");
+            queryWrapper.select(selectSql.toString()).having(havingSql.toString(), 0);
+        }
+        //谐波电流
+        else if (type == 8) {
+            StringBuilder selectSql = new StringBuilder();
+            StringBuilder havingSql = new StringBuilder();
+            for (int i = 2; i <= 25; i++) {
+                selectSql.append("max(iharm_").append(i).append("_overtime) iharm_").append(i).append("_overtime,");
+                if (i == 25) {
+                    havingSql.append("iharm_").append(i).append("_overtime");
+                } else {
+                    havingSql.append("iharm_").append(i).append("_overtime + ");
+                }
+            }
+            selectSql.append("time_id time");
+            havingSql = new StringBuilder("sum(" + havingSql + ")");
+            queryWrapper.select(selectSql.toString()).having(havingSql.toString(), 0);
+        }
+        //间谐波电压
+        else if (type == 9) {
+            StringBuilder selectSql = new StringBuilder();
+            StringBuilder havingSql = new StringBuilder();
+            for (int i = 1; i <= 16; i++) {
+                selectSql.append("max(inuharm_").append(i).append("_overtime) inuharm_").append(i).append("_overtime,");
+                if (i == 16) {
+                    havingSql.append("inuharm_").append(i).append("_overtime");
+                } else {
+                    havingSql.append("inuharm_").append(i).append("_overtime + ");
+                }
+            }
+            selectSql.append("time_id time");
+            havingSql = new StringBuilder("sum(" + havingSql + ")");
+            queryWrapper.select(selectSql.toString()).having(havingSql.toString(), 0);
+        }
+        return this.baseMapper.selectList(queryWrapper);
+    }
+
+    @Override
+    public Page<MainLineVO> mainLineList(MainLineQueryParam param) {
+        Page<MainLineVO> result = new Page<>();
+        result.setCurrent(param.getPageNum());
+        result.setSize(param.getPageSize());
+        String keywords = param.getKeywords();
+        List<String> keywordsLineIds = new ArrayList<>();
+        if (StrUtil.isNotBlank(keywords)) {
+            List<CsLinePO> lineList = csLineFeignClient.getLineByName(keywords).getData();
+            if (CollUtil.isEmpty(lineList)) {
+                return result;
+            }
+            keywordsLineIds = lineList.stream().map(CsLinePO::getLineId).collect(Collectors.toList());
+        }
+        // 根据监测点Id分组，再分页
+        Page<RStatLimitRateDPO> ratePage = this.page(new Page<RStatLimitRateDPO>(param.getPageNum(), param.getPageSize()), new LambdaQueryWrapper<RStatLimitRateDPO>()
+                .eq(RStatLimitRateDPO::getPhasicType, "T")
+                .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime())
+                .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime())
+                .in(CollUtil.isNotEmpty(keywordsLineIds), RStatLimitRateDPO::getLineId, keywordsLineIds)
+                .groupBy(RStatLimitRateDPO::getLineId)
+                .select(RStatLimitRateDPO::getLineId)
+        );
+        BeanUtil.copyProperties(ratePage, result);
+        List<RStatLimitRateDPO> records = ratePage.getRecords();
+        if (CollUtil.isEmpty(records)) {
+            return result;
+        }
+        List<MainLineVO> list = new ArrayList<>();
+        MainLineVO mainLineVO;
+        for (RStatLimitRateDPO record : records) {
+            String lineId = record.getLineId();
+            CsLinePO linePO = csLineFeignClient.getById(lineId).getData();
+            mainLineVO = new MainLineVO();
+            mainLineVO.setLineId(lineId);
+            if (linePO != null) {
+                mainLineVO.setLineName(linePO.getName());
+                if (linePO.getGovern().equals(0)) {
+                    mainLineVO.setGovern("未治理");
+                }
+                if (linePO.getGovern().equals(1)) {
+                    mainLineVO.setGovern("已治理");
+                }
+                mainLineVO.setObjType(linePO.getMonitorObj());
+                DictData dictData = dicDataFeignClient.getDicDataById(linePO.getMonitorObj()).getData();
+                if (dictData != null) {
+                    mainLineVO.setObjType(dictData.getName());
+                }
+            }
+            MainLineStatLimitRateDetailsQueryParam detailsQueryParam = new MainLineStatLimitRateDetailsQueryParam();
+            detailsQueryParam.setLineId(lineId);
+            detailsQueryParam.setSearchBeginTime(param.getSearchBeginTime());
+            detailsQueryParam.setSearchEndTime(param.getSearchEndTime());
+            List<MainLineStatLimitRateDetailsVO> detailsList = this.mainLineStatLimitRateDetails(detailsQueryParam);
+            List<String> problemList = new ArrayList<>();
+            for (MainLineStatLimitRateDetailsVO details : detailsList) {
+                JSONObject entries = JSONUtil.parseObj(details);
+                for (Map.Entry<String, Object> entry : entries.entrySet()) {
+                    String key = entry.getKey();
+                    if (key.endsWith("Overtime")) {
+                        String value = entry.getValue().toString();
+                        // 值 >0 则表示该电能质量指标有问题
+                        Integer intValue = new Integer(value);
+                        if (intValue > 0) {
+                            String description = getDescription(key);
+                            if (StrUtil.isNotBlank(description)) {
+                                if (!problemList.contains(description)) {
+                                    problemList.add(description);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (CollUtil.isEmpty(problemList)) {
+                mainLineVO.setProblems("所有指标都合格");
+            } else {
+                mainLineVO.setProblems(CollUtil.join(problemList, "、"));
+            }
+
+            list.add(mainLineVO);
+        }
+        result.setRecords(list);
+        return result;
+    }
+
+    @Override
+    public List<MainLineStatLimitRateDetailsVO> mainLineStatLimitRateDetails(MainLineStatLimitRateDetailsQueryParam param) {
+
+        HttpResult<CsLinePO> lineResult = csLineFeignClient.getById(param.getLineId());
+        CsLinePO linePO = lineResult.getData();
+        if (linePO == null) {
+            return Collections.emptyList();
+        }
+        List<RStatLimitRateDPO> list = this.list(new LambdaQueryWrapper<RStatLimitRateDPO>()
+                .eq(RStatLimitRateDPO::getLineId, param.getLineId())
+                .eq(RStatLimitRateDPO::getPhasicType, "T")
+                .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime())
+                .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime())
+                .orderByAsc(RStatLimitRateDPO::getTime)
+        );
+        return list.stream().map(item -> {
+            MainLineStatLimitRateDetailsVO vo = BeanUtil.copyProperties(item, MainLineStatLimitRateDetailsVO.class);
+            vo.setLineName(linePO.getName());
+            Integer lineInterval = linePO.getLineInterval();
+            JSONObject entries = JSONUtil.parseObj(vo);
+            for (Map.Entry<String, Object> entry : entries.entrySet()) {
+                String key = entry.getKey();
+                if (key.endsWith("Overtime")) {
+                    String value = entry.getValue().toString();
+                    Integer intValue = new Integer(value);
+                    // 总分钟 = 越限次数 * 间隔时间
+                    int minutes = intValue * lineInterval;
+                    entries.putOpt(key, minutes);
+                }
+            }
+            return BeanUtil.copyProperties(entries, MainLineStatLimitRateDetailsVO.class);
+        }).collect(Collectors.toList());
+    }
+
+    @Override
+    public TotalLimitTotalStatisticsVO totalLimitTotalStatisticsData(TotalLimitStatisticsParam param) {
+        List<RStatLimitRateDPO> rateList = this.list(new LambdaQueryWrapper<RStatLimitRateDPO>()
+                .eq(RStatLimitRateDPO::getPhasicType, "T")
+                .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime())
+                .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime())
+                .orderByAsc(RStatLimitRateDPO::getTime)
+        );
+
+        TotalLimitTotalStatisticsVO statisticsVO = new TotalLimitTotalStatisticsVO();
+        int flickerTotalTime = rateList.stream().mapToInt(RStatLimitRateDPO::getFlickerOvertime).sum();
+        int voltageDevTotalTime = rateList.stream().mapToInt(RStatLimitRateDPO::getVoltageDevOvertime).sum();
+        int ubalanceTotalTime = rateList.stream().mapToInt(RStatLimitRateDPO::getUbalanceOvertime).sum();
+        int iharmTotalTime = 0;
+        int uharmTotalTime = 0;
+        for (RStatLimitRateDPO rate : rateList) {
+            JSONObject entries = JSONUtil.parseObj(rate);
+            for (Map.Entry<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> totalLimitStatisticsList(TotalLimitStatisticsParam param) {
+        List<TotalLimitStatisticsVO> result = new ArrayList<>();
+
+        List<RStatLimitRateDPO> rateList = this.list(new LambdaQueryWrapper<RStatLimitRateDPO>()
+                .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));
+
+        List<CsLinePO> linePOList = csLineFeignClient.queryLineById(new ArrayList<>(lineMap.keySet())).getData();
+        if (CollUtil.isEmpty(linePOList)) {
+            return result;
+        }
+        TotalLimitStatisticsVO statisticsVO;
+        for (CsLinePO linePO : linePOList) {
+            statisticsVO = new TotalLimitStatisticsVO();
+            statisticsVO.setLineId(linePO.getLineId());
+            statisticsVO.setLineName(linePO.getName());
+            List<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;
+    }
+
+    @Override
+    public List<TotalLimitStatisticsDetailsVO> totalLimitStatisticsDetails(TotalLimitStatisticsDetailsQueryParam param) {
+
+        HttpResult<CsLinePO> lineResult = csLineFeignClient.getById(param.getLineId());
+        CsLinePO linePO = lineResult.getData();
+        if (linePO == null) {
+            return Collections.emptyList();
+        }
+        List<RStatLimitRateDPO> list = this.list(new LambdaQueryWrapper<RStatLimitRateDPO>()
+                .eq(RStatLimitRateDPO::getLineId, param.getLineId())
+                .eq(RStatLimitRateDPO::getPhasicType, "T")
+                .ge(StrUtil.isNotBlank(param.getSearchBeginTime()), RStatLimitRateDPO::getTime, param.getSearchBeginTime())
+                .le(StrUtil.isNotBlank(param.getSearchEndTime()), RStatLimitRateDPO::getTime, param.getSearchEndTime())
+                .orderByAsc(RStatLimitRateDPO::getTime)
+        );
+        return list.stream().map(item -> {
+            MainLineStatLimitRateDetailsVO vo = BeanUtil.copyProperties(item, MainLineStatLimitRateDetailsVO.class);
+            vo.setLineName(linePO.getName());
+            Integer allTime = item.getAllTime();
+            JSONObject entries = JSONUtil.parseObj(vo);
+            for (Map.Entry<String, Object> entry : entries.entrySet()) {
+                String key = entry.getKey();
+                if (key.endsWith("Overtime") && allTime != 0) {
+                    String value = entry.getValue().toString();
+                    int intValue = new Integer(value);
+                    // 占比 = 越限次数 / 总次数 * 100
+                    double proportion = calculatePercentage(intValue, allTime);
+                    entries.putOpt(key, proportion);
+                }
+            }
+            return BeanUtil.copyProperties(entries, TotalLimitStatisticsDetailsVO.class);
+        }).collect(Collectors.toList());
+    }
+
+    @Override
+    public TotalLimitTotalStatisticsVO gridSideLimitTotalStatisticsData(TotalLimitStatisticsParam param) {
+        TotalLimitTotalStatisticsVO statisticsVO = new TotalLimitTotalStatisticsVO();
+        // 获取电网侧监测点
+        DictData dictData = dicDataFeignClient.getDicDataByCode(GRID_SIDE_DICT_CODE).getData();
+        CsLinePO queryParam = new CsLinePO();
+        queryParam.setPosition(dictData.getId());
+        List<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 "闪变越限超标";
+        }
+        if (StrUtil.equals(key, "freqDevOvertime")) {
+            return "频率偏差超标";
+        }
+        if (StrUtil.equals(key, "voltageDevOvertime")) {
+            return "电压偏差超标";
+        }
+        if (StrUtil.equals(key, "ubalanceOvertime")) {
+            return "三相电压不平衡超标";
+        }
+        // 电压
+        if (StrUtil.startWith(key, "uharm")) {
+            // 从 key 中提取数字 2
+            String number = key.substring(5, key.indexOf("Overtime"));
+            return number + "次谐波电压";
+        }
+        // 电流
+        if (StrUtil.startWith(key, "iharm")) {
+            // 从 key 中提取数字
+            String number = key.substring(5, key.indexOf("Overtime"));
+            return number + "次谐波电流";
+        }
+        return null;
+    }
+
+
+    private double calculatePercentage(double part, double total) {
+        return Double.parseDouble(df.format(BigDecimal.valueOf(part / total * 100.0)
+                .setScale(2, RoundingMode.HALF_UP).doubleValue()));
+    }
+
+}

cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/impl/RStatLimitRateDetailDServiceImpl.java

@@ -0,0 +1,549 @@
+package com.njcn.csharmonic.service.impl;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.lang.Pair;
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONArray;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import com.baomidou.dynamic.datasource.annotation.DS;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.njcn.csdevice.api.CsLineFeignClient;
+import com.njcn.csdevice.api.OverLimitClient;
+import com.njcn.csdevice.pojo.po.CsLinePO;
+import com.njcn.csdevice.pojo.po.Overlimit;
+import com.njcn.csharmonic.mapper.RStatLimitRateDetailDMapper;
+import com.njcn.csharmonic.pojo.param.LimitCalendarQueryParam;
+import com.njcn.csharmonic.pojo.param.LimitExtentDayQueryParam;
+import com.njcn.csharmonic.pojo.param.LimitExtentQueryParam;
+import com.njcn.csharmonic.pojo.param.LimitProbabilityQueryParam;
+import com.njcn.csharmonic.pojo.po.RStatLimitRateDetailDPO;
+import com.njcn.csharmonic.pojo.vo.LimitCalendarVO;
+import com.njcn.csharmonic.pojo.vo.LimitExtentVO;
+import com.njcn.csharmonic.pojo.vo.LimitProbabilityVO;
+import com.njcn.csharmonic.pojo.vo.LimitTimeProbabilityVO;
+import com.njcn.csharmonic.service.IRStatLimitRateDetailDService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
+import java.time.LocalDate;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@DS("sjzx")
+@RequiredArgsConstructor
+@Service
+public class RStatLimitRateDetailDServiceImpl extends ServiceImpl<RStatLimitRateDetailDMapper, RStatLimitRateDetailDPO> implements IRStatLimitRateDetailDService {
+
+    private final CsLineFeignClient csLineFeignClient;
+    private final OverLimitClient overLimitClient;
+
+    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()));
+    }
+}