diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/PowerStatisticsParam.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/PowerStatisticsParam.java index e1c02d254..943fbf7d1 100644 --- a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/PowerStatisticsParam.java +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/PowerStatisticsParam.java @@ -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; diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/RActivePowerRangePO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/RActivePowerRangePO.java index 8263a1011..8507a16c1 100644 --- a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/RActivePowerRangePO.java +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/RActivePowerRangePO.java @@ -26,7 +26,7 @@ public class RActivePowerRangePO extends BaseEntity { /** * 日期（天） */ - private LocalDate timeId; + private String timeId; /** * 0%~10%区间时间Json diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/PowerStatisticsTargetVO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/PowerStatisticsTargetVO.java index 89ab6a610..b032b896a 100644 --- a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/PowerStatisticsTargetVO.java +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/PowerStatisticsTargetVO.java @@ -40,28 +40,4 @@ public class PowerStatisticsTargetVO { @ApiModelProperty("电流不平衡度") private Integer sequenceCurrentUnbalance = 0; - @ApiModelProperty("电压偏差详情") - private List voltageOffsetList = new ArrayList<>(); - - @ApiModelProperty("谐波电压详情") - private List vTimesList = new ArrayList<>(); - - @ApiModelProperty("谐波电流详情") - private List iTimestList = new ArrayList<>(); - - @ApiModelProperty("三相电压不平衡度详情") - private List ubalanceList = new ArrayList<>(); - - @ApiModelProperty("电压波动") - private List voltageFluctuationList = new ArrayList<>(); - - @ApiModelProperty("闪变详情") - private List flickerList = new ArrayList<>(); - - @ApiModelProperty("间谐波电压含有率详情") - private List interHarmonicList = new ArrayList<>(); - - @ApiModelProperty("电流不平衡度详情") - private List sequenceCurrentUnbalanceList = new ArrayList<>(); - } diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/RActivePowerRangeVO.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/RActivePowerRangeVO.java new file mode 100644 index 000000000..84e4d8edd --- /dev/null +++ b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/RActivePowerRangeVO.java @@ -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 timeId; + + /** + * 0%~10%区间时间Json + */ + private List minsTime0; + + /** + * 0%~10%区间个数 + */ + private Integer minsNum0 = 0; + + /** + * 0%~10%区间是否越限 + */ + private Integer isOrNot0 = 0; + + /** + * 10%~20%区间时间Json + */ + private List minsTime1; + + /** + * 10%~20%区间个数 + */ + private Integer minsNum1 = 0;; + + /** + * 10%~20%区间是否越限 + */ + private Integer isOrNot1 = 0; + + /** + * 20%~30%区间时间Json + */ + private List minsTime2; + + /** + * 20%~30%区间个数 + */ + private Integer minsNum2 = 0;; + + /** + * 20%~30%区间是否越限 + */ + private Integer isOrNot2 = 0; + + /** + * 30%~40%区间时间Json + */ + private List minsTime3; + + /** + * 30%~40%区间个数 + */ + private Integer minsNum3 = 0;; + + /** + * 30%~40%区间是否越限 + */ + private Integer isOrNot3 = 0; + + /** + * 40%~50%区间时间Json + */ + private List minsTime4; + + /** + * 40%~50%区间个数 + */ + private Integer minsNum4 = 0;; + + /** + * 40%~50%区间是否越限 + */ + private Integer isOrNot4 = 0; + + /** + * 50%~60%区间时间Json + */ + private List minsTime5; + + /** + * 50%~60%区间个数 + */ + private Integer minsNum5 = 0;; + + /** + * 50%~60%区间是否越限 + */ + private Integer isOrNot5 = 0; + + /** + * 60%~70%区间时间Json + */ + private List minsTime6; + + /** + * 60%~70%区间个数 + */ + private Integer minsNum6 = 0;; + + /** + * 60%~70%区间是否越限 + */ + private Integer isOrNot6 = 0; + + /** + * 70%~80%区间时间Json + */ + private List minsTime7; + + /** + * 70%~80%区间个数 + */ + private Integer minsNum7 = 0;; + + /** + * 70%~80%区间是否越限 + */ + private Integer isOrNot7 = 0; + + /** + * 80%~90%区间时间Json + */ + private List minsTime8; + + /** + * 80%~90%区间个数 + */ + private Integer minsNum8 = 0;; + + /** + * 80%~90%区间是否越限 + */ + private Integer isOrNot8 = 0; + + /** + * 90%~100%区间时间Json + */ + private List minsTime9; + + /** + * 90%~100%区间个数 + */ + private Integer minsNum9 = 0;; + + /** + * 90%~100%区间是否越限 + */ + private Integer isOrNot9 = 0; + +} diff --git a/pqs-harmonic/harmonic-boot/pom.xml b/pqs-harmonic/harmonic-boot/pom.xml index 4352a74c3..146750ee8 100644 --- a/pqs-harmonic/harmonic-boot/pom.xml +++ b/pqs-harmonic/harmonic-boot/pom.xml @@ -112,6 +112,12 @@ cs-device-api 1.0.0 + + com.njcn.platform + data-processing-api + 1.0.0 + compile + diff --git a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/controller/powerstatistics/PowerStatisticsController.java b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/controller/powerstatistics/PowerStatisticsController.java index 74a9f902f..23f1a9966 100644 --- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/controller/powerstatistics/PowerStatisticsController.java +++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/controller/powerstatistics/PowerStatisticsController.java @@ -66,7 +66,7 @@ public class PowerStatisticsController extends BaseController { @ApiOperation("点击越限列表时间查询指标的详细数据") public HttpResult> getTargetByTime(@RequestBody @Validated PowerStatisticsParam powerStatisticsParam) { String methodDescribe = getMethodDescribe("getTargetByTime"); - List targetByTime = powerStatisticsService.getTargetByTime(powerStatisticsParam); + List targetByTime = powerStatisticsService.getTargetByTimeDetail(powerStatisticsParam); return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, targetByTime, methodDescribe); } diff --git a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/PowerStatisticsService.java b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/PowerStatisticsService.java index 22ccaaf66..5798639f6 100644 --- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/PowerStatisticsService.java +++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/PowerStatisticsService.java @@ -29,11 +29,11 @@ public interface PowerStatisticsService { List getTargetLimitById(PowerStatisticsParam powerStatisticsParam); /** - * 点击越限列表时间查询指标的详细数据 - * @param powerStatisticsParam + * 查询稳态详情信息 + * @param param * @return */ - List getTargetByTime(PowerStatisticsParam powerStatisticsParam); + List getTargetByTimeDetail(PowerStatisticsParam param); /** * 导出区间数据 diff --git a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/RActivePowerRangeService.java b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/RActivePowerRangeService.java index 3d81518ce..57512d777 100644 --- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/RActivePowerRangeService.java +++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/RActivePowerRangeService.java @@ -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 { - /** - * 有功功率趋势记录(用于定时任务) - */ - List record(RActivePowerRangeParam rActivePowerRangeParam); /** * 根据监测点ID及时间获取有功功率趋势 */ - RActivePowerRangePO getDataByLineId(String lineId, String startTime, String endTime); + RActivePowerRangeVO getDataByLineId(String lineId, String startTime, String endTime); } diff --git a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/PowerStatisticsServiceImpl.java b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/PowerStatisticsServiceImpl.java index 309ba935d..481cf0e8b 100644 --- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/PowerStatisticsServiceImpl.java +++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/PowerStatisticsServiceImpl.java @@ -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 METHODS = Arrays.asList(InfluxDBTableConstant.AVG, InfluxDBTableConstant.CP95, InfluxDBTableConstant.MIN, InfluxDBTableConstant.MAX); - - private List 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 times = Arrays.asList("0~10%", "10~20%", "20~30%", "30~40%", "40~50%", "50~60%", "60~70%", "70~80%", "80~90%", "90~100%"); - Map DATABSEMAP = new HashMap() {{ - put("PPVDev", "电压偏差"); - put("ImbNgV", "三相电压不平衡度"); - put("PhFluc", "电压波动"); - put("PhPlt", "长时闪变"); - put("ImbNgA", "电流不平衡度"); - }}; - - Map UHARMMAP = new HashMap() {{ - put("HRPhV", "谐波电压"); - }}; - - Map IHARMMAP = new HashMap() {{ - put("HA", "谐波电流"); - }}; - - Map 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 getTargetLimitById(PowerStatisticsParam powerStatisticsParam) { List 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 dtoList = dataLimitRateDetailFeignClient.getLimitRateDetailTimeList(lineCountEvaluateParam).getData(); + Map timeDateMap = dtoList.stream().collect(Collectors.toMap(x -> x.getTime(), Function.identity())); + if (ObjectUtil.isNotNull(rActivePowerRangePO)) { + List 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 timeList = JSONArray.parseArray(times, String.class); + for (int i = 0; i < timeId.size(); i++) { + String date = timeId.get(i); + List 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 getTargetByTimeDetail(PowerStatisticsParam param) { + List info = new ArrayList<>(); + //获取越线详情 + List 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 dataVAllTime = dataVFeignClient.getRawData(evaluateParam).getData(); + //闪变数据 + List dataFlickerAllTime = dataPltFeignClient.getRawData(evaluateParam).getData(); + //电流数据 + List 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 dataVHarmList = dataHarmRateVFeignClient.getRawData(evaluateParam).getData(); + addThdData(info, overlimit, "getUharm", "v", 2, 26, dataVHarmList, "谐波电压"); + } + if ("3".equals(param.getStatisticalId())) { + //电流数据 + List dataIList = dataIFeignClient.getRawData(evaluateParam).getData(); + addThdData(info, overlimit, "getUharm", "i", 2, 26, dataIList, "谐波电流"); + + } + if ("4".equals(param.getStatisticalId())) { + //间谐波数据 + List dataVInHarmList = dataInharmVFeignClient.getRawData(evaluateParam).getData(); + addThdData(info, overlimit, "getInuharm", "v", 1, 17, dataVInHarmList, "间谐波电压"); + } + return info; + } + + private void addThdData(List 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 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 info, Float limit, String fieldName, List dataAllTime, String anotherName) { + if (CollUtil.isNotEmpty(dataAllTime)) { + List 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 timeCross) { + if (timeCross.contains(time)) { + return 1; + } + return 0; } /** @@ -155,177 +308,6 @@ public class PowerStatisticsServiceImpl implements PowerStatisticsService { return null; } - @Override - public List getTargetByTime(PowerStatisticsParam powerStatisticsParam) { - List result = new ArrayList(); - List 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 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 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 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 thdDataVOList = getTargetByTime(powerStatisticsParam); + List thdDataVOList = getTargetByTimeDetail(powerStatisticsParam); if (i != 1) { for (ThdDataVO thdDataVO : thdDataVOList) { switch (i) { diff --git a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/RActivePowerRangeServiceImpl.java b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/RActivePowerRangeServiceImpl.java index 697e1762a..2ed0c7def 100644 --- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/RActivePowerRangeServiceImpl.java +++ b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/activepowerrange/impl/RActivePowerRangeServiceImpl.java @@ -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 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 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 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 list) { + if (CollUtil.isNotEmpty(list)) { + + } + return null; + } }