diff --git a/pqs-device/device-boot/src/main/resources/bootstrap.yml b/pqs-device/device-boot/src/main/resources/bootstrap.yml index 0537cd79d..b17c80ccc 100644 --- a/pqs-device/device-boot/src/main/resources/bootstrap.yml +++ b/pqs-device/device-boot/src/main/resources/bootstrap.yml @@ -64,4 +64,5 @@ mqtt: oracle: isSync: false syncLedgerLineUrl: http://localhost:8082/export/syncLedgerLine - syncLedgerUpdateLine: http://localhost:8082/export/syncLedgerLine + syncLedgerUpdateLine: http://localhost:8082/export/syncLedgerUpdateLine + syncLedgerDeleteLine: http://localhost:8082/export/syncLedgerDeleteLine diff --git a/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/enums/PrepareResponseEnum.java b/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/enums/PrepareResponseEnum.java index 9c0fba44b..cef543a00 100644 --- a/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/enums/PrepareResponseEnum.java +++ b/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/enums/PrepareResponseEnum.java @@ -16,6 +16,8 @@ public enum PrepareResponseEnum { NO_REPAIR_DATE("A0803", "未指定补招日期"), + LIMIT_RATE_MISSING("A0804", "监测点限值缺失"), + ; private final String code; diff --git a/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/mysql/po/line/MpSurplusAbnormalD.java b/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/mysql/po/line/MpSurplusAbnormalD.java index ab347a32c..7dcc1baa6 100644 --- a/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/mysql/po/line/MpSurplusAbnormalD.java +++ b/pqs-prepare/prepare-api/src/main/java/com/njcn/prepare/harmonic/pojo/mysql/po/line/MpSurplusAbnormalD.java @@ -2,6 +2,7 @@ package com.njcn.prepare.harmonic.pojo.mysql.po.line; import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableName; +import com.github.jeffreyning.mybatisplus.anno.MppMultiId; import lombok.Data; import java.time.LocalDateTime; @@ -24,21 +25,26 @@ public class MpSurplusAbnormalD { /** * 统计数据时间 */ + @MppMultiId(value = "time_id") private LocalDateTime timeId; /** * 越限监测点 */ - private String id; + @MppMultiId + @TableField("id") + private String lineId; /** * 数据类型,’A’表示A相，’B’表示B相,’C’表示C相,’T’表示总 */ + @MppMultiId(value = "phasic_type") private String phasicType; /** * 指标类型，’AVG’代表平均值平均值，‘MAX’代表最大值，‘MIN’代表最小值，‘CP95’代表CP95值 */ + @MppMultiId(value = "value_type") private String valueType; /** diff --git a/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/executor/MeasurementExecutor.java b/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/executor/MeasurementExecutor.java index 6e6ff685d..c0ae8c248 100644 --- a/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/executor/MeasurementExecutor.java +++ b/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/executor/MeasurementExecutor.java @@ -619,5 +619,21 @@ public class MeasurementExecutor extends BaseExecutor { harmonicMetricService.newMetricData(bindCmp.getRequestData()); } + /** + * 算法名: 监测点统计表 + * r_mp_surplus_abnormal_d + * + * @author xuyang + * @date 2024年10月22日 8:50 + */ + @LiteflowMethod(value = LiteFlowMethodEnum.IS_ACCESS, nodeId = "rMpSurplusAbnormalD", nodeType = NodeTypeEnum.COMMON) + public boolean rMpSurplusAbnormalDAccess(NodeComponent bindCmp) { + return isAccess(bindCmp); + } + @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "rMpSurplusAbnormalD", nodeType = NodeTypeEnum.COMMON) + public void rMpSurplusAbnormalDProcess(NodeComponent bindCmp) { + harmonicMetricService.rMpSurplusAbnormalD(bindCmp.getRequestData()); + } + /********************************************算法负责人:xy结束***********************************************************/ } diff --git a/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/mapper/mysql/line/AbnormalMapper.java b/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/mapper/mysql/line/AbnormalMapper.java index d23434564..4582c284e 100644 --- a/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/mapper/mysql/line/AbnormalMapper.java +++ b/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/mapper/mysql/line/AbnormalMapper.java @@ -1,6 +1,6 @@ package com.njcn.prepare.harmonic.mapper.mysql.line; -import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.github.jeffreyning.mybatisplus.base.MppBaseMapper; import com.njcn.prepare.harmonic.pojo.mysql.po.line.MpSurplusAbnormalD; /** @@ -8,5 +8,5 @@ import com.njcn.prepare.harmonic.pojo.mysql.po.line.MpSurplusAbnormalD; * @version 1.0.0 * @date 2022年10月18日 11:12 */ -public interface AbnormalMapper extends BaseMapper { +public interface AbnormalMapper extends MppBaseMapper { } diff --git a/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/line/HarmonicMetricServiceImpl.java b/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/line/HarmonicMetricServiceImpl.java index 75f993de9..f59abc3cd 100644 --- a/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/line/HarmonicMetricServiceImpl.java +++ b/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/line/HarmonicMetricServiceImpl.java @@ -2,17 +2,29 @@ package com.njcn.prepare.harmonic.service.mysql.Impl.line; import cn.hutool.core.collection.CollUtil; import cn.hutool.core.date.DateUtil; +import cn.hutool.core.date.TimeInterval; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.github.jeffreyning.mybatisplus.service.MppServiceImpl; -import com.njcn.device.pq.api.LineFeignClient; +import com.njcn.common.pojo.exception.BusinessException; import com.njcn.device.biz.pojo.po.Overlimit; -import com.njcn.harmonic.pojo.po.day.RStatAssesDPO; +import com.njcn.device.pq.api.GeneralDeviceInfoClient; +import com.njcn.device.pq.api.LineFeignClient; +import com.njcn.device.pq.api.OverLimitClient; +import com.njcn.harmonic.pojo.po.day.*; +import com.njcn.influx.deprecated.InfluxDBPublicParam; import com.njcn.influx.pojo.po.DataPlt; import com.njcn.influx.pojo.po.DataV; import com.njcn.influx.utils.InfluxDbUtils; -import com.njcn.prepare.harmonic.mapper.mysql.day.RStatAssesDMapper; +import com.njcn.prepare.harmonic.enums.PrepareResponseEnum; +import com.njcn.prepare.harmonic.mapper.mysql.day.*; +import com.njcn.prepare.harmonic.mapper.mysql.line.AbnormalMapper; import com.njcn.prepare.harmonic.pojo.bo.CalculatedParam; +import com.njcn.prepare.harmonic.pojo.mysql.po.line.MpSurplusAbnormalD; import com.njcn.prepare.harmonic.pojo.param.LineParam; import com.njcn.prepare.harmonic.service.mysql.line.HarmonicMetricService; +import com.njcn.prepare.harmonic.service.mysql.line.NormalLimitService; +import com.njcn.user.api.DeptFeignClient; +import com.njcn.user.pojo.po.Dept; import lombok.AllArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.influxdb.InfluxDB; @@ -22,9 +34,14 @@ import org.influxdb.dto.QueryResult; import org.influxdb.impl.InfluxDBResultMapper; import org.springframework.scheduling.annotation.Async; import org.springframework.stereotype.Service; +import org.springframework.util.CollectionUtils; +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; import java.util.*; import java.util.concurrent.TimeUnit; +import java.util.function.Function; import java.util.stream.Collectors; /** @@ -39,8 +56,16 @@ import java.util.stream.Collectors; public class HarmonicMetricServiceImpl extends MppServiceImpl implements HarmonicMetricService { private final InfluxDbUtils influxDbUtils; - private final LineFeignClient lineFeignClient; + private final GeneralDeviceInfoClient generalDeviceInfoClient; + private final DeptFeignClient deptFeignClient; + private final OverLimitClient overLimitClient; + private final RStatDataHarmRateVDMapper rStatDataHarmRateVDMapper; + private final RStatDataInHarmVDMapper rStatDataInHarmVDMapper; + private final RStatDataVDMapper rStatDataVDMapper; + private final RStatDataIDMapper rStatDataIDMapper; + private final RStatDataPltDMapper rStatDataPltDMapper; + private final NormalLimitService normalLimitService; @Override @Async("asyncExecutor") @@ -127,6 +152,466 @@ public class HarmonicMetricServiceImpl extends MppServiceImpl lineIds; + List all = new ArrayList<>(); + + if (CollectionUtils.isEmpty(calculatedParam.getIdList())) { + Dept dept = deptFeignClient.getRootDept().getData(); + lineIds = generalDeviceInfoClient.deptGetRunLine(dept.getId()).getData(); + } else { + //不为空则为补招 + lineIds = calculatedParam.getIdList(); + } + if (CollUtil.isNotEmpty(lineIds)) { + List> overLimitMap = overLimitClient.getLimitMapsByLineIds(lineIds).getData(); + Map> ovMap = overLimitMap.stream().collect(Collectors.toMap(item -> item.get("id").toString(), Function.identity())); + + for (String lineIndex : lineIds) { + boolean flag = false; + //获取当前监测点的限值详情 + if (!ovMap.containsKey(lineIndex)) { + log.error(LocalDateTime.now() + "--监测点<" + lineIndex + ">不存在限值！"); + throw new BusinessException(PrepareResponseEnum.LIMIT_RATE_MISSING); + } + Map overLimit = ovMap.get(lineIndex); + + //谐波电压 + LambdaQueryWrapper lambdaQueryV = new LambdaQueryWrapper<>(); + lambdaQueryV.eq(RStatDataHarmrateVDPO::getLineId, lineIndex).eq(RStatDataHarmrateVDPO::getTime, calculatedParam.getDataDate() + InfluxDBPublicParam.START_TIME); + List> harmVMap = rStatDataHarmRateVDMapper.selectMaps(lambdaQueryV); + Map>> tenMap = harmVMap.stream().collect(Collectors.groupingBy(item -> item.get("phaseType").toString())); + + //谐波电流幅值 + LambdaQueryWrapper lambdaQueryI = new LambdaQueryWrapper<>(); + lambdaQueryI.eq(RStatDataIDPO::getLineId, lineIndex).eq(RStatDataIDPO::getTime, calculatedParam.getDataDate() + InfluxDBPublicParam.START_TIME); + List> harmIMap = rStatDataIDMapper.selectMaps(lambdaQueryI); + Map>> iMap = harmIMap.stream().collect(Collectors.groupingBy(item -> item.get("phaseType").toString())); + + //间谐波电压 + LambdaQueryWrapper lambdaQueryInV = new LambdaQueryWrapper<>(); + lambdaQueryInV.eq(RStatDataInharmVDPO::getLineId, lineIndex).eq(RStatDataInharmVDPO::getTime, calculatedParam.getDataDate() + InfluxDBPublicParam.START_TIME); + List> harmInVMap = rStatDataInHarmVDMapper.selectMaps(lambdaQueryInV); + Map>> inMap = harmInVMap.stream().collect(Collectors.groupingBy(item -> item.get("phaseType").toString())); + + //三相电压 + LambdaQueryWrapper lambdaQueryDataV = new LambdaQueryWrapper<>(); + lambdaQueryDataV.eq(RStatDataVDPO::getLineId, lineIndex).eq(RStatDataVDPO::getTime, calculatedParam.getDataDate() + InfluxDBPublicParam.START_TIME); + List rStatDataVDPOList = rStatDataVDMapper.selectList(lambdaQueryDataV); + Map> dataVMap = rStatDataVDPOList.stream().collect(Collectors.groupingBy(RStatDataVDPO::getPhaseType)); + + //电流 + LambdaQueryWrapper lambdaQueryDataI = new LambdaQueryWrapper<>(); + lambdaQueryDataI.eq(RStatDataIDPO::getLineId, lineIndex).eq(RStatDataIDPO::getTime, calculatedParam.getDataDate() + InfluxDBPublicParam.START_TIME); + List rStatDataIDPOList = rStatDataIDMapper.selectList(lambdaQueryDataI); + Map> dataIMap = rStatDataIDPOList.stream().collect(Collectors.groupingBy(RStatDataIDPO::getPhaseType)); + + //长时闪变 + LambdaQueryWrapper lambdaQueryDataPlt = new LambdaQueryWrapper<>(); + lambdaQueryDataPlt.eq(RStatDataPltDPO::getLineId, lineIndex).eq(RStatDataPltDPO::getTime, calculatedParam.getDataDate() + InfluxDBPublicParam.START_TIME); + List rStatDataPltDPOList = rStatDataPltDMapper.selectList(lambdaQueryDataPlt); + Map> dataPltMap = rStatDataPltDPOList.stream().collect(Collectors.groupingBy(RStatDataPltDPO::getPhaseType)); + + String phasic = ""; + for (int phase = 1; phase < 5; phase++) { + switch (phase) { + case 1: + phasic = "A"; + break; + case 2: + phasic = "B"; + break; + case 3: + phasic = "C"; + break; + case 4: + phasic = "T"; + break; + } + + MpSurplusAbnormalD mpSurplusAbnormalCp95 = new MpSurplusAbnormalD(); + mpSurplusAbnormalCp95.setPhasicType(phasic); + mpSurplusAbnormalCp95.setValueType("CP95"); + mpSurplusAbnormalCp95.setLineId(lineIndex); + mpSurplusAbnormalCp95.setTimeId(LocalDateTime.parse(calculatedParam.getDataDate() + InfluxDBPublicParam.START_TIME, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))); + + MpSurplusAbnormalD mpSurplusAbnormalAvg = new MpSurplusAbnormalD(); + mpSurplusAbnormalAvg.setPhasicType(phasic); + mpSurplusAbnormalAvg.setValueType("AVG"); + mpSurplusAbnormalAvg.setLineId(lineIndex); + mpSurplusAbnormalAvg.setTimeId(LocalDateTime.parse(calculatedParam.getDataDate() + InfluxDBPublicParam.START_TIME, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))); + + MpSurplusAbnormalD mpSurplusAbnormalMax = new MpSurplusAbnormalD(); + mpSurplusAbnormalMax.setPhasicType(phasic); + mpSurplusAbnormalMax.setValueType("MAX"); + mpSurplusAbnormalMax.setLineId(lineIndex); + mpSurplusAbnormalMax.setTimeId(LocalDateTime.parse(calculatedParam.getDataDate() + InfluxDBPublicParam.START_TIME, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))); + + MpSurplusAbnormalD mpSurplusAbnormalMin = new MpSurplusAbnormalD(); + mpSurplusAbnormalMin.setPhasicType(phasic); + mpSurplusAbnormalMin.setValueType("MIN"); + mpSurplusAbnormalMin.setLineId(lineIndex); + mpSurplusAbnormalMin.setTimeId(LocalDateTime.parse(calculatedParam.getDataDate() + InfluxDBPublicParam.START_TIME, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))); + + if (dataVMap.containsKey(phasic)) { + List mapList = dataVMap.get(phasic); + Map vMap = mapList.stream().collect(Collectors.toMap(RStatDataVDPO::getValueType, Function.identity())); + //三项电压不平衡度 + if (vMap.get("CP95").getVUnbalance() > (Double) overLimit.get("ubalance")) { + mpSurplusAbnormalCp95.setUbalance(vMap.get("CP95").getVUnbalance().floatValue()); + mpSurplusAbnormalAvg.setUbalance(vMap.get("AVG").getVUnbalance().floatValue()); + mpSurplusAbnormalMin.setUbalance(vMap.get("MIN").getVUnbalance().floatValue()); + mpSurplusAbnormalMax.setUbalance(vMap.get("MAX").getVUnbalance().floatValue()); + flag = true; + } + //电压畸变 + if (vMap.get("CP95").getVThd() > (Double) overLimit.get("uaberrance")) { + mpSurplusAbnormalCp95.setUaberrance(vMap.get("CP95").getVThd().floatValue()); + mpSurplusAbnormalAvg.setUaberrance(vMap.get("AVG").getVThd().floatValue()); + mpSurplusAbnormalMin.setUaberrance(vMap.get("MIN").getVThd().floatValue()); + mpSurplusAbnormalMax.setUaberrance(vMap.get("MAX").getVThd().floatValue()); + flag = true; + } + //频率偏差 + if (Math.abs(vMap.get("MAX").getFreqDev()) > (Double) overLimit.get("freq_dev") || Math.abs(vMap.get("MIN").getFreqDev()) > (Double) overLimit.get("freq_dev")) { + mpSurplusAbnormalCp95.setFreq(vMap.get("CP95").getFreqDev().floatValue()); + mpSurplusAbnormalAvg.setFreq(vMap.get("AVG").getFreqDev().floatValue()); + mpSurplusAbnormalMin.setFreq(vMap.get("MIN").getFreqDev().floatValue()); + mpSurplusAbnormalMax.setFreq(vMap.get("MAX").getFreqDev().floatValue()); + flag = true; + } + //电压上偏差 + if (Math.abs(vMap.get("MAX").getVlDev()) > (Double) overLimit.get("voltage_dev")) { + mpSurplusAbnormalCp95.setVoltageDev(vMap.get("CP95").getVlDev().floatValue()); + mpSurplusAbnormalAvg.setVoltageDev(vMap.get("AVG").getVlDev().floatValue()); + mpSurplusAbnormalMin.setVoltageDev(vMap.get("MIN").getVlDev().floatValue()); + mpSurplusAbnormalMax.setVoltageDev(vMap.get("MAX").getVlDev().floatValue()); + flag = true; + } + + } + //负序电流 + if (dataIMap.containsKey(phasic)) { + List mapList = dataIMap.get(phasic); + Map inegMap = mapList.stream().collect(Collectors.toMap(RStatDataIDPO::getValueType, Function.identity())); + if (inegMap.get("CP95").getINeg() > (Double) overLimit.get("i_neg")) { + mpSurplusAbnormalCp95.setINeg(inegMap.get("CP95").getINeg().floatValue()); + mpSurplusAbnormalAvg.setINeg(inegMap.get("AVG").getINeg().floatValue()); + mpSurplusAbnormalMin.setINeg(inegMap.get("MIN").getINeg().floatValue()); + mpSurplusAbnormalMax.setINeg(inegMap.get("MAX").getINeg().floatValue()); + flag = true; + } + } + //长时闪变 + if (dataPltMap.containsKey(phasic)) { + List mapList = dataPltMap.get(phasic); + Map pltMap = mapList.stream().collect(Collectors.toMap(RStatDataPltDPO::getValueType, Function.identity())); + if (pltMap.get("MAX").getPlt() > (Double) overLimit.get("flicker")) { + mpSurplusAbnormalCp95.setFlicker(pltMap.get("CP95").getPlt().floatValue()); + mpSurplusAbnormalAvg.setFlicker(pltMap.get("AVG").getPlt().floatValue()); + mpSurplusAbnormalMin.setFlicker(pltMap.get("MIN").getPlt().floatValue()); + mpSurplusAbnormalMax.setFlicker(pltMap.get("MAX").getPlt().floatValue()); + flag = true; + } + } + //谐波电压 + dealData(tenMap,phasic,overLimit,flag,mpSurplusAbnormalCp95,mpSurplusAbnormalAvg,mpSurplusAbnormalMax,mpSurplusAbnormalMin,2,26,1,"uharm_","v_",all); + //谐波电流 + dealData(iMap,phasic,overLimit,flag,mpSurplusAbnormalCp95,mpSurplusAbnormalAvg,mpSurplusAbnormalMax,mpSurplusAbnormalMin,2,26,2,"iharm_","i_",all); + //间谐波电压 + dealData(inMap,phasic,overLimit,flag,mpSurplusAbnormalCp95,mpSurplusAbnormalAvg,mpSurplusAbnormalMax,mpSurplusAbnormalMin,1,17,3,"inuharm_","v_",all); + } + } + } + if (CollUtil.isNotEmpty(all)) { + //入库操作 + normalLimitService.saveOrUpdateBatchByMultiId(all); + } + } + + /** + * + * @author cdf + * @date 2023/8/23 + */ + private void dealData(Map>> inMap, + String phasic,Map overLimit, + Boolean flag,MpSurplusAbnormalD mpSurplusAbnormalCp95,MpSurplusAbnormalD mpSurplusAbnormalAvg,MpSurplusAbnormalD mpSurplusAbnormalMax,MpSurplusAbnormalD mpSurplusAbnormalMin + ,int start,int count,int type,String overTag,String temTag, List all){ + if (inMap.containsKey(phasic)) { + List> mapList = inMap.get(phasic); + Map> harmMap = mapList.stream().collect(Collectors.toMap(item -> item.get("value_type").toString(), Function.identity())); + Map mCP95 = harmMap.get("CP95"); + Map mAVG = harmMap.get("AVG"); + Map mMAX = harmMap.get("MAX"); + Map mMIN = harmMap.get("MIN"); + Map moreValueCp95 = new HashMap<>(); + Map moreValueAvg = new HashMap<>(); + Map moreValueMax = new HashMap<>(); + Map moreValueMin = new HashMap<>(); + for (int i = start; i < count; i++) { + BigDecimal hv = (BigDecimal) mCP95.get(temTag + i); + String t = overTag + i; + BigDecimal over = BigDecimal.valueOf((Double) overLimit.get(t)); + if (hv.compareTo(over) > 0) { + moreValueCp95.put(temTag + i, hv.floatValue()); + moreValueAvg.put(temTag + i, mAVG.get(temTag + i)); + moreValueMax.put(temTag + i, mMAX.get(temTag + i)); + moreValueMin.put(temTag + i, mMIN.get(temTag + i)); + } + } + + if (!moreValueCp95.isEmpty()) { + flag = true; + assPojo(moreValueCp95, mpSurplusAbnormalCp95, type); + assPojo(moreValueAvg, mpSurplusAbnormalAvg, type); + assPojo(moreValueMax, mpSurplusAbnormalMax, type); + assPojo(moreValueMin, mpSurplusAbnormalMin, type); + + all.add(mpSurplusAbnormalCp95); + all.add(mpSurplusAbnormalAvg); + all.add(mpSurplusAbnormalMax); + all.add(mpSurplusAbnormalMin); + } + } + } + + + /** + * type 1.谐波电压含有率 2.谐波电流幅值 其他.间谐波电流 + * + * @author cdf + * @date 2023/8/22 + */ + private void assPojo(Map map, MpSurplusAbnormalD mpSurplusAbnormalD, Integer type) { + if (type == 1) { + //谐波电压 + map.forEach((key, val) -> { + switch (key) { + case "v_2": + mpSurplusAbnormalD.setUharm2(Float.parseFloat(val.toString())); + break; + case "v_3": + mpSurplusAbnormalD.setUharm3(Float.parseFloat(val.toString())); + break; + case "v_4": + mpSurplusAbnormalD.setUharm4(Float.parseFloat(val.toString())); + break; + case "v_5": + mpSurplusAbnormalD.setUharm5(Float.parseFloat(val.toString())); + break; + case "v_6": + mpSurplusAbnormalD.setUharm6(Float.parseFloat(val.toString())); + break; + case "v_7": + mpSurplusAbnormalD.setUharm7(Float.parseFloat(val.toString())); + break; + case "v_8": + mpSurplusAbnormalD.setUharm8(Float.parseFloat(val.toString())); + break; + case "v_9": + mpSurplusAbnormalD.setUharm9(Float.parseFloat(val.toString())); + break; + case "v_10": + mpSurplusAbnormalD.setUharm10(Float.parseFloat(val.toString())); + break; + case "v_11": + mpSurplusAbnormalD.setUharm11(Float.parseFloat(val.toString())); + break; + case "v_12": + mpSurplusAbnormalD.setUharm12(Float.parseFloat(val.toString())); + break; + case "v_13": + mpSurplusAbnormalD.setUharm13(Float.parseFloat(val.toString())); + break; + case "v_14": + mpSurplusAbnormalD.setUharm14(Float.parseFloat(val.toString())); + break; + case "v_15": + mpSurplusAbnormalD.setUharm15(Float.parseFloat(val.toString())); + break; + case "v_16": + mpSurplusAbnormalD.setUharm16(Float.parseFloat(val.toString())); + break; + case "v_17": + mpSurplusAbnormalD.setUharm17(Float.parseFloat(val.toString())); + break; + case "v_18": + mpSurplusAbnormalD.setUharm18(Float.parseFloat(val.toString())); + break; + case "v_19": + mpSurplusAbnormalD.setUharm19(Float.parseFloat(val.toString())); + break; + case "v_20": + mpSurplusAbnormalD.setUharm20(Float.parseFloat(val.toString())); + break; + case "v_21": + mpSurplusAbnormalD.setUharm21(Float.parseFloat(val.toString())); + break; + case "v_22": + mpSurplusAbnormalD.setUharm22(Float.parseFloat(val.toString())); + break; + case "v_23": + mpSurplusAbnormalD.setUharm23(Float.parseFloat(val.toString())); + break; + case "v_24": + mpSurplusAbnormalD.setUharm24(Float.parseFloat(val.toString())); + break; + case "v_25": + mpSurplusAbnormalD.setUharm25(Float.parseFloat(val.toString())); + break; + case "time": + break; + default: + throw new IllegalStateException("Unexpected value: " + key); + } + + }); + } else if (type == 2) { + //谐波电流 + map.forEach((key, val) -> { + switch (key) { + case "i_2": + mpSurplusAbnormalD.setIharm2(Float.parseFloat(val.toString())); + break; + case "i_3": + mpSurplusAbnormalD.setIharm3(Float.parseFloat(val.toString())); + break; + case "i_4": + mpSurplusAbnormalD.setIharm4(Float.parseFloat(val.toString())); + break; + case "i_5": + mpSurplusAbnormalD.setIharm5(Float.parseFloat(val.toString())); + break; + case "i_6": + mpSurplusAbnormalD.setIharm6(Float.parseFloat(val.toString())); + break; + case "i_7": + mpSurplusAbnormalD.setIharm7(Float.parseFloat(val.toString())); + break; + case "i_8": + mpSurplusAbnormalD.setIharm8(Float.parseFloat(val.toString())); + break; + case "i_9": + mpSurplusAbnormalD.setIharm9(Float.parseFloat(val.toString())); + break; + case "i_10": + mpSurplusAbnormalD.setIharm10(Float.parseFloat(val.toString())); + break; + case "i_11": + mpSurplusAbnormalD.setIharm11(Float.parseFloat(val.toString())); + break; + case "i_12": + mpSurplusAbnormalD.setIharm12(Float.parseFloat(val.toString())); + break; + case "i_13": + mpSurplusAbnormalD.setIharm13(Float.parseFloat(val.toString())); + break; + case "i_14": + mpSurplusAbnormalD.setIharm14(Float.parseFloat(val.toString())); + break; + case "i_15": + mpSurplusAbnormalD.setIharm15(Float.parseFloat(val.toString())); + break; + case "i_16": + mpSurplusAbnormalD.setIharm16(Float.parseFloat(val.toString())); + break; + case "i_17": + mpSurplusAbnormalD.setIharm17(Float.parseFloat(val.toString())); + break; + case "i_18": + mpSurplusAbnormalD.setIharm18(Float.parseFloat(val.toString())); + break; + case "i_19": + mpSurplusAbnormalD.setIharm19(Float.parseFloat(val.toString())); + break; + case "i_20": + mpSurplusAbnormalD.setIharm20(Float.parseFloat(val.toString())); + break; + case "i_21": + mpSurplusAbnormalD.setIharm21(Float.parseFloat(val.toString())); + break; + case "i_22": + mpSurplusAbnormalD.setIharm22(Float.parseFloat(val.toString())); + break; + case "i_23": + mpSurplusAbnormalD.setIharm23(Float.parseFloat(val.toString())); + break; + case "i_24": + mpSurplusAbnormalD.setIharm24(Float.parseFloat(val.toString())); + break; + case "i_25": + mpSurplusAbnormalD.setIharm25(Float.parseFloat(val.toString())); + break; + case "time": + break; + default: + throw new IllegalStateException("Unexpected value: " + key); + } + }); + } else { + //间谐波电压 + map.forEach((key, val) -> { + switch (key) { + case "v_1": + mpSurplusAbnormalD.setInuharm1(Float.parseFloat(val.toString())); + break; + case "v_2": + mpSurplusAbnormalD.setInuharm2(Float.parseFloat(val.toString())); + break; + case "v_3": + mpSurplusAbnormalD.setInuharm3(Float.parseFloat(val.toString())); + break; + case "v_4": + mpSurplusAbnormalD.setInuharm4(Float.parseFloat(val.toString())); + break; + case "v_5": + mpSurplusAbnormalD.setInuharm5(Float.parseFloat(val.toString())); + break; + case "v_6": + mpSurplusAbnormalD.setInuharm6(Float.parseFloat(val.toString())); + break; + case "v_7": + mpSurplusAbnormalD.setInuharm7(Float.parseFloat(val.toString())); + break; + case "v_8": + mpSurplusAbnormalD.setInuharm8(Float.parseFloat(val.toString())); + break; + case "v_9": + mpSurplusAbnormalD.setInuharm9(Float.parseFloat(val.toString())); + break; + case "v_10": + mpSurplusAbnormalD.setInuharm10(Float.parseFloat(val.toString())); + break; + case "v_11": + mpSurplusAbnormalD.setInuharm11(Float.parseFloat(val.toString())); + break; + case "v_12": + mpSurplusAbnormalD.setInuharm12(Float.parseFloat(val.toString())); + break; + case "v_13": + mpSurplusAbnormalD.setInuharm13(Float.parseFloat(val.toString())); + break; + case "v_14": + mpSurplusAbnormalD.setInuharm14(Float.parseFloat(val.toString())); + break; + case "v_15": + mpSurplusAbnormalD.setInuharm15(Float.parseFloat(val.toString())); + break; + case "v_16": + mpSurplusAbnormalD.setInuharm16(Float.parseFloat(val.toString())); + break; + case "time": + break; + default: + throw new IllegalStateException("Unexpected value: " + key); + } + + }); + } + } + private Map getMetricData(String lineId,String date){ String processParam = " and line_id = '"+lineId+"' and time >= '"+date+" 00:00:00' and time <= '"+date+" 23:59:59' tz('Asia/Shanghai')"; QueryResult vuDevResult = influxDbUtils.query("select abs(vu_dev) as vu_dev from data_v where phasic_type != 'T' and value_type = 'AVG'"+processParam); diff --git a/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/line/NormalLimitServiceImpl.java b/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/line/NormalLimitServiceImpl.java index b1ab243a5..8230a83d7 100644 --- a/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/line/NormalLimitServiceImpl.java +++ b/pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/line/NormalLimitServiceImpl.java @@ -3,7 +3,7 @@ package com.njcn.prepare.harmonic.service.mysql.Impl.line; import cn.hutool.core.collection.CollUtil; import cn.hutool.core.date.TimeInterval; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; -import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.github.jeffreyning.mybatisplus.service.MppServiceImpl; import com.njcn.device.pq.api.GeneralDeviceInfoClient; import com.njcn.device.pq.api.LineFeignClient; import com.njcn.device.pq.api.OverLimitClient; @@ -25,7 +25,10 @@ import org.springframework.util.CollectionUtils; import java.math.BigDecimal; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; -import java.util.*; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import java.util.function.Function; import java.util.stream.Collectors; @@ -38,7 +41,7 @@ import java.util.stream.Collectors; @Service @AllArgsConstructor @Slf4j -public class NormalLimitServiceImpl extends ServiceImpl implements NormalLimitService { +public class NormalLimitServiceImpl extends MppServiceImpl implements NormalLimitService { private final GeneralDeviceInfoClient generalDeviceInfoClient; @@ -146,25 +149,25 @@ public class NormalLimitServiceImpl extends ServiceImpl { +public interface NormalLimitService extends IMppService {