Microservice/govern
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master'

Browse Source 
# Conflicts:
#	cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/controller/line/CslineController.java
This commit is contained in:
cdf
2025-12-05 09:13:20 +08:00
parent e6df543f1d f86a3c4167
commit 3753544e5f
53 changed files with 5789 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
cs-device/cs-device-api/src/main/java/com/njcn/csdevice/api/OverLimitClient.java Normal file
View File

@@ -0,0 +1,39 @@
package com.njcn.csdevice.api;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.csdevice.api.fallback.OverLimitFallbackFactory;
import com.njcn.csdevice.pojo.po.Overlimit;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import java.util.List;
import java.util.Map;
/**
* 监测点数据完整性
* @author cdf
* @date 2023/6/7
*/
@FeignClient(value = ServerInfo.CS_DEVICE_BOOT,
path = "/overLimit",
fallbackFactory = OverLimitFallbackFactory.class,contextId = "overLimit")
public interface OverLimitClient {
/**
*
* @author cdf
* @date 2023/6/7
*/
@PostMapping("/getOverLimitByLineIds")
HttpResult<List<Overlimit>> getOverLimitByLineIds(@RequestBody List<String> lineIds);
/**
*
* @author cdf
* @date 2023/6/7
*/
@PostMapping("/getLimitMapsByLineIds")
HttpResult<List<Map<String, Object>>> getLimitMapsByLineIds(@RequestBody List<String> lineIds);
}

49
cs-device/cs-device-api/src/main/java/com/njcn/csdevice/api/fallback/OverLimitFallbackFactory.java Normal file
View File

