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

有功功率稳态表格和详情调整

Browse Source
This commit is contained in:
wr
2025-04-07 21:01:07 +08:00
parent 6cb549102b
commit c5e4562cc9
10 changed files with 447 additions and 296 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/PowerStatisticsParam.java
View File

@@ -24,6 +24,9 @@ public class PowerStatisticsParam extends BaseParam {
@ApiModelProperty("指标分类ID(用于查询指标详细数据的指标分类ID)")
private String statisticalId;
@ApiModelProperty("指标分类ID(用于查询指标详细数据的指标分类ID)")
private String code;
@ApiModelProperty("区间字段(用于查询指标越限列表)")
private String field;

2
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/RActivePowerRangePO.java
View File

@@ -26,7 +26,7 @@ public class RActivePowerRangePO extends BaseEntity {
/**
* 日期（天）
*/
private LocalDate timeId;
private String timeId;
/**
* 0%~10%区间时间Json

24
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/PowerStatisticsTargetVO.java
View File

@@ -40,28 +40,4 @@ public class PowerStatisticsTargetVO {
@ApiModelProperty("电流不平衡度")
private Integer sequenceCurrentUnbalance = 0;
@ApiModelProperty("电压偏差详情")
private List<ThdDataVO> voltageOffsetList = new ArrayList<>();
@ApiModelProperty("谐波电压详情")
private List<ThdDataVO> vTimesList = new ArrayList<>();
@ApiModelProperty("谐波电流详情")
private List<ThdDataVO> iTimestList = new ArrayList<>();
@ApiModelProperty("三相电压不平衡度详情")
private List<ThdDataVO> ubalanceList = new ArrayList<>();
@ApiModelProperty("电压波动")
private List<ThdDataVO> voltageFluctuationList = new ArrayList<>();
@ApiModelProperty("闪变详情")
private List<ThdDataVO> flickerList = new ArrayList<>();
@ApiModelProperty("间谐波电压含有率详情")
private List<ThdDataVO> interHarmonicList = new ArrayList<>();
@ApiModelProperty("电流不平衡度详情")
private List<ThdDataVO> sequenceCurrentUnbalanceList = new ArrayList<>();
}

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

@@ -0,0 +1,177 @@
package com.njcn.harmonic.pojo.vo;
import lombok.Data;
import java.util.List;
/**
* 有功功率趋势 实体类
* @author guofeihu
* @since 2024-08-20
*/
@Data
public class RActivePowerRangeVO {
/**
* 监测点ID
*/
private String lineId;
/**
* 日期（天）
*/
private List<String> timeId;
/**
* 0%~10%区间时间Json
*/
private List<String> minsTime0;
/**
* 0%~10%区间个数
*/
private Integer minsNum0 = 0;
/**
* 0%~10%区间是否越限
*/
private Integer isOrNot0 = 0;
/**
* 10%~20%区间时间Json
*/
private List<String> minsTime1;
/**
* 10%~20%区间个数
*/
private Integer minsNum1 = 0;;
/**
* 10%~20%区间是否越限
*/
private Integer isOrNot1 = 0;
/**
* 20%~30%区间时间Json
*/
private List<String> minsTime2;
/**
* 20%~30%区间个数
*/
private Integer minsNum2 = 0;;
/**
* 20%~30%区间是否越限
*/
private Integer isOrNot2 = 0;
/**
* 30%~40%区间时间Json
*/
private List<String> minsTime3;
/**
* 30%~40%区间个数
*/
private Integer minsNum3 = 0;;
/**
* 30%~40%区间是否越限
*/
private Integer isOrNot3 = 0;
/**
* 40%~50%区间时间Json
*/
private List<String> minsTime4;
/**
* 40%~50%区间个数
*/
private Integer minsNum4 = 0;;
/**
* 40%~50%区间是否越限
*/
private Integer isOrNot4 = 0;
/**
* 50%~60%区间时间Json
*/
private List<String> minsTime5;
/**
* 50%~60%区间个数
*/
private Integer minsNum5 = 0;;
/**
* 50%~60%区间是否越限
*/
private Integer isOrNot5 = 0;
/**
* 60%~70%区间时间Json
*/
private List<String> minsTime6;
/**
* 60%~70%区间个数
*/
private Integer minsNum6 = 0;;
/**
* 60%~70%区间是否越限
*/
private Integer isOrNot6 = 0;
/**
* 70%~80%区间时间Json
*/
private List<String> minsTime7;
/**
* 70%~80%区间个数
*/
private Integer minsNum7 = 0;;
/**
* 70%~80%区间是否越限
*/
private Integer isOrNot7 = 0;
/**
* 80%~90%区间时间Json
*/
private List<String> minsTime8;
/**
* 80%~90%区间个数
*/
private Integer minsNum8 = 0;;
/**
* 80%~90%区间是否越限
*/
private Integer isOrNot8 = 0;
/**
* 90%~100%区间时间Json
*/
private List<String> minsTime9;
/**
* 90%~100%区间个数
*/
private Integer minsNum9 = 0;;
/**
* 90%~100%区间是否越限
*/
private Integer isOrNot9 = 0;
}

6
pqs-harmonic/harmonic-boot/pom.xml
View File

@@ -112,6 +112,12 @@
<artifactId>cs-device-api</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>com.njcn.platform</groupId>
<artifactId>data-processing-api</artifactId>
<version>1.0.0</version>
<scope>compile</scope>
</dependency>
</dependencies>
<build>

2
pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/controller/powerstatistics/PowerStatisticsController.java
View File

@@ -66,7 +66,7 @@ public class PowerStatisticsController extends BaseController {
@ApiOperation("点击越限列表时间查询指标的详细数据")
public HttpResult<List<ThdDataVO>> getTargetByTime(@RequestBody @Validated PowerStatisticsParam powerStatisticsParam) {
String methodDescribe = getMethodDescribe("getTargetByTime");
List<ThdDataVO> targetByTime = powerStatisticsService.getTargetByTime(powerStatisticsParam);
List<ThdDataVO> targetByTime = powerStatisticsService.getTargetByTimeDetail(powerStatisticsParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, targetByTime, methodDescribe);
}

6
pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/PowerStatisticsService.java
View File

@@ -29,11 +29,11 @@ public interface PowerStatisticsService {
List<PowerStatisticsTargetVO> getTargetLimitById(PowerStatisticsParam powerStatisticsParam);
/**
* 点击越限列表时间查询指标的详细数据
* @param powerStatisticsParam
* 查询稳态详情信息
* @param param
* @return
*/
List<ThdDataVO> getTargetByTime(PowerStatisticsParam powerStatisticsParam);
List<ThdDataVO> getTargetByTimeDetail(PowerStatisticsParam param);
/**
* 导出区间数据

7
pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/RActivePowerRangeService.java
View File

@@ -3,6 +3,7 @@ package com.njcn.harmonic.service.activepowerrange;
import com.github.jeffreyning.mybatisplus.service.IMppService;
import com.njcn.harmonic.pojo.po.RActivePowerRangePO;
import com.njcn.harmonic.pojo.vo.PowerStatisticsTargetVO;
import com.njcn.harmonic.pojo.vo.RActivePowerRangeVO;
import com.njcn.prepare.harmonic.pojo.param.RActivePowerRangeParam;
import java.util.List;
@@ -14,14 +15,10 @@ import java.util.List;
*/
public interface RActivePowerRangeService extends IMppService<RActivePowerRangePO> {
/**
* 有功功率趋势记录(用于定时任务)
*/
List<PowerStatisticsTargetVO> record(RActivePowerRangeParam rActivePowerRangeParam);
/**
* 根据监测点ID及时间获取有功功率趋势
*/
RActivePowerRangePO getDataByLineId(String lineId, String startTime, String endTime);
RActivePowerRangeVO getDataByLineId(String lineId, String startTime, String endTime);
}

418
pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/PowerStatisticsServiceImpl.java
View File

@@ -2,25 +2,26 @@ package com.njcn.harmonic.service.activepowerrange.impl;
import cn.afterturn.easypoi.excel.ExcelExportUtil;
import cn.afterturn.easypoi.excel.entity.ExportParams;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.alibaba.fastjson.JSONArray;
import com.njcn.dataProcess.api.*;
import com.njcn.dataProcess.param.LineCountEvaluateParam;
import com.njcn.dataProcess.pojo.dto.*;
import com.njcn.device.biz.pojo.po.Overlimit;
import com.njcn.device.pq.api.OverLimitClient;
import com.njcn.harmonic.constant.Param;
import com.njcn.harmonic.pojo.param.PowerStatisticsParam;
import com.njcn.harmonic.pojo.po.RActivePowerRangePO;
import com.njcn.harmonic.pojo.vo.*;
import com.njcn.harmonic.service.activepowerrange.PowerStatisticsService;
import com.njcn.harmonic.service.activepowerrange.RActivePowerRangeService;
import com.njcn.influx.pojo.bo.CommonQueryParam;
import com.njcn.influx.pojo.constant.InfluxDBTableConstant;
import com.njcn.influx.pojo.dto.StatisticalDataDTO;
import com.njcn.influx.service.CommonService;
import com.njcn.poi.util.PoiUtil;
import com.njcn.prepare.harmonic.pojo.param.RActivePowerRangeParam;
import com.njcn.system.api.EpdFeignClient;
import com.njcn.system.pojo.po.EleEpdPqd;
import lombok.RequiredArgsConstructor;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
@@ -32,10 +33,13 @@ import org.springframework.stereotype.Service;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
@@ -53,41 +57,24 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService {
private final DecimalFormat df = new DecimalFormat(Param.DECIMAL_FORMATSTR);
private final DecimalFormat dftwo = new DecimalFormat(Param.DECIMAL_FORMATTWOSTR);
private final EpdFeignClient epdFeignClient;
private List<String> METHODS = Arrays.asList(InfluxDBTableConstant.AVG, InfluxDBTableConstant.CP95, InfluxDBTableConstant.MIN, InfluxDBTableConstant.MAX);
private List<String> PHASE = Arrays.asList(InfluxDBTableConstant.PHASE_TYPE_A, InfluxDBTableConstant.PHASE_TYPE_B, InfluxDBTableConstant.PHASE_TYPE_C);
private final DataVFeignClient dataVFeignClient;
private final DataIFeignClient dataIFeignClient;
private final DataPltFeignClient dataPltFeignClient;
private final DataInharmVFeignClient dataInharmVFeignClient;
private final DataHarmRateVFeignClient dataHarmRateVFeignClient;
private final OverLimitClient overLimitClient;
private final DataLimitRateDetailFeignClient dataLimitRateDetailFeignClient;
private List<String> times = Arrays.asList("0~10%", "10~20%", "20~30%", "30~40%", "40~50%", "50~60%", "60~70%", "70~80%", "80~90%", "90~100%");
Map<String, String> DATABSEMAP = new HashMap() {{
put("PPVDev", "电压偏差");
put("ImbNgV", "三相电压不平衡度");
put("PhFluc", "电压波动");
put("PhPlt", "长时闪变");
put("ImbNgA", "电流不平衡度");
}};
Map<String, String> UHARMMAP = new HashMap() {{
put("HRPhV", "谐波电压");
}};
Map<String, String> IHARMMAP = new HashMap() {{
put("HA", "谐波电流");
}};
Map<String, String> INTERHARMONICMAP = new HashMap() {{
put("IHRPhV", "间谐波电压含有率");
}};
@Override
public PowerStatisticsVO getDataByLineId(PowerStatisticsParam powerStatisticsParam) {
//执行完就可以获取到区间数据了
RActivePowerRangePO rActivePowerRangePO = rActivePowerRangeService.getDataByLineId(powerStatisticsParam.getLineId(),
RActivePowerRangeVO rActivePowerRangePO = rActivePowerRangeService.getDataByLineId(powerStatisticsParam.getLineId(),
powerStatisticsParam.getSearchBeginTime(), powerStatisticsParam.getSearchEndTime());
//如果的确没有统计到数据则默认
if (rActivePowerRangePO == null) {
rActivePowerRangePO = new RActivePowerRangePO();
rActivePowerRangePO = new RActivePowerRangeVO();
}
PowerStatisticsVO powerStatisticsVO = new PowerStatisticsVO();
BeanUtils.copyProperties(rActivePowerRangePO, powerStatisticsVO);
@@ -115,24 +102,190 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService {
@Override
public List<PowerStatisticsTargetVO> getTargetLimitById(PowerStatisticsParam powerStatisticsParam) {
List<PowerStatisticsTargetVO> record = new ArrayList<>();
RActivePowerRangeParam rActivePowerRangeParam = new RActivePowerRangeParam();
BeanUtil.copyProperties(powerStatisticsParam, rActivePowerRangeParam);
rActivePowerRangeParam.setSearch(true);
RActivePowerRangePO rActivePowerRangePO = rActivePowerRangeService.getDataByLineId(powerStatisticsParam.getLineId(),
RActivePowerRangeVO rActivePowerRangePO = rActivePowerRangeService.getDataByLineId(powerStatisticsParam.getLineId(),
powerStatisticsParam.getSearchBeginTime(), powerStatisticsParam.getSearchEndTime());
if (rActivePowerRangePO != null) {
//获取电压数据
LineCountEvaluateParam lineParam = new LineCountEvaluateParam();
lineParam.setLineId(Collections.singletonList(rActivePowerRangePO.getLineId()));
LineCountEvaluateParam lineCountEvaluateParam = new LineCountEvaluateParam();
lineCountEvaluateParam.setLineId(Collections.singletonList(rActivePowerRangePO.getLineId()));
lineCountEvaluateParam.setStartTime(powerStatisticsParam.getSearchBeginTime());
lineCountEvaluateParam.setEndTime(powerStatisticsParam.getSearchBeginTime());
//获取超标数据
List<DataLimitRateDetailTimeDto> dtoList = dataLimitRateDetailFeignClient.getLimitRateDetailTimeList(lineCountEvaluateParam).getData();
Map<String, DataLimitRateDetailTimeDto> timeDateMap = dtoList.stream().collect(Collectors.toMap(x -> x.getTime(), Function.identity()));
if (ObjectUtil.isNotNull(rActivePowerRangePO)) {
List<String> timeId = rActivePowerRangePO.getTimeId();
String times = reflexObjValue(rActivePowerRangePO, "minsTime" + powerStatisticsParam.getField()).toString().replace("null", "");
rActivePowerRangeParam.setSearchTimeFort(false);
for (String se : times.split("&")) {
String startTime = se.split(",")[0];
String endTime = se.split(",")[1];
rActivePowerRangeParam.setSearchBeginTime(startTime);
rActivePowerRangeParam.setSearchEndTime(endTime);
record.addAll(rActivePowerRangeService.record(rActivePowerRangeParam));
List<String> timeList = JSONArray.parseArray(times, String.class);
for (int i = 0; i < timeId.size(); i++) {
String date = timeId.get(i);
List<String> strings = JSONArray.parseArray(timeList.get(i), String.class);
if (CollUtil.isNotEmpty(strings)) {
for (String time : strings) {
PowerStatisticsTargetVO vo = new PowerStatisticsTargetVO();
String t = date + " " + time;
vo.setTime(t);
if (timeDateMap.containsKey(date)) {
DataLimitRateDetailTimeDto rateDetail = timeDateMap.get(date);
vo.setVoltageOffset(isCross(t, rateDetail.getVoltageDevOvertime()));
vo.setSequenceCurrentUnbalance(isCross(t, rateDetail.getINegOvertime()));
vo.setUbalance(isCross(t, rateDetail.getUbalanceOvertime()));
vo.setFlicker(isCross(t, rateDetail.getFlickerOvertime()));
vo.setVTimes(isCross(t, rateDetail.getUharmOvertime()));
vo.setITimes(isCross(t, rateDetail.getIharmOvertime()));
vo.setInterHarmonic(isCross(t, rateDetail.getInuharmOvertime()));
}
record.add(vo);
}
}
}
}
return record.stream().sorted(Comparator.comparing(PowerStatisticsTargetVO::getTime)).collect(Collectors.toList());
}
@Override
public List<ThdDataVO> getTargetByTimeDetail(PowerStatisticsParam param) {
List<ThdDataVO> info = new ArrayList<>();
//获取越线详情
List<Overlimit> data = overLimitClient.getOverLimitByLineIds(Collections.singletonList(param.getLineId())).getData();
Overlimit overlimit = data.get(0);
LineCountEvaluateParam evaluateParam = new LineCountEvaluateParam();
evaluateParam.setLineId(Collections.singletonList(param.getLineId()));
evaluateParam.setStartTime(param.getSearchBeginTime());
evaluateParam.setEndTime(param.getSearchEndTime());
if ("1".equals(param.getStatisticalId())) {
//电压数据
List<DataVDto> dataVAllTime = dataVFeignClient.getRawData(evaluateParam).getData();
//闪变数据
List<DataPltDto> dataFlickerAllTime = dataPltFeignClient.getRawData(evaluateParam).getData();
//电流数据
List<DataIDto> dataIList = dataIFeignClient.getRawData(evaluateParam).getData();
//电压偏差
if ("Dev".equals(param.getCode()) || StrUtil.isBlank(param.getCode())) {
addThdData(info, overlimit.getVoltageDev(), "vuDev", dataVAllTime, "电压上偏差");
addThdData(info, overlimit.getUvoltageDev(), "vlDev", dataVAllTime, "电压下偏差");
}
//电压不平横度
if ("Unbalance".equals(param.getCode()) || StrUtil.isBlank(param.getCode())) {
addThdData(info, overlimit.getUbalance(), "vUnbalance", dataVAllTime, "三相电压不平横度");
}
//闪变
if ("plt".equals(param.getCode()) || StrUtil.isBlank(param.getCode())) {
addThdData(info, overlimit.getFlicker(), "plt", dataFlickerAllTime, "长时闪变");
}
//电流不平衡度
if ("iNeg".equals(param.getCode()) || StrUtil.isBlank(param.getCode())) {
addThdData(info, overlimit.getINeg(), "iNeg", dataIList, "电流不平衡度");
}
}
if ("2".equals(param.getStatisticalId())) {
//谐波数据
List<DataHarmDto> dataVHarmList = dataHarmRateVFeignClient.getRawData(evaluateParam).getData();
addThdData(info, overlimit, "getUharm", "v", 2, 26, dataVHarmList, "谐波电压");
}
if ("3".equals(param.getStatisticalId())) {
//电流数据
List<DataIDto> dataIList = dataIFeignClient.getRawData(evaluateParam).getData();
addThdData(info, overlimit, "getUharm", "i", 2, 26, dataIList, "谐波电流");
}
if ("4".equals(param.getStatisticalId())) {
//间谐波数据
List<DataHarmDto> dataVInHarmList = dataInharmVFeignClient.getRawData(evaluateParam).getData();
addThdData(info, overlimit, "getInuharm", "v", 1, 17, dataVInHarmList, "间谐波电压");
}
return info;
}
private void addThdData(List<ThdDataVO> info, Overlimit overlimit, String limitField, String fieldName, Integer start, Integer end, List<?> dataAllTime, String anotherName) {
if (CollUtil.isNotEmpty(dataAllTime)) {
for (int i = start; i < end; i++) {
int finalI = i;
List<String> collect = dataAllTime.stream().map(x -> data(x, fieldName + finalI)).filter(x -> ObjectUtil.isNotNull(x)).collect(Collectors.toList());
if (CollUtil.isNotEmpty(collect)) {
ThdDataVO vo = new ThdDataVO();
try {
Method getUharmMethod = Overlimit.class.getMethod(limitField + i);
float limit = (float) getUharmMethod.invoke(overlimit);
vo.setLimit(limit);
} catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
throw new RuntimeException(e);
}
vo.setAnotherName(anotherName);
if ("getInuharm".equals(limitField)) {
vo.setAnotherName(i - 0.5 + "次");
} else {
vo.setAnotherName(i + "次");
}
for (String s : collect) {
setDataV(vo, s);
}
info.add(vo);
}
}
}
}
private void addThdData(List<ThdDataVO> info, Float limit, String fieldName, List<?> dataAllTime, String anotherName) {
if (CollUtil.isNotEmpty(dataAllTime)) {
List<String> collect = dataAllTime.stream().map(x -> data(x, fieldName)).filter(x -> ObjectUtil.isNotNull(x)).collect(Collectors.toList());
if (CollUtil.isNotEmpty(collect)) {
ThdDataVO vo = new ThdDataVO();
vo.setLimit(limit);
vo.setAnotherName(anotherName);
for (String s : collect) {
setDataV(vo, s);
}
info.add(vo);
}
}
}
private void setDataV(ThdDataVO dto, String fieldName) {
String[] split = fieldName.split("&");
if (split.length > 1) {
try {
Class clazz = dto.getClass();
Field field = clazz.getDeclaredField(split[0]);
field.setAccessible(true);
field.set(dto, split[1]);
} catch (Exception e) {
e.printStackTrace();
}
}
}
private String data(Object dto, String fieldName) {
try {
Class clazz = dto.getClass();
Field field = clazz.getDeclaredField(fieldName);
field.setAccessible(true);
Object o = field.get(dto);
if (ObjectUtil.isNotNull(o)) {
Field phasicType = clazz.getDeclaredField("phasicType");
phasicType.setAccessible(true);
String phasic = phasicType.get(dto).toString();
Field valueType = clazz.getDeclaredField("valueType");
valueType.setAccessible(true);
String value = valueType.get(dto).toString();
return value.toUpperCase() + "Phase" + phasic + "&" + o;
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private Integer isCross(String time, List<String> timeCross) {
if (timeCross.contains(time)) {
return 1;
}
return 0;
}
/**
@@ -155,177 +308,6 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService {
return null;
}
@Override
public List<ThdDataVO> getTargetByTime(PowerStatisticsParam powerStatisticsParam) {
List<ThdDataVO> result = new ArrayList();
List<EleEpdPqd> eleEpdPqds = new ArrayList<>();
//获取固定指标具体请看
if ("1".equals(powerStatisticsParam.getStatisticalId())) {
DATABSEMAP.forEach((key, value) -> {
EleEpdPqd epdPqd = epdFeignClient.findByName(key).getData();
if(ObjectUtil.isNotEmpty(epdPqd)){
epdPqd.setShowName(value);
eleEpdPqds.add(epdPqd);
}
});
}
if ("2".equals(powerStatisticsParam.getStatisticalId())) {
UHARMMAP.forEach((key, value) -> {
EleEpdPqd epdPqd = epdFeignClient.findByName(key).getData();
if(ObjectUtil.isNotEmpty(epdPqd)){
epdPqd.setShowName(value);
eleEpdPqds.add(epdPqd);
}
});
}
if ("3".equals(powerStatisticsParam.getStatisticalId())) {
IHARMMAP.forEach((key, value) -> {
EleEpdPqd epdPqd = epdFeignClient.findByName(key).getData();
if(ObjectUtil.isNotEmpty(epdPqd)){
epdPqd.setShowName(value);
eleEpdPqds.add(epdPqd);
}
});
}
if ("4".equals(powerStatisticsParam.getStatisticalId())) {
INTERHARMONICMAP.forEach((key, value) -> {
EleEpdPqd epdPqd = epdFeignClient.findByName(key).getData();
if(ObjectUtil.isNotEmpty(epdPqd)){
epdPqd.setShowName(value);
eleEpdPqds.add(epdPqd);
}
});
}
eleEpdPqds.forEach(epdPqd -> {
List<CommonQueryParam> commonQueryParams = new ArrayList<>();
commonQueryParams.clear();
//带有谐波次数的指标
if (epdPqd.getHarmEnd() != null && epdPqd.getHarmStart() != null) {
for (int i = epdPqd.getHarmStart().intValue(); i <= epdPqd.getHarmEnd().intValue(); i++) {
ThdDataVO thdDataVO = new ThdDataVO();
thdDataVO.setUnit(epdPqd.getUnit());
thdDataVO.setTime(powerStatisticsParam.getSearchBeginTime());
String index = i + "";
if (epdPqd.getShowName().equals("间谐波电压含有率")) {
thdDataVO.setAnotherName(Integer.parseInt(index) - 0.5 + "次");
} else {
thdDataVO.setAnotherName(index + "次");
}
getThdDataVO(epdPqd.getOtherName() + "_" + index, thdDataVO, epdPqd, powerStatisticsParam);
result.add(thdDataVO);
}
} else {
//无谐波次数的指标
ThdDataVO thdDataVO = new ThdDataVO();
thdDataVO.setAnotherName(epdPqd.getShowName());
thdDataVO.setUnit(epdPqd.getUnit());
thdDataVO.setTime(powerStatisticsParam.getSearchBeginTime());
getThdDataVO(null, thdDataVO, epdPqd, powerStatisticsParam);
result.add(thdDataVO);
}
});
return result;
}
//将各个指标的所有的相别统计方式以表格的维度进行组装数据
private ThdDataVO getThdDataVO(String columnName, ThdDataVO thdDataVO, EleEpdPqd epdPqd, PowerStatisticsParam powerStatisticsParam) {
List<CommonQueryParam> commonQueryParams = new ArrayList<>();
CommonQueryParam commonQueryParam = new CommonQueryParam();
commonQueryParam.setLineId(powerStatisticsParam.getLineId());
commonQueryParam.setTableName(epdPqd.getClassId());
commonQueryParam.setColumnName(columnName == null ? epdPqd.getOtherName() : columnName);
commonQueryParam.setStartTime(powerStatisticsParam.getSearchBeginTime());
commonQueryParam.setEndTime(powerStatisticsParam.getSearchEndTime());
//唯一不同的条件时统计方式和相别,所以这边直接把所有的情况都考虑进去
commonQueryParam.setDataType(METHODS.get(0));
commonQueryParam.setPhasic(PHASE.get(0));
commonQueryParams.add(commonQueryParam);
List<StatisticalDataDTO> deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
if (!deviceRtData.isEmpty()) {
thdDataVO.setAVGPhaseA(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
}
commonQueryParam.setDataType(METHODS.get(0));
commonQueryParam.setPhasic(PHASE.get(1));
deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
if (!deviceRtData.isEmpty()) {
thdDataVO.setAVGPhaseB(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
}
commonQueryParam.setDataType(METHODS.get(0));
commonQueryParam.setPhasic(PHASE.get(2));
deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
if (!deviceRtData.isEmpty()) {
thdDataVO.setAVGPhaseC(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
}
commonQueryParam.setDataType(METHODS.get(1));
commonQueryParam.setPhasic(PHASE.get(0));
deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
if (!deviceRtData.isEmpty()) {
thdDataVO.setCP95PhaseA(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
}
commonQueryParam.setDataType(METHODS.get(1));
commonQueryParam.setPhasic(PHASE.get(1));
deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
if (!deviceRtData.isEmpty()) {
thdDataVO.setCP95PhaseB(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
}
commonQueryParam.setDataType(METHODS.get(1));
commonQueryParam.setPhasic(PHASE.get(2));
deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
if (!deviceRtData.isEmpty()) {
thdDataVO.setCP95PhaseC(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
}
commonQueryParam.setDataType(METHODS.get(2));
commonQueryParam.setPhasic(PHASE.get(0));
deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
if (!deviceRtData.isEmpty()) {
thdDataVO.setMINPhaseA(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
}
commonQueryParam.setDataType(METHODS.get(2));
commonQueryParam.setPhasic(PHASE.get(1));
deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
if (!deviceRtData.isEmpty()) {
thdDataVO.setMINPhaseB(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
}
commonQueryParam.setDataType(METHODS.get(2));
commonQueryParam.setPhasic(PHASE.get(2));
deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
if (!deviceRtData.isEmpty()) {
thdDataVO.setMINPhaseC(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
}
commonQueryParam.setDataType(METHODS.get(3));
commonQueryParam.setPhasic(PHASE.get(0));
deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
if (!deviceRtData.isEmpty()) {
thdDataVO.setMAXPhaseA(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
}
commonQueryParam.setDataType(METHODS.get(3));
commonQueryParam.setPhasic(PHASE.get(1));
deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
if (!deviceRtData.isEmpty()) {
thdDataVO.setMAXPhaseB(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
}
commonQueryParam.setDataType(METHODS.get(3));
commonQueryParam.setPhasic(PHASE.get(2));
deviceRtData = commonService.getNewDeviceRtDataByTime(commonQueryParams);
if (!deviceRtData.isEmpty()) {
thdDataVO.setMAXPhaseC(Double.valueOf(df.format(deviceRtData.get(0).getValue())) + "");
}
return thdDataVO;
}
@Override
public void exportExcelRangTemplate(PowerStatisticsParam powerStatisticsParam, HttpServletResponse response) {
@@ -498,9 +480,9 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService {
for (String time : times) {
powerStatisticsParam.setSearchBeginTime(time);
powerStatisticsParam.setSearchEndTime(time);
for (int i = 1; i <= 4; i++) {
for (int i = 1; i < 5; i++) {
powerStatisticsParam.setStatisticalId(i + "");
List<ThdDataVO> thdDataVOList = getTargetByTime(powerStatisticsParam);
List<ThdDataVO> thdDataVOList = getTargetByTimeDetail(powerStatisticsParam);
if (i != 1) {
for (ThdDataVO thdDataVO : thdDataVOList) {
switch (i) {

98
pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/RActivePowerRangeServiceImpl.java
View File

@@ -1,11 +1,14 @@
package com.njcn.harmonic.service.activepowerrange.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
import com.njcn.event.pojo.constant.Param;
import com.njcn.harmonic.mapper.RActivePowerRangeMapper;
import com.njcn.harmonic.pojo.po.RActivePowerRangePO;
import com.njcn.harmonic.pojo.vo.PowerStatisticsTargetVO;
import com.njcn.harmonic.pojo.vo.RActivePowerRangeVO;
import com.njcn.harmonic.service.activepowerrange.RActivePowerRangeService;
import com.njcn.influx.pojo.constant.InfluxDBTableConstant;
import com.njcn.prepare.harmonic.pojo.param.RActivePowerRangeParam;
@@ -18,6 +21,7 @@ import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;
/**
* 有功功率趋势 服务实现类
@@ -52,61 +56,67 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl<RActivePowerRan
* 间谐波电压含有率 data_inharm_v v1-v16 0.5-15.5次间谐波电压含有率 有一个指标超标，则谐波电压超标
* 电流不平衡度 data_i i_unbalance 这个不确定，找宝哥确认下
*
* @param rActivePowerRangeParam
* @param
* @return
*/
@Override
@Transactional(rollbackFor = Exception.class)
public List<PowerStatisticsTargetVO> record(RActivePowerRangeParam rActivePowerRangeParam) {
return null;
}
@Override
public RActivePowerRangePO getDataByLineId(String lineId, String startTime, String endTime) {
public RActivePowerRangeVO getDataByLineId(String lineId, String startTime, String endTime) {
LambdaQueryWrapper<RActivePowerRangePO> lambdaQueryWrapper = new LambdaQueryWrapper();
lambdaQueryWrapper.eq(RActivePowerRangePO::getLineId, lineId).eq(RActivePowerRangePO::getState, "1")
.between(RActivePowerRangePO::getTimeId, startTime, endTime);
lambdaQueryWrapper.eq(RActivePowerRangePO::getLineId, lineId)
.eq(RActivePowerRangePO::getState, "1")
.between(RActivePowerRangePO::getTimeId, startTime, endTime)
.orderByAsc(RActivePowerRangePO::getTimeId)
;
List<RActivePowerRangePO> rActivePowerRangePOS = this.baseMapper.selectList(lambdaQueryWrapper);
if (!rActivePowerRangePOS.isEmpty()) {
RActivePowerRangePO rActivePowerRangePO = new RActivePowerRangePO();
RActivePowerRangeVO rActivePowerRangePO = new RActivePowerRangeVO();
rActivePowerRangePO.setLineId(lineId);
rActivePowerRangePO.setTimeId(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getTimeId).collect(Collectors.toList()));
//多条记录则次数累加,是否越限只要有一个区间越限则统一视为该区间越限
for (RActivePowerRangePO rangePO : rActivePowerRangePOS) {
rActivePowerRangePO.setMinsNum0(rangePO.getMinsNum0() + rActivePowerRangePO.getMinsNum0());
rActivePowerRangePO.setMinsNum1(rangePO.getMinsNum1() + rActivePowerRangePO.getMinsNum1());
rActivePowerRangePO.setMinsNum2(rangePO.getMinsNum2() + rActivePowerRangePO.getMinsNum2());
rActivePowerRangePO.setMinsNum3(rangePO.getMinsNum3() + rActivePowerRangePO.getMinsNum3());
rActivePowerRangePO.setMinsNum4(rangePO.getMinsNum4() + rActivePowerRangePO.getMinsNum4());
rActivePowerRangePO.setMinsNum5(rangePO.getMinsNum5() + rActivePowerRangePO.getMinsNum5());
rActivePowerRangePO.setMinsNum6(rangePO.getMinsNum6() + rActivePowerRangePO.getMinsNum6());
rActivePowerRangePO.setMinsNum7(rangePO.getMinsNum7() + rActivePowerRangePO.getMinsNum7());
rActivePowerRangePO.setMinsNum8(rangePO.getMinsNum8() + rActivePowerRangePO.getMinsNum8());
rActivePowerRangePO.setMinsNum9(rangePO.getMinsNum9() + rActivePowerRangePO.getMinsNum9());
rActivePowerRangePO.setIsOrNot0(rangePO.getIsOrNot0() + rActivePowerRangePO.getIsOrNot0());
rActivePowerRangePO.setIsOrNot1(rangePO.getIsOrNot1() + rActivePowerRangePO.getIsOrNot1());
rActivePowerRangePO.setIsOrNot2(rangePO.getIsOrNot2() + rActivePowerRangePO.getIsOrNot2());
rActivePowerRangePO.setIsOrNot3(rangePO.getIsOrNot3() + rActivePowerRangePO.getIsOrNot3());
rActivePowerRangePO.setIsOrNot4(rangePO.getIsOrNot4() + rActivePowerRangePO.getIsOrNot4());
rActivePowerRangePO.setIsOrNot5(rangePO.getIsOrNot5() + rActivePowerRangePO.getIsOrNot5());
rActivePowerRangePO.setIsOrNot6(rangePO.getIsOrNot6() + rActivePowerRangePO.getIsOrNot6());
rActivePowerRangePO.setIsOrNot7(rangePO.getIsOrNot7() + rActivePowerRangePO.getIsOrNot7());
rActivePowerRangePO.setIsOrNot8(rangePO.getIsOrNot8() + rActivePowerRangePO.getIsOrNot8());
rActivePowerRangePO.setIsOrNot9(rangePO.getIsOrNot9() + rActivePowerRangePO.getIsOrNot9());
rActivePowerRangePO.setMinsTime0(rangePO.getMinsTime0() + "&" + rActivePowerRangePO.getMinsTime0());
rActivePowerRangePO.setMinsTime1(rangePO.getMinsTime1() + "&" + rActivePowerRangePO.getMinsTime1());
rActivePowerRangePO.setMinsTime2(rangePO.getMinsTime2() + "&" + rActivePowerRangePO.getMinsTime2());
rActivePowerRangePO.setMinsTime3(rangePO.getMinsTime3() + "&" + rActivePowerRangePO.getMinsTime3());
rActivePowerRangePO.setMinsTime4(rangePO.getMinsTime4() + "&" + rActivePowerRangePO.getMinsTime4());
rActivePowerRangePO.setMinsTime5(rangePO.getMinsTime5() + "&" + rActivePowerRangePO.getMinsTime5());
rActivePowerRangePO.setMinsTime6(rangePO.getMinsTime6() + "&" + rActivePowerRangePO.getMinsTime6());
rActivePowerRangePO.setMinsTime7(rangePO.getMinsTime7() + "&" + rActivePowerRangePO.getMinsTime7());
rActivePowerRangePO.setMinsTime8(rangePO.getMinsTime8() + "&" + rActivePowerRangePO.getMinsTime8());
rActivePowerRangePO.setMinsTime9(rangePO.getMinsTime9() + "&" + rActivePowerRangePO.getMinsTime9());
}
rActivePowerRangePO.setMinsNum0(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum0).sum());
rActivePowerRangePO.setMinsNum1(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum1).sum());
rActivePowerRangePO.setMinsNum2(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum2).sum());
rActivePowerRangePO.setMinsNum3(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum3).sum());
rActivePowerRangePO.setMinsNum4(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum4).sum());
rActivePowerRangePO.setMinsNum5(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum5).sum());
rActivePowerRangePO.setMinsNum6(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum6).sum());
rActivePowerRangePO.setMinsNum7(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum7).sum());
rActivePowerRangePO.setMinsNum8(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum8).sum());
rActivePowerRangePO.setMinsNum9(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum9).sum());
rActivePowerRangePO.setIsOrNot0(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum0).sum());
rActivePowerRangePO.setIsOrNot1(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum1).sum());
rActivePowerRangePO.setIsOrNot2(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum2).sum());
rActivePowerRangePO.setIsOrNot3(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum3).sum());
rActivePowerRangePO.setIsOrNot4(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum4).sum());
rActivePowerRangePO.setIsOrNot5(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum5).sum());
rActivePowerRangePO.setIsOrNot6(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum6).sum());
rActivePowerRangePO.setIsOrNot7(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum7).sum());
rActivePowerRangePO.setIsOrNot8(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum8).sum());
rActivePowerRangePO.setIsOrNot9(rActivePowerRangePOS.stream().mapToInt(RActivePowerRangePO::getMinsNum9).sum());
rActivePowerRangePO.setMinsTime0(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime0).collect(Collectors.toList()));
rActivePowerRangePO.setMinsTime1(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime1).collect(Collectors.toList()));
rActivePowerRangePO.setMinsTime2(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime2).collect(Collectors.toList()));
rActivePowerRangePO.setMinsTime3(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime3).collect(Collectors.toList()));
rActivePowerRangePO.setMinsTime4(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime4).collect(Collectors.toList()));
rActivePowerRangePO.setMinsTime5(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime5).collect(Collectors.toList()));
rActivePowerRangePO.setMinsTime6(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime6).collect(Collectors.toList()));
rActivePowerRangePO.setMinsTime7(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime7).collect(Collectors.toList()));
rActivePowerRangePO.setMinsTime8(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime8).collect(Collectors.toList()));
rActivePowerRangePO.setMinsTime9(rActivePowerRangePOS.stream().map(RActivePowerRangePO::getMinsTime9).collect(Collectors.toList()));
return rActivePowerRangePO;
}
return null;
}
private String minsTimeJson(List<String> list) {
if (CollUtil.isNotEmpty(list)) {
}
return null;
}
}