@@ -0,0 +1,49 @@
package com.njcn.csdevice.api.fallback;
import com.njcn.common.pojo.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.exception.BusinessException;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.csdevice.api.OverLimitClient;
import com.njcn.csdevice.pojo.po.Overlimit;
import com.njcn.device.biz.utils.DeviceEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
/**
* 告警管理熔断降级
* @author yzh
* @date 2022/9/19
*/
@Slf4j
@Component
public class OverLimitFallbackFactory implements FallbackFactory<OverLimitClient> {
@Override
public OverLimitClient create(Throwable throwable) {
//判断抛出异常是否为解码器抛出的业务异常
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException) throwable.getCause();
exceptionEnum = DeviceEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new OverLimitClient() {
@Override
public HttpResult<List<Overlimit>> getOverLimitByLineIds(List<String> lineIds) {
log.error("{}异常，降级处理，异常为：{}", "监测点限值", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<List<Map<String, Object>>> getLimitMapsByLineIds(List<String> lineIds) {
log.error("{}异常，降级处理，异常为：{}", "获取监测点限值map", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

953
cs-device/cs-device-api/src/main/java/com/njcn/csdevice/pojo/po/Overlimit.java Normal file
View File

@@ -0,0 +1,953 @@
package com.njcn.csdevice.pojo.po;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.njcn.device.biz.utils.COverlimit;
import lombok.Data;
import java.io.Serializable;
/**
* <p>
*
* </p>
*
* @author cdf
* @since 2022-01-04
*/
@Data
@TableName("pq_overlimit")
public class Overlimit implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 监测点序号
*/
private String id;
/**
* 频率限值
*/
private Float freqDev;
/**
* 电压波动
*/
private Float voltageFluctuation;
/**
* 电压上偏差限值
*/
private Float voltageDev;
/**
* 电压下偏差限值
*/
private Float uvoltageDev;
/**
* 三相电压不平衡度限值
*/
private Float ubalance;
/**
* 短时电压不平衡度限值
*/
private Float shortUbalance;
/**
* 闪变限值
*/
private Float flicker;
/**
* 电压总谐波畸变率限值
*/
private Float uaberrance;
/**
* 负序电流限值
*/
private Float iNeg;
/**
* 2次谐波电压限值
*/
@TableField("uharm_2")
private Float uharm2;
/**
* 3次谐波电压限值
*/
@TableField("uharm_3")
private Float uharm3;
/**
* 4次谐波电压限值
*/
@TableField("uharm_4")
private Float uharm4;
/**
* 5次谐波电压限值
*/
@TableField("uharm_5")
private Float uharm5;
/**
* 6次谐波电压限值
*/
@TableField("uharm_6")
private Float uharm6;
/**
* 7次谐波电压限值
*/
@TableField("uharm_7")
private Float uharm7;
/**
* 8次谐波电压限值
*/
@TableField("uharm_8")
private Float uharm8;
/**
* 9次谐波电压限值
*/
@TableField("uharm_9")
private Float uharm9;
/**
* 10次谐波电压限值
*/
@TableField("uharm_10")
private Float uharm10;
/**
* 11次谐波电压限值
*/
@TableField("uharm_11")
private Float uharm11;
/**
* 12次谐波电压限值
*/
@TableField("uharm_12")
private Float uharm12;
/**
* 13次谐波电压限值
*/
@TableField("uharm_13")
private Float uharm13;
/**
* 14次谐波电压限值
*/
@TableField("uharm_14")
private Float uharm14;
/**
* 15次谐波电压限值
*/
@TableField("uharm_15")
private Float uharm15;
/**
* 16次谐波电压限值
*/
@TableField("uharm_16")
private Float uharm16;
/**
* 17次谐波电压限值
*/
@TableField("uharm_17")
private Float uharm17;
/**
* 18次谐波电压限值
*/
@TableField("uharm_18")
private Float uharm18;
/**
* 19次谐波电压限值
*/
@TableField("uharm_19")
private Float uharm19;
/**
* 20次谐波电压限值
*/
@TableField("uharm_20")
private Float uharm20;
/**
* 21次谐波电压限值
*/
@TableField("uharm_21")
private Float uharm21;
/**
* 22次谐波电压限值
*/
@TableField("uharm_22")
private Float uharm22;
/**
* 23次谐波电压限值
*/
@TableField("uharm_23")
private Float uharm23;
/**
* 24次谐波电压限值
*/
@TableField("uharm_24")
private Float uharm24;
/**
* 25次谐波电压限值
*/
@TableField("uharm_25")
private Float uharm25;
/**
* 2次谐波电压限值
*/
@TableField("uharm_26")
private Float uharm26;
/**
* 3次谐波电压限值
*/
@TableField("uharm_27")
private Float uharm27;
/**
* 4次谐波电压限值
*/
@TableField("uharm_28")
private Float uharm28;
/**
* 5次谐波电压限值
*/
@TableField("uharm_29")
private Float uharm29;
/**
* 6次谐波电压限值
*/
@TableField("uharm_30")
private Float uharm30;
/**
* 7次谐波电压限值
*/
@TableField("uharm_31")
private Float uharm31;
/**
* 8次谐波电压限值
*/
@TableField("uharm_32")
private Float uharm32;
/**
* 9次谐波电压限值
*/
@TableField("uharm_33")
private Float uharm33;
/**
* 10次谐波电压限值
*/
@TableField("uharm_34")
private Float uharm34;
/**
* 11次谐波电压限值
*/
@TableField("uharm_35")
private Float uharm35;
/**
* 12次谐波电压限值
*/
@TableField("uharm_36")
private Float uharm36;
/**
* 13次谐波电压限值
*/
@TableField("uharm_37")
private Float uharm37;
/**
* 14次谐波电压限值
*/
@TableField("uharm_38")
private Float uharm38;
/**
* 15次谐波电压限值
*/
@TableField("uharm_39")
private Float uharm39;
/**
* 16次谐波电压限值
*/
@TableField("uharm_40")
private Float uharm40;
/**
* 17次谐波电压限值
*/
@TableField("uharm_41")
private Float uharm41;
/**
* 18次谐波电压限值
*/
@TableField("uharm_42")
private Float uharm42;
/**
* 19次谐波电压限值
*/
@TableField("uharm_43")
private Float uharm43;
/**
* 20次谐波电压限值
*/
@TableField("uharm_44")
private Float uharm44;
/**
* 21次谐波电压限值
*/
@TableField("uharm_45")
private Float uharm45;
/**
* 22次谐波电压限值
*/
@TableField("uharm_46")
private Float uharm46;
/**
* 23次谐波电压限值
*/
@TableField("uharm_47")
private Float uharm47;
/**
* 24次谐波电压限值
*/
@TableField("uharm_48")
private Float uharm48;
/**
* 25次谐波电压限值
*/
@TableField("uharm_49")
private Float uharm49;
/**
* 50次谐波电压限值
*/
@TableField("uharm_50")
private Float uharm50;
/**
* 2次谐波电流限值
*/
@TableField("iharm_2")
private Float iharm2;
/**
* 3次谐波电流限值
*/
@TableField("iharm_3")
private Float iharm3;
/**
* 4次谐波电流限值
*/
@TableField("iharm_4")
private Float iharm4;
/**
* 5次谐波电流限值
*/
@TableField("iharm_5")
private Float iharm5;
/**
* 6次谐波电流限值
*/
@TableField("iharm_6")
private Float iharm6;
/**
* 7次谐波电流限值
*/
@TableField("iharm_7")
private Float iharm7;
/**
* 8次谐波电流限值
*/
@TableField("iharm_8")
private Float iharm8;
/**
* 9次谐波电流限值
*/
@TableField("iharm_9")
private Float iharm9;
/**
* 10次谐波电流限值
*/
@TableField("iharm_10")
private Float iharm10;
/**
* 11次谐波电流限值
*/
@TableField("iharm_11")
private Float iharm11;
/**
* 12次谐波电流限值
*/
@TableField("iharm_12")
private Float iharm12;
/**
* 13次谐波电流限值
*/
@TableField("iharm_13")
private Float iharm13;
/**
* 14次谐波电流限值
*/
@TableField("iharm_14")
private Float iharm14;
/**
* 15次谐波电流限值
*/
@TableField("iharm_15")
private Float iharm15;
/**
* 16次谐波电流限值
*/
@TableField("iharm_16")
private Float iharm16;
/**
* 17次谐波电流限值
*/
@TableField("iharm_17")
private Float iharm17;
/**
* 18次谐波电流限值
*/
@TableField("iharm_18")
private Float iharm18;
/**
* 19次谐波电流限值
*/
@TableField("iharm_19")
private Float iharm19;
/**
* 20次谐波电流限值
*/
@TableField("iharm_20")
private Float iharm20;
/**
* 21次谐波电流限值
*/
@TableField("iharm_21")
private Float iharm21;
/**
* 22次谐波电流限值
*/
@TableField("iharm_22")
private Float iharm22;
/**
* 23次谐波电流限值
*/
@TableField("iharm_23")
private Float iharm23;
/**
* 24次谐波电流限值
*/
@TableField("iharm_24")
private Float iharm24;
/**
* 25次谐波电流限值
*/
@TableField("iharm_25")
private Float iharm25;
/**
* 2次谐波电压限值
*/
@TableField("iharm_26")
private Float iharm26;
/**
* 3次谐波电压限值
*/
@TableField("iharm_27")
private Float iharm27;
/**
* 4次谐波电压限值
*/
@TableField("iharm_28")
private Float iharm28;
/**
* 5次谐波电压限值
*/
@TableField("iharm_29")
private Float iharm29;
/**
* 6次谐波电压限值
*/
@TableField("iharm_30")
private Float iharm30;
/**
* 7次谐波电压限值
*/
@TableField("iharm_31")
private Float iharm31;
/**
* 8次谐波电压限值
*/
@TableField("iharm_32")
private Float iharm32;
/**
* 9次谐波电压限值
*/
@TableField("iharm_33")
private Float iharm33;
/**
* 10次谐波电压限值
*/
@TableField("iharm_34")
private Float iharm34;
/**
* 11次谐波电压限值
*/
@TableField("iharm_35")
private Float iharm35;
/**
* 12次谐波电压限值
*/
@TableField("iharm_36")
private Float iharm36;
/**
* 13次谐波电压限值
*/
@TableField("iharm_37")
private Float iharm37;
/**
* 14次谐波电压限值
*/
@TableField("iharm_38")
private Float iharm38;
/**
* 15次谐波电压限值
*/
@TableField("iharm_39")
private Float iharm39;
/**
* 16次谐波电压限值
*/
@TableField("iharm_40")
private Float iharm40;
/**
* 17次谐波电压限值
*/
@TableField("iharm_41")
private Float iharm41;
/**
* 18次谐波电压限值
*/
@TableField("iharm_42")
private Float iharm42;
/**
* 19次谐波电压限值
*/
@TableField("iharm_43")
private Float iharm43;
/**
* 20次谐波电压限值
*/
@TableField("iharm_44")
private Float iharm44;
/**
* 21次谐波电压限值
*/
@TableField("iharm_45")
private Float iharm45;
/**
* 22次谐波电压限值
*/
@TableField("iharm_46")
private Float iharm46;
/**
* 23次谐波电压限值
*/
@TableField("iharm_47")
private Float iharm47;
/**
* 24次谐波电压限值
*/
@TableField("iharm_48")
private Float iharm48;
/**
* 25次谐波电压限值
*/
@TableField("iharm_49")
private Float iharm49;
/**
* 50次谐波电压限值
*/
@TableField("iharm_50")
private Float iharm50;
/**
* 0.5次间谐波电压限值
*/
@TableField("inuharm_1")
private Float inuharm1;
/**
* 1.5次间谐波电压限值
*/
@TableField("inuharm_2")
private Float inuharm2;
/**
* 2.5次间谐波电压限值
*/
@TableField("inuharm_3")
private Float inuharm3;
/**
* 3.5次间谐波电压限值
*/
@TableField("inuharm_4")
private Float inuharm4;
/**
* 4.5次间谐波电压限值
*/
@TableField("inuharm_5")
private Float inuharm5;
/**
* 5.5次间谐波电压限值
*/
@TableField("inuharm_6")
private Float inuharm6;
/**
* 6.5次间谐波电压限值
*/
@TableField("inuharm_7")
private Float inuharm7;
/**
* 7.5次间谐波电压限值
*/
@TableField("inuharm_8")
private Float inuharm8;
/**
* 8.5次间谐波电压限值
*/
@TableField("inuharm_9")
private Float inuharm9;
/**
* 9.5次间谐波电压限值
*/
@TableField("inuharm_10")
private Float inuharm10;
/**
* 10.5次间谐波电压限值
*/
@TableField("inuharm_11")
private Float inuharm11;
/**
* 11.5次间谐波电压限值
*/
@TableField("inuharm_12")
private Float inuharm12;
/**
* 12.5次间谐波电压限值
*/
@TableField("inuharm_13")
private Float inuharm13;
/**
* 13.5次间谐波电压限值
*/
@TableField("inuharm_14")
private Float inuharm14;
/**
* 14.5次间谐波电压限值
*/
@TableField("inuharm_15")
private Float inuharm15;
/**
* 15.5次间谐波电压限值
*/
@TableField("inuharm_16")
private Float inuharm16;
public Overlimit(){}
public Overlimit(String lineId, String scaTmp, float fDLRL, float fJZRL, float fXYRL, float fSBRL){
float[] fLimit = COverlimit.GetOverLimit(scaTmp, fDLRL, fJZRL, fXYRL, fSBRL);
this.id=lineId;
this.freqDev=fLimit[0];
this.voltageDev=fLimit[1];
this.ubalance=fLimit[2];
this.flicker=fLimit[3];
this.uaberrance=fLimit[4];
this.uharm2=fLimit[5];
this.uharm3=fLimit[6];
this.uharm4=fLimit[7];
this.uharm5=fLimit[8];
this.uharm6=fLimit[9];
this.uharm7=fLimit[10];
this.uharm8=fLimit[11];
this.uharm9=fLimit[12];
this.uharm10=fLimit[13];
this.uharm11=fLimit[14];
this.uharm12=fLimit[15];
this.uharm13=fLimit[16];
this.uharm14=fLimit[17];
this.uharm15=fLimit[18];
this.uharm16=fLimit[19];
this.uharm17=fLimit[20];
this.uharm18=fLimit[21];
this.uharm19=fLimit[22];
this.uharm20=fLimit[23];
this.uharm21=fLimit[24];
this.uharm22=fLimit[25];
this.uharm23=fLimit[26];
this.uharm24=fLimit[27];
this.uharm25=fLimit[28];
this.iharm2=fLimit[29];
this.iharm3=fLimit[30];
this.iharm4=fLimit[31];
this.iharm5=fLimit[32];
this.iharm6=fLimit[33];
this.iharm7=fLimit[34];
this.iharm8=fLimit[35];
this.iharm9=fLimit[36];
this.iharm10=fLimit[37];
this.iharm11=fLimit[38];
this.iharm12=fLimit[39];
this.iharm13=fLimit[40];
this.iharm14=fLimit[41];
this.iharm15=fLimit[42];
this.iharm16=fLimit[43];
this.iharm17=fLimit[44];
this.iharm18=fLimit[45];
this.iharm19=fLimit[46];
this.iharm20=fLimit[47];
this.iharm21=fLimit[48];
this.iharm22=fLimit[49];
this.iharm23=fLimit[50];
this.iharm24=fLimit[51];
this.iharm25=fLimit[52];
this.uvoltageDev=fLimit[53];
this.iNeg=fLimit[54];
this.inuharm1=fLimit[55];
this.inuharm2=fLimit[56];
this.inuharm3=fLimit[57];
this.inuharm4=fLimit[58];
this.inuharm5=fLimit[59];
this.inuharm6=fLimit[60];
this.inuharm7=fLimit[61];
this.inuharm8=fLimit[62];
this.inuharm9=fLimit[63];
this.inuharm10=fLimit[64];
this.inuharm11=fLimit[65];
this.inuharm12=fLimit[66];
this.inuharm13=fLimit[67];
this.inuharm14=fLimit[68];
this.inuharm15=fLimit[69];
this.inuharm16=fLimit[70];
}
public void buildIHarm(Float[] iHarmTem){
this.iharm2= iHarmTem[0];
this.iharm4= iHarmTem[2];
this.iharm6= iHarmTem[4];
this.iharm8= iHarmTem[6];
this.iharm10= iHarmTem[8];
this.iharm12= iHarmTem[10];
this.iharm14= iHarmTem[12];
this.iharm16= iHarmTem[14];
this.iharm18= iHarmTem[16];
this.iharm20= iHarmTem[18];
this.iharm22= iHarmTem[20];
this.iharm24= iHarmTem[22];
this.iharm26= iHarmTem[24];
this.iharm28= iHarmTem[26];
this.iharm30= iHarmTem[28];
this.iharm32= iHarmTem[30];
this.iharm34= iHarmTem[32];
this.iharm36= iHarmTem[34];
this.iharm38= iHarmTem[36];
this.iharm40= iHarmTem[38];
this.iharm42= iHarmTem[40];
this.iharm44= iHarmTem[42];
this.iharm46= iHarmTem[44];
this.iharm48= iHarmTem[46];
this.iharm50= iHarmTem[48];
this.iharm3= iHarmTem[1];
this.iharm5= iHarmTem[3];
this.iharm7= iHarmTem[5];
this.iharm9= iHarmTem[7];
this.iharm11= iHarmTem[9];
this.iharm13= iHarmTem[11];
this.iharm15= iHarmTem[13];
this.iharm17= iHarmTem[15];
this.iharm19= iHarmTem[17];
this.iharm21= iHarmTem[19];
this.iharm23= iHarmTem[21];
this.iharm25= iHarmTem[23];
this.iharm27= iHarmTem[25];
this.iharm29= iHarmTem[27];
this.iharm31= iHarmTem[29];
this.iharm33= iHarmTem[31];
this.iharm35= iHarmTem[33];
this.iharm37= iHarmTem[35];
this.iharm39= iHarmTem[37];
this.iharm41= iHarmTem[39];
this.iharm43= iHarmTem[41];
this.iharm45= iHarmTem[43];
this.iharm47= iHarmTem[45];
this.iharm49= iHarmTem[47];
}
public void buildUharm(Float resultEven,Float resultOdd){
this.uharm2=resultEven;
this.uharm4=resultEven;
this.uharm6=resultEven;
this.uharm8=resultEven;
this.uharm10=resultEven;
this.uharm12=resultEven;
this.uharm14=resultEven;
this.uharm16=resultEven;
this.uharm18=resultEven;
this.uharm20=resultEven;
this.uharm22=resultEven;
this.uharm24=resultEven;
this.uharm26=resultEven;
this.uharm28=resultEven;
this.uharm30=resultEven;
this.uharm32=resultEven;
this.uharm34=resultEven;
this.uharm36=resultEven;
this.uharm38=resultEven;
this.uharm40=resultEven;
this.uharm42=resultEven;
this.uharm44=resultEven;
this.uharm46=resultEven;
this.uharm48=resultEven;
this.uharm50=resultEven;
this.uharm3=resultOdd;
this.uharm5=resultOdd;
this.uharm7=resultOdd;
this.uharm9=resultOdd;
this.uharm11=resultOdd;
this.uharm13=resultOdd;
this.uharm15=resultOdd;
this.uharm17=resultOdd;
this.uharm19=resultOdd;
this.uharm21=resultOdd;
this.uharm23=resultOdd;
this.uharm25=resultOdd;
this.uharm27=resultOdd;
this.uharm29=resultOdd;
this.uharm31=resultOdd;
this.uharm33=resultOdd;
this.uharm35=resultOdd;
this.uharm37=resultOdd;
this.uharm39=resultOdd;
this.uharm41=resultOdd;
this.uharm43=resultOdd;
this.uharm45=resultOdd;
this.uharm47=resultOdd;
this.uharm49=resultOdd;
}
}

120
cs-device/cs-device-api/src/main/java/com/njcn/csdevice/pojo/vo/LineOverLimitVO.java Normal file
View File

@@ -0,0 +1,120 @@
package com.njcn.csdevice.pojo.vo;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* @author denghuajun
* @date 2022/2/23
*
*/
@Data
@ApiModel
public class LineOverLimitVO {
@ApiModelProperty(name = "freqDev",value = "频率限值")
private Float freqDev;
@ApiModelProperty(name = "voltageDev",value = "电压上偏差限值")
private Float voltageDev;
@ApiModelProperty(name = "uvoltageDev",value = "电压下偏差限值")
private Float uvoltageDev;
@ApiModelProperty(name = "ubalance",value = "三相电压不平衡度限值")
private Float ubalance;
@ApiModelProperty(name = "iNeg",value = "负序电流")
private Float iNeg;
@ApiModelProperty(name = "flicker",value = "长时闪变限值")
private Float flicker;
@ApiModelProperty(name = "uaberrance",value = "电压总谐波畸变率限值")
private Float uaberrance;
@ApiModelProperty(name = "oddHarm",value = "奇次谐波含有率限值")
private Float oddHarm;
@ApiModelProperty(name = "evenHarm",value = "偶次谐波含有率限值")
private Float evenHarm;
@ApiModelProperty(name = "iharm2",value = "2次谐波电流幅值限值")
private Float iharm2;
@ApiModelProperty(name = "iharm3",value = "3次谐波电流幅值限值")
private Float iharm3;
@ApiModelProperty(name = "iharm4",value = "4次谐波电流幅值限值")
private Float iharm4;
@ApiModelProperty(name = "iharm5",value = "5次谐波电流幅值限值")
private Float iharm5;
@ApiModelProperty(name = "iharm6",value = "6次谐波电流幅值限值")
private Float iharm6;
@ApiModelProperty(name = "iharm7",value = "7次谐波电流幅值限值")
private Float iharm7;
@ApiModelProperty(name = "iharm8",value = "8次谐波电流幅值限值")
private Float iharm8;
@ApiModelProperty(name = "iharm9",value = "9次谐波电流幅值限值")
private Float iharm9;
@ApiModelProperty(name = "iharm10",value = "10次谐波电流幅值限值")
private Float iharm10;
@ApiModelProperty(name = "iharm11",value = "11次谐波电流幅值限值")
private Float iharm11;
@ApiModelProperty(name = "iharm12",value = "12次谐波电流幅值限值")
private Float iharm12;
@ApiModelProperty(name = "iharm13",value = "13次谐波电流幅值限值")
private Float iharm13;
@ApiModelProperty(name = "iharm14",value = "14次谐波电流幅值限值")
private Float iharm14;
@ApiModelProperty(name = "iharm15",value = "15次谐波电流幅值限值")
private Float iharm15;
@ApiModelProperty(name = "iharm16",value = "16次谐波电流幅值限值")
private Float iharm16;
@ApiModelProperty(name = "iharm17",value = "17次谐波电流幅值限值")
private Float iharm17;
@ApiModelProperty(name = "iharm18",value = "18次谐波电流幅值限值")
private Float iharm18;
@ApiModelProperty(name = "iharm19",value = "19次谐波电流幅值限值")
private Float iharm19;
@ApiModelProperty(name = "iharm20",value = "20次谐波电流幅值限值")
private Float iharm20;
@ApiModelProperty(name = "iharm21",value = "21次谐波电流幅值限值")
private Float iharm21;
@ApiModelProperty(name = "iharm22",value = "22次谐波电流幅值限值")
private Float iharm22;
@ApiModelProperty(name = "iharm23",value = "23次谐波电流幅值限值")
private Float iharm23;
@ApiModelProperty(name = "iharm24",value = "24次谐波电流幅值限值")
private Float iharm24;
@ApiModelProperty(name = "iharm25",value = "25次谐波电流幅值限值")
private Float iharm25;
@ApiModelProperty(name = "inUharm",value = "0.5-1.5次间谐波电压幅值限值")
private Float inUharm;
@ApiModelProperty(name = "inUharm16",value = "2.5-15.5次间谐波电压幅值限值")
private Float inUharm16;
}

383
cs-device/cs-device-api/src/main/java/com/njcn/csdevice/utils/COverlimitUtil.java Normal file
View File

@@ -0,0 +1,383 @@
package com.njcn.csdevice.utils;
import com.njcn.csdevice.pojo.po.Overlimit;
import com.njcn.device.biz.enums.RunFlagEnum;
import com.njcn.system.enums.DicDataEnum;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Objects;
/**
* pqs
* 限值计算工具类
*
* @author cdf
* @date 2023/5/15
*/
public class COverlimitUtil {
/**
* 谐波电流系数
*/
private static final double[][] ARR = {
{78, 62, 39, 62, 26, 44, 19, 21, 16, 28, 13, 24, 11, 12, 9.7, 18, 8.6, 16, 7.8, 8.9, 7.1, 14, 6.5, 12, 6.0, 6.9, 5.6, 11, 5.2, 10, 4.9, 5.6, 4.6, 8.9, 4.3, 8.4, 4.1, 4.8, 3.9, 7.6, 3.7, 7.2, 3.5, 4.1, 3.4, 6.6, 3.3, 6.3, 3.1},
{43, 34, 21, 34, 14, 24, 11, 11, 8.5, 16, 7.1, 13, 6.1, 6.8, 5.3, 10, 4.7, 9, 4.3, 4.9, 3.9, 7.4, 3.6, 6.8, 3.3, 3.8, 3.1, 5.9, 2.9, 5.5, 2.7, 3.1, 2.5, 4.9, 2.4, 4.6, 2.3, 2.6, 2.2, 4.1, 2.0, 4.0, 2.0, 2.3, 1.9, 3.6, 1.8, 3.5, 1.7},
{26, 20, 13, 20, 8.5, 15, 6.4, 6.8, 5.1, 9.3, 4.3, 7.9, 3.7, 4.1, 3.2, 6, 2.8, 5.4, 2.6, 2.9, 2.3, 4.5, 2.1, 4.1, 2.0, 2.2, 1.9, 3.4, 1.7, 3.2, 1.6, 1.8, 1.5, 2.9, 1.4, 2.7, 1.4, 1.5, 1.3, 2.4, 1.2, 2.3, 1.2, 1.3, 1.1, 2.1, 1.1, 2.0, 1.0},
{15, 12, 7.7, 12, 5.1, 8.8, 3.8, 4.1, 3.1, 5.6, 2.6, 4.7, 2.2, 2.5, 1.9, 3.6, 1.7, 3.2, 1.5, 1.8, 1.4, 2.7, 1.3, 2.5, 1.2, 1.3, 1.1, 2.1, 1.0, 1.9, 0.9, 1.1, 0.9, 1.7, 0.8, 1.6, 0.8, 0.9, 0.8, 1.5, 0.7, 1.4, 0.7, 0.8, 0.7, 1.3, 0.6, 1.2, 0.6},
{16, 13, 8.1, 13, 5.4, 9.3, 4.1, 4.3, 3.3, 5.9, 2.7, 5, 2.3, 2.6, 2, 3.8, 1.8, 3.4, 1.6, 1.9, 1.5, 2.8, 1.4, 2.6, 1.2, 1.4, 1.1, 2.2, 1.1, 2.1, 1.0, 1.2, 0.9, 1.9, 0.9, 1.8, 0.8, 1.0, 0.8, 1.6, 0.8, 1.5, 0.7, 0.9, 0.7, 1.4, 0.7, 1.3, 0.6},
{12, 9.6, 6, 9.6, 4, 6.8, 3, 3.2, 2.4, 4.3, 2, 3.7, 1.7, 1.9, 1.5, 2.8, 1.3, 2.5, 1.2, 1.4, 1.1, 2.1, 1, 1.9, 0.9, 1.1, 0.9, 1.7, 0.8, 1.5, 0.8, 0.9, 0.7, 1.4, 0.7, 1.3, 0.6, 0.7, 0.6, 1.2, 0.6, 1.1, 0.5, 0.6, 0.5, 1.0, 0.5, 1.0, 0.5}
};
/**
* 计算监测点限值
* @param voltageLevel 电压等级（10kV = 10 220kV = 220 ）
* @param protocolCapacity 协议容量
* @param devCapacity 设备容量
* @param shortCapacity 短路容量
* @param powerFlag 0.用户侧 1.电网侧
* @param lineType 0.主网 1.配网 需要注意配网目前没有四种容量，谐波电流幅值限值,负序电流限值无法计算默认-3.14159
*/
public static Overlimit globalAssemble(Float voltageLevel, Float protocolCapacity, Float devCapacity,
Float shortCapacity, Integer powerFlag, Integer lineType) {
Overlimit overlimit = new Overlimit();
voltageDeviation(overlimit,voltageLevel);
frequency(overlimit);
voltageFluctuation(overlimit,voltageLevel);
voltageFlicker(overlimit,voltageLevel);
totalHarmonicDistortion(overlimit,voltageLevel);
uHarm(overlimit,voltageLevel);
threeVoltageUnbalance(overlimit);
interharmonicCurrent(overlimit,voltageLevel);
if(Objects.equals(lineType, RunFlagEnum.PW_FLAG.getStatus())) {
//配网
Float[] iHarmTem = new Float[49];
for (int i = 0; i <= 48; i++) {
iHarmTem[i] = -3.14159f;
}
overlimit.buildIHarm(iHarmTem);
overlimit.setINeg(-3.14159f);
}else {
//主网
iHarm(overlimit, voltageLevel, protocolCapacity, devCapacity, shortCapacity);
negativeSequenceCurrent(overlimit, voltageLevel, shortCapacity);
}
return overlimit;
}
/**
* 电压偏差限值
*
*/
public static void voltageDeviation(Overlimit overlimit,Float voltageLevel) {
float voltageDev = 3.14159f,uvoltageDev = 3.14159f;
if(voltageLevel <= Float.parseFloat(DicDataEnum.V220.getCode())){
voltageDev = 7.0f;
uvoltageDev=-10.0f;
}else if(voltageLevel>Float.parseFloat(DicDataEnum.V220.getCode())&&voltageLevel<Float.parseFloat(DicDataEnum.KV20.getCode())){
voltageDev = 7.0f;
uvoltageDev=-7.0f;
}else if(voltageLevel>=Float.parseFloat(DicDataEnum.KV20.getCode())&&voltageLevel<Float.parseFloat(DicDataEnum.KV35.getCode())){
voltageDev = 7.0f;
uvoltageDev=-7.0f;
}else if(voltageLevel>=Float.parseFloat(DicDataEnum.KV35.getCode())&&voltageLevel<Float.parseFloat(DicDataEnum.KV66.getCode())){
voltageDev = 10.0f;
uvoltageDev=-10.0f;
}else if(voltageLevel>=Float.parseFloat(DicDataEnum.KV66.getCode())&&voltageLevel<=Float.parseFloat(DicDataEnum.KV110.getCode())){
voltageDev = 7.0f;
uvoltageDev=-3.0f;
}else if(voltageLevel>Float.parseFloat(DicDataEnum.KV110.getCode())){
voltageDev = 10.0f;
uvoltageDev=-10.0f;
}
overlimit.setVoltageDev(voltageDev);
overlimit.setUvoltageDev(uvoltageDev);
}
/**
* 频率偏差
* 默认限值：±0.2Hz（即：-0.2 Hz≤限值≤0.2 Hz）
*/
public static void frequency(Overlimit overlimit) {
overlimit.setFreqDev(0.2f);
}
/**
* 电压波动
* 对LV、MV：0≤限值≤3%；对HV：0≤限值≤2.5%。
* LV、MV、HV的定义：
* 低压（LV） UN≤1kV
* 中压（MV） 1kV＜UN≤35kV
* 高压（HV） 35kV＜UN≤220kV
* 超高压（EHV），220kV＜UN，参照HV执行
*/
public static void voltageFluctuation(Overlimit overlimit, Float voltageLevel) {
if (voltageLevel < Float.parseFloat(DicDataEnum.KV35.getCode())) {
overlimit.setVoltageFluctuation(3.0f);
} else {
overlimit.setVoltageFluctuation(2.5f);
}
}
/**
* 电压闪变
* ≤110kV 1
* ＞110kV 0.8
*/
public static void voltageFlicker(Overlimit overlimit, Float voltageLevel) {
if (voltageLevel <= Float.parseFloat(DicDataEnum.KV110.getCode())) {
overlimit.setFlicker(1.0f);
} else {
overlimit.setFlicker(0.8f);
}
}
/**
* 总谐波电压畸变率
*
*
*/
public static void totalHarmonicDistortion(Overlimit overlimit, Float voltageLevel) {
float result = 3.14159f;
if (voltageLevel < Float.parseFloat(DicDataEnum.KV6.getCode())) {
result = 5.0f;
} else if(voltageLevel >= Float.parseFloat(DicDataEnum.KV6.getCode()) && voltageLevel <= Float.parseFloat(DicDataEnum.KV20.getCode())){
result = 4.0f;
} else if(voltageLevel >= Float.parseFloat(DicDataEnum.KV35.getCode()) && voltageLevel <= Float.parseFloat(DicDataEnum.KV66.getCode())){
result = 3.0f;
} else if(voltageLevel >= Float.parseFloat(DicDataEnum.KV110.getCode()) && voltageLevel <= Float.parseFloat(DicDataEnum.KV1000.getCode())){
result = 2.0f;
}
overlimit.setUaberrance(result);
}
/**
* 谐波电压含有率
*/
public static void uHarm(Overlimit overlimit, Float voltageLevel) {
float resultOdd = 3.14159f,resultEven = 3.14159f;
if (voltageLevel < Float.parseFloat(DicDataEnum.KV6.getCode())) {
resultOdd = 4.0f;
resultEven = 2.0f;
} else if(voltageLevel >= Float.parseFloat(DicDataEnum.KV6.getCode()) && voltageLevel <= Float.parseFloat(DicDataEnum.KV20.getCode())){
resultOdd = 3.2f;
resultEven = 1.6f;
} else if(voltageLevel >= Float.parseFloat(DicDataEnum.KV35.getCode()) && voltageLevel <= Float.parseFloat(DicDataEnum.KV66.getCode())){
resultOdd = 2.4f;
resultEven = 1.2f;
} else if(voltageLevel >= Float.parseFloat(DicDataEnum.KV110.getCode()) && voltageLevel <= Float.parseFloat(DicDataEnum.KV1000.getCode())){
resultOdd = 1.6f;
resultEven = 0.8f;
}
overlimit.buildUharm(resultEven,resultOdd);
}
/**
* 负序电压不平衡（三相电压不平衡度）
*
*/
public static void threeVoltageUnbalance(Overlimit overlimit) {
overlimit.setUbalance(2.0f);
overlimit.setShortUbalance(4.0f);
}
/*---------------------------------谐波电流限值start-----------------------------------*/
/**
* 谐波电流限值
*/
public static void iHarm(Overlimit overlimit, Float voltageLevel,Float protocolCapacity,Float devCapacity,Float shortCapacity) {
float calCap = shortCapacity/getDlCapByVoltageLevel(voltageLevel);
//24谐波电流幅值
Float[] iHarmTem = new Float[49];
for (int i = 0; i <= 48; i++) {
float inHarm = iHarmCalculate(i+2,voltageLevel,protocolCapacity,devCapacity,calCap);
iHarmTem[i] = inHarm;
}
overlimit.buildIHarm(iHarmTem);
}
/**
* @Description: iHarmCalculate
* @Param: protocolCapacity 协议容量 devCapacity设备容量 calCap 短路容量
* @return: float
* @Author: clam
* @Date: 2024/2/4
*/
private static float iHarmCalculate(int nHarm, Float voltageLevel,float protocolCapacity, float devCapacity,float calCap) {
double tag = calCap*getHarmTag(nHarm,voltageLevel);
Double limit = getHarmonicLimit(nHarm,tag,new BigDecimal(String.valueOf(devCapacity)).doubleValue(),new BigDecimal(String.valueOf(protocolCapacity)).doubleValue());
BigDecimal bigDecimal = BigDecimal.valueOf(limit).setScale(4,RoundingMode.HALF_UP);
return bigDecimal.floatValue();
}
/**
* 电流谐波限值
*/
private static Double getHarmTag(Integer iCount, Float voltageLevel) {
int x, y;
if (voltageLevel < DicDataEnum.KV6.getValue()) {
x = 0;
} else if (voltageLevel<DicDataEnum.KV10.getValue()) {
x = 1;
} else if (voltageLevel<DicDataEnum.KV35.getValue()) {
x = 2;
} else if (voltageLevel<DicDataEnum.KV66.getValue()) {
x = 3;
} else if (voltageLevel<DicDataEnum.KV110.getValue()) {
x = 4;
} else {
x = 5;
}
y = iCount - 2;
return ARR[x][y];
}
/**
* 相位叠加系数的取值
*/
public static Double getHarmonicLimit(Integer times, double iTag, double supply, double user) {
if (supply == 0) {
return 0.0;
}
double coefficient = 2.0;
if (times == 3) {
coefficient = 1.1;
} else if (times == 5) {
coefficient = 1.2;
} else if (times == 7) {
coefficient = 1.4;
} else if (times == 11) {
coefficient = 1.8;
} else if (times == 13) {
coefficient = 1.9;
}
BigDecimal bd = new BigDecimal(iTag * Math.pow((user / supply), (1 / coefficient)));
bd = bd.setScale(6, RoundingMode.HALF_UP);
return Double.parseDouble(bd.toString());
}
/**
* 根据电压等级获取基准短路容量
*/
public static float getDlCapByVoltageLevel(Float voltageLevel){
float capValue;
if(voltageLevel< DicDataEnum.KV06.getValue()){
capValue = 10;
}else if(voltageLevel<DicDataEnum.KV20.getValue()){
capValue = 100;
}else if(voltageLevel<DicDataEnum.KV35.getValue()){
capValue = 200;
}else if(voltageLevel<DicDataEnum.KV66.getValue()){
capValue = 250;
}else if(voltageLevel<DicDataEnum.KV110.getValue()){
capValue = 500;
}else if(voltageLevel<DicDataEnum.KV220.getValue()){
capValue = 750;
}else if(voltageLevel<DicDataEnum.KV330.getValue()){
capValue = 2000;
}else if(voltageLevel<DicDataEnum.KV500.getValue()){
capValue = 3000;
}else if(voltageLevel<DicDataEnum.KV750.getValue()){
capValue = 4500;
}else if(voltageLevel<DicDataEnum.KV1000.getValue()){
capValue = 7000;
}else {
capValue = 9000;
}
return capValue;
}
/*---------------------------------谐波电流限值end-----------------------------------*/
/**
* 间谐波电压含有率
*/
public static void interharmonicCurrent(Overlimit overlimit,Float voltageLevel){
float aValue,bValue;
if(voltageLevel <= DicDataEnum.KV1.getValue()){
aValue = 0.2f;bValue = 0.5f;
}else {
aValue = 0.16f;bValue = 0.4f;
}
overlimit.setInuharm1(aValue);
overlimit.setInuharm2(aValue);
overlimit.setInuharm3(bValue);
overlimit.setInuharm4(bValue);
overlimit.setInuharm5(bValue);
overlimit.setInuharm6(bValue);
overlimit.setInuharm7(bValue);
overlimit.setInuharm8(bValue);
overlimit.setInuharm9(bValue);
overlimit.setInuharm10(bValue);
overlimit.setInuharm11(bValue);
overlimit.setInuharm12(bValue);
overlimit.setInuharm13(bValue);
overlimit.setInuharm14(bValue);
overlimit.setInuharm15(bValue);
overlimit.setInuharm16(bValue);
}
/**
* 负序电流限值
*/
public static void negativeSequenceCurrent(Overlimit overlimit,Float voltageLevel,Float shortCapacity){
double v = (0.013*shortCapacity*1000)/(getUl(voltageLevel)*Math.sqrt(3));
overlimit.setINeg((float) v);
}
/**
* 获取额定线电压
*/
private static float getUl(Float voltageLevel){
float value;
if(voltageLevel<DicDataEnum.KV6.getValue()){
value = 0.4f;
}else if(voltageLevel<DicDataEnum.KV10.getValue()){
value = 6.3f;
}else if(voltageLevel<DicDataEnum.KV20.getValue()){
value = 10.5f;
}else if(voltageLevel<DicDataEnum.KV35.getValue()){
value = 21.0f;
}else if(voltageLevel<DicDataEnum.KV66.getValue()){
value = 36.5f;
}else if(voltageLevel<DicDataEnum.KV110.getValue()){
value = 69.0f;
}else if(voltageLevel<DicDataEnum.KV220.getValue()){
value = 115.5f;
}else if(voltageLevel<DicDataEnum.KV330.getValue()){
value = 230.0f;
}else {
value = 345.0f;
}
return value;
}
public static void main(String[] args) {
System.out.println("sss");
float aa = iHarmCalculate(9,500f,10,10,0.002222222222f);
System.out.println(aa);
}
}

104
cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/controller/PQOverlimitController.java Normal file
View File

@@ -0,0 +1,104 @@
package com.njcn.csdevice.controller;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.csdevice.pojo.po.Overlimit;
import com.njcn.csdevice.pojo.vo.LineOverLimitVO;
import com.njcn.csdevice.service.IOverLimitService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
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 springfox.documentation.annotations.ApiIgnore;
import java.util.List;
import java.util.Map;
@Slf4j
@RestController
@RequiredArgsConstructor
@Api(tags = "监测点限值信息查询")
public class PQOverlimitController extends BaseController {
private final IOverLimitService overLimitService;
// -------- 3个重复的代码！！！！ ----------
/**
* 来源于CommTerminalController的getOverLimitData
*/
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/commTerminal/getOverLimitData")
@ApiOperation("根据监测点id获取越限数值")
@ApiImplicitParam(name = "id", value = "监测点id", required = true)
public HttpResult<Overlimit> getOverLimitDataTerminal(@RequestParam("id") String id) {
String methodDescribe = getMethodDescribe("getOverLimitData");
Overlimit result = overLimitService.getOverLimitDataById(id);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/line/getOverLimitData")
@ApiOperation("根据监测点id获取越限数值")
@ApiImplicitParam(name = "id", value = "监测点id", required = true)
public HttpResult<Overlimit> getOverLimitData(@RequestParam("id") String id) {
String methodDescribe = getMethodDescribe("getOverLimitData");
Overlimit result = overLimitService.getOverLimitDataById(id);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/line/getLineOverLimitData")
@ApiOperation("根据监测点id获取越限详情")
@ApiImplicitParam(name = "id", value = "监测点id", required = true)
public HttpResult<LineOverLimitVO> getLineOverLimitData(@RequestParam("id") String id) {
String methodDescribe = getMethodDescribe("getLineOverLimitData");
LineOverLimitVO result = overLimitService.getLineOverLimitDataById(id);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/overLimit/getOverLimitByLineIds")
@ApiOperation("监测点集合获取限值")
@ApiImplicitParam(name = "lineIds", value = "监测点ids", required = true)
@ApiIgnore
public HttpResult<List<Overlimit>> getOverLimitByLineIds(@RequestBody List<String> lineIds){
String methodDescribe = getMethodDescribe("getOverLimitByLineIds");
List<Overlimit> overLimitList= overLimitService.list(new LambdaQueryWrapper<Overlimit>().in(Overlimit::getId,lineIds));
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, overLimitList, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/commTerminal/getOverLimitDataByIds")
@ApiOperation("根据监测点id集合获取越限数值")
@ApiImplicitParam(name = "ids", value = "监测点id集合", required = true)
public HttpResult<List<Overlimit>> getOverLimitDataByIds(@RequestBody List<String> ids) {
String methodDescribe = getMethodDescribe("getOverLimitDataByIds");
List<Overlimit> result = overLimitService.listByIds(ids);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/overLimit/getLimitMapsByLineIds")
@ApiOperation("监测点集合获取限值")
@ApiImplicitParam(name = "lineIds", value = "监测点ids", required = true)
@ApiIgnore
public HttpResult<List<Map<String, Object>>> getLimitMapsByLineIds(@RequestBody List<String> lineIds){
String methodDescribe = getMethodDescribe("getLimitMapsByLineIds");
List<Map<String, Object>> overLimitList= overLimitService.listMaps(new LambdaQueryWrapper<Overlimit>().in(Overlimit::getId,lineIds));
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, overLimitList, methodDescribe);
}
}

4
cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/controller/line/CslineController.java
View File

@@ -12,10 +12,10 @@ import com.njcn.csdevice.mapper.OverlimitMapper;
import com.njcn.csdevice.pojo.param.CsLineParam;
import com.njcn.csdevice.pojo.po.CsLinePO;
import com.njcn.csdevice.pojo.vo.LineDetailDataVO;
import com.njcn.csdevice.pojo.po.Overlimit;
import com.njcn.csdevice.pojo.vo.PqSensitiveUserLineVO;
import com.njcn.csdevice.service.CsLinePOService;
import com.njcn.device.biz.pojo.po.Overlimit;
import com.njcn.device.biz.utils.COverlimitUtil;
import com.njcn.csdevice.utils.COverlimitUtil;
import com.njcn.web.controller.BaseController;
import com.njcn.web.pojo.param.BaseParam;
import io.swagger.annotations.*;

2
cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/mapper/OverlimitMapper.java
View File

@@ -3,7 +3,7 @@ package com.njcn.csdevice.mapper;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.njcn.device.biz.pojo.po.Overlimit;
import com.njcn.csdevice.pojo.po.Overlimit;
import org.apache.ibatis.annotations.Mapper;

20
cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/mapper/mapping/OverlimitMapper.xml Normal file
View File

@@ -0,0 +1,20 @@
<?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.device.overlimit.mapper.OverlimitMapper">
<select id="getAllLineOverLimit" resultType="com.njcn.device.biz.pojo.po.Overlimit">
select f.* from pq_line a
inner join pq_line_detail b on a.id = b.id
inner join pq_line c on a.pid = c.id
inner join pq_line d on c.pid = d.id
inner join pq_device e on d.id = e.id
inner join pq_overlimit f on a.id=f.id
where e.dev_data_type in
<foreach collection="list" item="item" open="(" close=")" separator=",">
#{item}
</foreach>
and e.run_flag = 0
and e.dev_model = 1
</select>
</mapper>

28
cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/IOverLimitService.java Normal file
View File

@@ -0,0 +1,28 @@
package com.njcn.csdevice.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.njcn.csdevice.pojo.po.Overlimit;
import com.njcn.csdevice.pojo.vo.LineOverLimitVO;
/**
* <p>
* 越限表实体
* </p>
*
* @author hongawen
* @since 2023-03-28
*/
public interface IOverLimitService extends IService<Overlimit> {
Overlimit getOverLimitDataById(String id);
/**
* 获取监测点越限详情
* @param id 监测点id
* @return 结果
*/
LineOverLimitVO getLineOverLimitDataById(String id);
}

21
cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/OverlimitServiceImpl.java
View File

@@ -1,21 +0,0 @@
package com.njcn.csdevice.service;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.njcn.device.biz.pojo.po.Overlimit;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.njcn.csdevice.mapper.OverlimitMapper;
import com.njcn.csdevice.service.impl.OverlimitService;
/**
*
* Description:
* Date: 2024/10/22 14:14【需求编号】
*
* @author clam
* @version V1.0.0
*/
@Service
@DS("sjzx")
public class OverlimitServiceImpl extends ServiceImpl<OverlimitMapper, Overlimit> implements OverlimitService{
}

1
cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/CsGroupServiceImpl.java
View File

@@ -37,7 +37,6 @@ import com.njcn.csharmonic.constant.HarmonicConstant;
import com.njcn.csharmonic.param.*;
import com.njcn.csharmonic.pojo.vo.ThdDataTdVO;
import com.njcn.csharmonic.pojo.vo.ThdDataVO;
import com.njcn.device.biz.pojo.po.Overlimit;
import com.njcn.influx.pojo.bo.CommonQueryParam;
import com.njcn.influx.pojo.dto.EventDataSetDTO;
import com.njcn.influx.pojo.dto.StatisticalDataDTO;

3
cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/IcdServiceImpl.java
View File

@@ -22,10 +22,9 @@ import com.njcn.csdevice.pojo.po.*;
import com.njcn.csdevice.pojo.vo.CldLedgerVo;
import com.njcn.csdevice.pojo.vo.DeviceInfo;
import com.njcn.csdevice.service.*;
import com.njcn.csdevice.utils.COverlimitUtil;
import com.njcn.csharmonic.api.EventFeignClient;
import com.njcn.csharmonic.pojo.po.CsEventPO;
import com.njcn.device.biz.pojo.po.Overlimit;
import com.njcn.device.biz.utils.COverlimitUtil;
import com.njcn.mq.message.BZEventMessage;
import com.njcn.mq.template.BZEventMessageTemplate;
import com.njcn.redis.pojo.enums.AppRedisKey;

42
cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/OverLimitServiceImpl.java Normal file
View File

@@ -0,0 +1,42 @@
package com.njcn.csdevice.service.impl;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.njcn.csdevice.mapper.OverlimitMapper;
import com.njcn.csdevice.pojo.po.Overlimit;
import com.njcn.csdevice.pojo.vo.LineOverLimitVO;
import com.njcn.csdevice.service.IOverLimitService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
/**
* pqs
*
* @author cdf
* @date 2023/6/7
*/
@Service
@RequiredArgsConstructor
public class OverLimitServiceImpl extends ServiceImpl<OverlimitMapper, Overlimit> implements IOverLimitService {
@Override
public Overlimit getOverLimitDataById(String id) {
return this.baseMapper.selectById(id);
}
@Override
public LineOverLimitVO getLineOverLimitDataById(String id) {
//根据监测点id查询所在监测点的限值表数据
Overlimit overlimit = this.baseMapper.selectById(id);
LineOverLimitVO lineOverLimitVO = new LineOverLimitVO();
BeanUtil.copyProperties(overlimit, lineOverLimitVO);
lineOverLimitVO.setOddHarm(overlimit.getUharm3());
lineOverLimitVO.setEvenHarm(overlimit.getUharm2());
lineOverLimitVO.setInUharm(overlimit.getInuharm1());
lineOverLimitVO.setInUharm16(overlimit.getInuharm16());
return lineOverLimitVO;
}
}

17
cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/OverlimitService.java
View File

@@ -1,17 +0,0 @@
package com.njcn.csdevice.service.impl;
import com.baomidou.mybatisplus.extension.service.IService;
import com.njcn.device.biz.pojo.po.Overlimit;
/**
*
* Description:
* Date: 2024/10/22 14:14【需求编号】
*
* @author clam
* @version V1.0.0
*/
public interface OverlimitService extends IService<Overlimit>{
}

15
cs-device/cs-device-boot/src/main/java/com/njcn/csdevice/service/impl/WlRecordServiceImpl.java
View File

@@ -18,27 +18,24 @@ import com.njcn.csdevice.api.EquipmentFeignClient;
import com.njcn.csdevice.constant.DataParam;
import com.njcn.csdevice.enums.LineBaseEnum;
import com.njcn.csdevice.mapper.CsDataSetMapper;
import com.njcn.csdevice.mapper.CsEquipmentDeliveryMapper;
import com.njcn.csdevice.mapper.CsLinePOMapper;
import com.njcn.csdevice.mapper.WlRecordMapper;
import com.njcn.csdevice.param.WlRecordPageParam;
import com.njcn.csdevice.pojo.dto.CsEquipmentDeliveryDTO;
import com.njcn.csdevice.pojo.param.WlRecordParam;
import com.njcn.csdevice.pojo.po.CsDataSet;
import com.njcn.csdevice.pojo.po.CsLinePO;
import com.njcn.csdevice.pojo.po.Overlimit;
import com.njcn.csdevice.pojo.po.WlRecord;
import com.njcn.csdevice.pojo.vo.RecordAllDevTreeVo;
import com.njcn.csdevice.pojo.vo.RecordTreeVo;
import com.njcn.csdevice.pojo.vo.RecordVo;
import com.njcn.csdevice.service.IOverLimitService;
import com.njcn.csdevice.service.IWlRecordService;
import com.njcn.csdevice.util.InfluxDbParamUtil;
import com.njcn.csdevice.utils.DataChangeUtil;
import com.njcn.csdevice.utils.COverlimitUtil;
import com.njcn.csdevice.utils.StringUtil;
import com.njcn.csharmonic.constant.HarmonicConstant;
import com.njcn.csharmonic.param.CommonStatisticalQueryParam;
import com.njcn.csharmonic.pojo.vo.ThdDataVO;
import com.njcn.device.biz.pojo.po.Overlimit;
import com.njcn.device.biz.utils.COverlimitUtil;
import com.njcn.influx.imapper.CommonMapper;
import com.njcn.influx.pojo.bo.CommonQueryParam;
import com.njcn.influx.pojo.constant.InfluxDBTableConstant;
@@ -62,7 +59,6 @@ import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@@ -93,10 +89,7 @@ public class WlRecordServiceImpl extends ServiceImpl<WlRecordMapper, WlRecord> i
private final InfluxDbParamUtil influxDbParamUtil;
private final CsLinePOMapper csLinePOMapper;
private final CsEquipmentDeliveryMapper csEquipmentDeliveryMapper;
private final OverlimitService overlimitService;
private final IOverLimitService overlimitService;
private final DicDataFeignClient dicDataFeignClient;
private final DecimalFormat df = new DecimalFormat(DataParam.DecimalFormatStr);

9
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/HarCurrent.java Normal file
View File

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

9
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/HarVoltage.java Normal file
View File

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

11
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/annotaion/InterharVoltage.java Normal file
View File

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

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

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

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

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

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

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

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

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

35
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/MainLineQueryParam.java Normal file
View File

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

23
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/MainLineStatLimitRateDetailsQueryParam.java Normal file
View File

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

27
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/RStatLimitQueryParam.java Normal file
View File

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

39
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/StatSubstationBizBaseParam.java Normal file
View File

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

9
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/TotalLimitStatisticsDetailsQueryParam.java Normal file
View File

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

19
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/param/TotalLimitStatisticsParam.java Normal file
View File

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

614
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/po/RStatLimitRateDPO.java Normal file
View File

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

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

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

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

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

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

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

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

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

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

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

11
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MainLineStatLimitRateDetailsVO.java Normal file
View File

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

21
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MainLineVO.java Normal file
View File

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

145
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/MonitorOverLimitVO.java Normal file
View File

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

34
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/RStatLimitRateDVO.java Normal file
View File

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

207
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitStatisticsDetailsVO.java Normal file
View File

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

15
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitStatisticsVO.java Normal file
View File

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

19
cs-harmonic/cs-harmonic-api/src/main/java/com/njcn/csharmonic/pojo/vo/TotalLimitTotalStatisticsVO.java Normal file
View File

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

5
cs-harmonic/cs-harmonic-boot/pom.xml
View File

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

159
cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/controller/RStatLimitRateDController.java Normal file
View File

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

85
cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/controller/RStatLimitRateDetailDController.java Normal file
View File

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

76
cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/RStatLimitRateDMapper.java Normal file
View File

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

9
cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/RStatLimitRateDetailDMapper.java Normal file
View File

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

475
cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/mapping/RStatLimitRateDMapper.xml Normal file
View File

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

6
cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/mapper/mapping/RStatLimitRateDetailDMapper.xml Normal file
View File

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

48
cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/IRStatLimitRateDService.java Normal file
View File

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

30
cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/IRStatLimitRateDetailDService.java Normal file
View File

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

600
cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/impl/RStatLimitRateDServiceImpl.java Normal file
View File

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

549
cs-harmonic/cs-harmonic-boot/src/main/java/com/njcn/csharmonic/service/impl/RStatLimitRateDetailDServiceImpl.java Normal file
View File

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