From ef7f63bbecff90ba7063770e143af9d15782f79e Mon Sep 17 00:00:00 2001 From: hzj <826100833@qq.com> Date: Mon, 15 Jan 2024 20:31:14 +0800 Subject: [PATCH] =?UTF-8?q?oralce=E5=90=8C=E6=AD=A5=E5=88=B0influxDB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- influx-data/influx-source/.gitignore | 38 ++ influx-data/influx-source/pom.xml | 112 ++++ .../influx/bo/po/InfluxDBDataFlicker.java | 68 +++ .../njcn/influx/bo/po/InfluxDBDataFluc.java | 65 ++ .../influx/bo/po/InfluxDBDataHarmPhasicI.java | 428 +++++++++++++ .../influx/bo/po/InfluxDBDataHarmPhasicV.java | 430 +++++++++++++ .../influx/bo/po/InfluxDBDataHarmPowerP.java | 438 +++++++++++++ .../influx/bo/po/InfluxDBDataHarmPowerQ.java | 433 +++++++++++++ .../influx/bo/po/InfluxDBDataHarmPowerS.java | 432 +++++++++++++ .../influx/bo/po/InfluxDBDataHarmRateI.java | 429 +++++++++++++ .../influx/bo/po/InfluxDBDataHarmRateV.java | 428 +++++++++++++ .../com/njcn/influx/bo/po/InfluxDBDataI.java | 479 +++++++++++++++ .../influx/bo/po/InfluxDBDataInHarmI.java | 432 +++++++++++++ .../influx/bo/po/InfluxDBDataInHarmV.java | 429 +++++++++++++ .../njcn/influx/bo/po/InfluxDBDataPlt.java | 61 ++ .../com/njcn/influx/bo/po/InfluxDBDataV.java | 577 ++++++++++++++++++ .../njcn/influx/bo/po/InfluxDBDayFlicker.java | 54 ++ .../njcn/influx/bo/po/InfluxDBDayFluc.java | 45 ++ .../influx/bo/po/InfluxDBDayHarmPhasicI.java | 189 ++++++ .../influx/bo/po/InfluxDBDayHarmPhasicV.java | 190 ++++++ .../influx/bo/po/InfluxDBDayHarmPowerP.java | 198 ++++++ .../influx/bo/po/InfluxDBDayHarmPowerQ.java | 193 ++++++ .../influx/bo/po/InfluxDBDayHarmPowerS.java | 193 ++++++ .../influx/bo/po/InfluxDBDayHarmRateI.java | 18 + .../influx/bo/po/InfluxDBDayHarmRateV.java | 18 + .../com/njcn/influx/bo/po/InfluxDBDayI.java | 208 +++++++ .../njcn/influx/bo/po/InfluxDBDayInHarmI.java | 20 + .../njcn/influx/bo/po/InfluxDBDayInHarmV.java | 187 ++++++ .../com/njcn/influx/bo/po/InfluxDBDayPlt.java | 43 ++ .../com/njcn/influx/bo/po/InfluxDBDayV.java | 235 +++++++ .../com/njcn/influx/bo/po/LimitRatePO.java | 248 ++++++++ .../com/njcn/influx/bo/po/LimitTarget.java | 279 +++++++++ .../influx/service/InfluxDBBaseService.java | 24 + .../service/impl/InfluxDBBaseServiceImpl.java | 61 ++ influx-data/influx-target/.gitignore | 38 ++ influx-data/influx-target/pom.xml | 35 ++ .../java/com/njcn/InfluxDataApplication.java | 26 + .../OracleToInfluxDBController.java | 116 ++++ .../src/main/resources/application.yml | 111 ++++ .../src/test/java/njcn/BaseJunitTest.java | 18 + .../src/test/java/njcn/DataTest.java | 64 ++ influx-data/pom.xml | 7 +- 42 files changed, 8096 insertions(+), 1 deletion(-) create mode 100644 influx-data/influx-source/.gitignore create mode 100644 influx-data/influx-source/pom.xml create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataFlicker.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataFluc.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPhasicI.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPhasicV.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPowerP.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPowerQ.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPowerS.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmRateI.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmRateV.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataI.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataInHarmI.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataInHarmV.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataPlt.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataV.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayFlicker.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayFluc.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPhasicI.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPhasicV.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPowerP.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPowerQ.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPowerS.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmRateI.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmRateV.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayI.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayInHarmI.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayInHarmV.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayPlt.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayV.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/LimitRatePO.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/LimitTarget.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/service/InfluxDBBaseService.java create mode 100644 influx-data/influx-source/src/main/java/com/njcn/influx/service/impl/InfluxDBBaseServiceImpl.java create mode 100644 influx-data/influx-target/.gitignore create mode 100644 influx-data/influx-target/pom.xml create mode 100644 influx-data/influx-target/src/main/java/com/njcn/InfluxDataApplication.java create mode 100644 influx-data/influx-target/src/main/java/com/njcn/influx/controller/OracleToInfluxDBController.java create mode 100644 influx-data/influx-target/src/main/resources/application.yml create mode 100644 influx-data/influx-target/src/test/java/njcn/BaseJunitTest.java create mode 100644 influx-data/influx-target/src/test/java/njcn/DataTest.java diff --git a/influx-data/influx-source/.gitignore b/influx-data/influx-source/.gitignore new file mode 100644 index 0000000..5ff6309 --- /dev/null +++ b/influx-data/influx-source/.gitignore @@ -0,0 +1,38 @@ +target/ +!.mvn/wrapper/maven-wrapper.jar +!**/src/main/**/target/ +!**/src/test/**/target/ + +### IntelliJ IDEA ### +.idea/modules.xml +.idea/jarRepositories.xml +.idea/compiler.xml +.idea/libraries/ +*.iws +*.iml +*.ipr + +### Eclipse ### +.apt_generated +.classpath +.factorypath +.project +.settings +.springBeans +.sts4-cache + +### NetBeans ### +/nbproject/private/ +/nbbuild/ +/dist/ +/nbdist/ +/.nb-gradle/ +build/ +!**/src/main/**/build/ +!**/src/test/**/build/ + +### VS Code ### +.vscode/ + +### Mac OS ### +.DS_Store \ No newline at end of file diff --git a/influx-data/influx-source/pom.xml b/influx-data/influx-source/pom.xml new file mode 100644 index 0000000..10b72cb --- /dev/null +++ b/influx-data/influx-source/pom.xml @@ -0,0 +1,112 @@ + + + 4.0.0 + + com.njcn + influx-data + 1.0.0 + + + influx-source + + + 8 + 8 + UTF-8 + + + + + org.projectlombok + lombok + + + + cn.hutool + hutool-all + + + org.springframework.boot + spring-boot-starter-json + + + org.apache.logging.log4j + log4j-to-slf4j + + + + + + org.springframework.boot + spring-boot-starter-actuator + + + + org.springframework.boot + spring-boot-configuration-processor + true + + + + org.springframework.boot + spring-boot-starter-test + + + + org.apache.commons + commons-lang3 + + + commons-io + commons-io + + + commons-codec + commons-codec + + + + com.github.xiaoymin + knife4j-spring-boot-starter + + + com.github.xiaoymin + knife4j-spring-ui + + + + com.fasterxml.jackson.core + jackson-databind + + + + com.fasterxml.jackson.core + jackson-core + + + com.fasterxml.jackson.core + jackson-annotations + + + com.fasterxml.jackson.datatype + jackson-datatype-jsr310 + + + + com.njcn + influxdb-springboot-starter + 1.0.0 + + + + com.njcn + oracle-source + 1.0.0 + compile + + + + + \ No newline at end of file diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataFlicker.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataFlicker.java new file mode 100644 index 0000000..25805ed --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataFlicker.java @@ -0,0 +1,68 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataFlicker; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.ZoneId; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + */ +@Data +@Measurement(name = "data_flicker") +public class InfluxDBDataFlicker { + + @TimeColumn + @Column(name = "time",tag = true) + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "fluc") + private Float fluc; + + @Column(name = "plt") + private Float plt; + + @Column(name = "pst") + private Float pst; + + @Column(name = "quality_flag") + private String qualityFlag; + + + public static InfluxDBDataFlicker oralceToInfluxDB(DataFlicker dataFlicker) { + if (dataFlicker == null) { + return null; + } + InfluxDBDataFlicker influxDBDataFlicker = new InfluxDBDataFlicker(); + + Instant instant = dataFlicker.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataFlicker.setTime(instant); + influxDBDataFlicker.setLineId(dataFlicker.getLineid()+""); + influxDBDataFlicker.setPhaseType(dataFlicker.getPhasicType()); + influxDBDataFlicker.setFluc(dataFlicker.getFluc()); + influxDBDataFlicker.setPlt(dataFlicker.getPst()); + influxDBDataFlicker.setPst(dataFlicker.getPlt()); + influxDBDataFlicker.setQualityFlag(dataFlicker.getQualityflag()+""); + + + return influxDBDataFlicker; + } +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataFluc.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataFluc.java new file mode 100644 index 0000000..1769207 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataFluc.java @@ -0,0 +1,65 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataFlicker; +import com.njcn.oracle.bo.po.DataFluc; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.ZoneId; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + */ +@Data +@Measurement(name = "data_fluc") +public class InfluxDBDataFluc { + + @TimeColumn + @Column(name = "time",tag = true) + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "fluc") + private Float fluc; + + @Column(name = "fluccf") + private Float fluccf; + + + @Column(name = "quality_flag") + private String qualityFlag; + + public static InfluxDBDataFluc oralceToInfluxDB(DataFluc dataFluc) { + if (dataFluc == null) { + return null; + } + InfluxDBDataFluc influxDBDataFluc = new InfluxDBDataFluc(); + + Instant instant = dataFluc.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataFluc.setTime(instant); + influxDBDataFluc.setLineId(dataFluc.getLineid()+""); + influxDBDataFluc.setPhaseType(dataFluc.getPhasicType()); + influxDBDataFluc.setFluc(dataFluc.getFluc()); + influxDBDataFluc.setFluccf(dataFluc.getFluccf()); + influxDBDataFluc.setQualityFlag(dataFluc.getQualityflag()+""); + + + return influxDBDataFluc; + } + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPhasicI.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPhasicI.java new file mode 100644 index 0000000..9bd31b5 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPhasicI.java @@ -0,0 +1,428 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataHarmphasicI; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + */ +@Data +@Measurement(name = "data_harmphasic_i") +public class InfluxDBDataHarmPhasicI { + + @TimeColumn + @Column(name = "time",tag = true) + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag") + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "i_1") + private Float i1; + + @Column(name = "i_2") + private Float i2; + + @Column(name = "i_3") + private Float i3; + + @Column(name = "i_4") + private Float i4; + + @Column(name = "i_5") + private Float i5; + + @Column(name = "i_6") + private Float i6; + + @Column(name = "i_7") + private Float i7; + + @Column(name = "i_8") + private Float i8; + + @Column(name = "i_9") + private Float i9; + + @Column(name = "i_10") + private Float i10; + + @Column(name = "i_11") + private Float i11; + + @Column(name = "i_12") + private Float i12; + + @Column(name = "i_13") + private Float i13; + + @Column(name = "i_14") + private Float i14; + + @Column(name = "i_15") + private Float i15; + + @Column(name = "i_16") + private Float i16; + + @Column(name = "i_17") + private Float i17; + + @Column(name = "i_18") + private Float i18; + + @Column(name = "i_19") + private Float i19; + + @Column(name = "i_20") + private Float i20; + + @Column(name = "i_21") + private Float i21; + + @Column(name = "i_22") + private Float i22; + + @Column(name = "i_23") + private Float i23; + + @Column(name = "i_24") + private Float i24; + + @Column(name = "i_25") + private Float i25; + + @Column(name = "i_26") + private Float i26; + + @Column(name = "i_27") + private Float i27; + + @Column(name = "i_28") + private Float i28; + + @Column(name = "i_29") + private Float i29; + + @Column(name = "i_30") + private Float i30; + + @Column(name = "i_31") + private Float i31; + + @Column(name = "i_32") + private Float i32; + + @Column(name = "i_33") + private Float i33; + + @Column(name = "i_34") + private Float i34; + + @Column(name = "i_35") + private Float i35; + + @Column(name = "i_36") + private Float i36; + + @Column(name = "i_37") + private Float i37; + + @Column(name = "i_38") + private Float i38; + + @Column(name = "i_39") + private Float i39; + + @Column(name = "i_40") + private Float i40; + + @Column(name = "i_41") + private Float i41; + + @Column(name = "i_42") + private Float i42; + + @Column(name = "i_43") + private Float i43; + + @Column(name = "i_44") + private Float i44; + + @Column(name = "i_45") + private Float i45; + + @Column(name = "i_46") + private Float i46; + + @Column(name = "i_47") + private Float i47; + + @Column(name = "i_48") + private Float i48; + + @Column(name = "i_49") + private Float i49; + + @Column(name = "i_50") + private Float i50; + + + public static List oralceToInfluxDB(DataHarmphasicI dataHarmphasicI) { + if (dataHarmphasicI == null) { + return null; + } + List influxDBDataHarmPhasicIList = new ArrayList<>(); + List valueTypeList = Stream.of("AVG", "MAX", "MIN", "CP95").collect(Collectors.toList()); + for (String valueType : valueTypeList) { + InfluxDBDataHarmPhasicI influxDBDataHarmPhasicI = new InfluxDBDataHarmPhasicI(); + Instant instant = dataHarmphasicI.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataHarmPhasicI.setTime(instant); + influxDBDataHarmPhasicI.setLineId(dataHarmphasicI.getLineid()+""); + influxDBDataHarmPhasicI.setPhaseType(dataHarmphasicI.getPhasicType()); + influxDBDataHarmPhasicI.setQualityFlag(dataHarmphasicI.getQualityflag()+""); + influxDBDataHarmPhasicI.setValueType(valueType); + if (valueType.equals("AVG")) { + influxDBDataHarmPhasicI.setI1(dataHarmphasicI.getI1()); + influxDBDataHarmPhasicI.setI2(dataHarmphasicI.getI2()); + influxDBDataHarmPhasicI.setI3(dataHarmphasicI.getI3()); + influxDBDataHarmPhasicI.setI4(dataHarmphasicI.getI4()); + influxDBDataHarmPhasicI.setI5(dataHarmphasicI.getI5()); + influxDBDataHarmPhasicI.setI6(dataHarmphasicI.getI6()); + influxDBDataHarmPhasicI.setI7(dataHarmphasicI.getI7()); + influxDBDataHarmPhasicI.setI8(dataHarmphasicI.getI8()); + influxDBDataHarmPhasicI.setI9(dataHarmphasicI.getI9()); + influxDBDataHarmPhasicI.setI10(dataHarmphasicI.getI10()); + influxDBDataHarmPhasicI.setI11(dataHarmphasicI.getI11()); + influxDBDataHarmPhasicI.setI12(dataHarmphasicI.getI12()); + influxDBDataHarmPhasicI.setI13(dataHarmphasicI.getI13()); + influxDBDataHarmPhasicI.setI14(dataHarmphasicI.getI14()); + influxDBDataHarmPhasicI.setI15(dataHarmphasicI.getI15()); + influxDBDataHarmPhasicI.setI16(dataHarmphasicI.getI16()); + influxDBDataHarmPhasicI.setI17(dataHarmphasicI.getI17()); + influxDBDataHarmPhasicI.setI18(dataHarmphasicI.getI18()); + influxDBDataHarmPhasicI.setI19(dataHarmphasicI.getI19()); + influxDBDataHarmPhasicI.setI20(dataHarmphasicI.getI20()); + influxDBDataHarmPhasicI.setI21(dataHarmphasicI.getI21()); + influxDBDataHarmPhasicI.setI22(dataHarmphasicI.getI22()); + influxDBDataHarmPhasicI.setI23(dataHarmphasicI.getI23()); + influxDBDataHarmPhasicI.setI24(dataHarmphasicI.getI24()); + influxDBDataHarmPhasicI.setI25(dataHarmphasicI.getI25()); + influxDBDataHarmPhasicI.setI26(dataHarmphasicI.getI26()); + influxDBDataHarmPhasicI.setI27(dataHarmphasicI.getI27()); + influxDBDataHarmPhasicI.setI28(dataHarmphasicI.getI28()); + influxDBDataHarmPhasicI.setI29(dataHarmphasicI.getI29()); + influxDBDataHarmPhasicI.setI30(dataHarmphasicI.getI30()); + influxDBDataHarmPhasicI.setI31(dataHarmphasicI.getI31()); + influxDBDataHarmPhasicI.setI32(dataHarmphasicI.getI32()); + influxDBDataHarmPhasicI.setI33(dataHarmphasicI.getI33()); + influxDBDataHarmPhasicI.setI34(dataHarmphasicI.getI34()); + influxDBDataHarmPhasicI.setI35(dataHarmphasicI.getI35()); + influxDBDataHarmPhasicI.setI36(dataHarmphasicI.getI36()); + influxDBDataHarmPhasicI.setI37(dataHarmphasicI.getI37()); + influxDBDataHarmPhasicI.setI38(dataHarmphasicI.getI38()); + influxDBDataHarmPhasicI.setI39(dataHarmphasicI.getI39()); + influxDBDataHarmPhasicI.setI40(dataHarmphasicI.getI40()); + influxDBDataHarmPhasicI.setI41(dataHarmphasicI.getI41()); + influxDBDataHarmPhasicI.setI42(dataHarmphasicI.getI42()); + influxDBDataHarmPhasicI.setI43(dataHarmphasicI.getI43()); + influxDBDataHarmPhasicI.setI44(dataHarmphasicI.getI44()); + influxDBDataHarmPhasicI.setI45(dataHarmphasicI.getI45()); + influxDBDataHarmPhasicI.setI46(dataHarmphasicI.getI46()); + influxDBDataHarmPhasicI.setI47(dataHarmphasicI.getI47()); + influxDBDataHarmPhasicI.setI48(dataHarmphasicI.getI48()); + influxDBDataHarmPhasicI.setI49(dataHarmphasicI.getI49()); + influxDBDataHarmPhasicI.setI50(dataHarmphasicI.getI50()); + } + else if (valueType.equals("MAX")){ + influxDBDataHarmPhasicI.setI1(dataHarmphasicI.getI1Max()); + influxDBDataHarmPhasicI.setI2(dataHarmphasicI.getI2Max()); + influxDBDataHarmPhasicI.setI3(dataHarmphasicI.getI3Max()); + influxDBDataHarmPhasicI.setI4(dataHarmphasicI.getI4Max()); + influxDBDataHarmPhasicI.setI5(dataHarmphasicI.getI5Max()); + influxDBDataHarmPhasicI.setI6(dataHarmphasicI.getI6Max()); + influxDBDataHarmPhasicI.setI7(dataHarmphasicI.getI7Max()); + influxDBDataHarmPhasicI.setI8(dataHarmphasicI.getI8Max()); + influxDBDataHarmPhasicI.setI9(dataHarmphasicI.getI9Max()); + influxDBDataHarmPhasicI.setI10(dataHarmphasicI.getI10Max()); + influxDBDataHarmPhasicI.setI11(dataHarmphasicI.getI11Max()); + influxDBDataHarmPhasicI.setI12(dataHarmphasicI.getI12Max()); + influxDBDataHarmPhasicI.setI13(dataHarmphasicI.getI13Max()); + influxDBDataHarmPhasicI.setI14(dataHarmphasicI.getI14Max()); + influxDBDataHarmPhasicI.setI15(dataHarmphasicI.getI15Max()); + influxDBDataHarmPhasicI.setI16(dataHarmphasicI.getI16Max()); + influxDBDataHarmPhasicI.setI17(dataHarmphasicI.getI17Max()); + influxDBDataHarmPhasicI.setI18(dataHarmphasicI.getI18Max()); + influxDBDataHarmPhasicI.setI19(dataHarmphasicI.getI19Max()); + influxDBDataHarmPhasicI.setI20(dataHarmphasicI.getI20Max()); + influxDBDataHarmPhasicI.setI21(dataHarmphasicI.getI21Max()); + influxDBDataHarmPhasicI.setI22(dataHarmphasicI.getI22Max()); + influxDBDataHarmPhasicI.setI23(dataHarmphasicI.getI23Max()); + influxDBDataHarmPhasicI.setI24(dataHarmphasicI.getI24Max()); + influxDBDataHarmPhasicI.setI25(dataHarmphasicI.getI25Max()); + influxDBDataHarmPhasicI.setI26(dataHarmphasicI.getI26Max()); + influxDBDataHarmPhasicI.setI27(dataHarmphasicI.getI27Max()); + influxDBDataHarmPhasicI.setI28(dataHarmphasicI.getI28Max()); + influxDBDataHarmPhasicI.setI29(dataHarmphasicI.getI29Max()); + influxDBDataHarmPhasicI.setI30(dataHarmphasicI.getI30Max()); + influxDBDataHarmPhasicI.setI31(dataHarmphasicI.getI31Max()); + influxDBDataHarmPhasicI.setI32(dataHarmphasicI.getI32Max()); + influxDBDataHarmPhasicI.setI33(dataHarmphasicI.getI33Max()); + influxDBDataHarmPhasicI.setI34(dataHarmphasicI.getI34Max()); + influxDBDataHarmPhasicI.setI35(dataHarmphasicI.getI35Max()); + influxDBDataHarmPhasicI.setI36(dataHarmphasicI.getI36Max()); + influxDBDataHarmPhasicI.setI37(dataHarmphasicI.getI37Max()); + influxDBDataHarmPhasicI.setI38(dataHarmphasicI.getI38Max()); + influxDBDataHarmPhasicI.setI39(dataHarmphasicI.getI39Max()); + influxDBDataHarmPhasicI.setI40(dataHarmphasicI.getI40Max()); + influxDBDataHarmPhasicI.setI41(dataHarmphasicI.getI41Max()); + influxDBDataHarmPhasicI.setI42(dataHarmphasicI.getI42Max()); + influxDBDataHarmPhasicI.setI43(dataHarmphasicI.getI43Max()); + influxDBDataHarmPhasicI.setI44(dataHarmphasicI.getI44Max()); + influxDBDataHarmPhasicI.setI45(dataHarmphasicI.getI45Max()); + influxDBDataHarmPhasicI.setI46(dataHarmphasicI.getI46Max()); + influxDBDataHarmPhasicI.setI47(dataHarmphasicI.getI47Max()); + influxDBDataHarmPhasicI.setI48(dataHarmphasicI.getI48Max()); + influxDBDataHarmPhasicI.setI49(dataHarmphasicI.getI49Max()); + influxDBDataHarmPhasicI.setI50(dataHarmphasicI.getI50Max()); + } + else if (valueType.equals("MIN")){ + influxDBDataHarmPhasicI.setI1(dataHarmphasicI.getI1Min()); + influxDBDataHarmPhasicI.setI2(dataHarmphasicI.getI2Min()); + influxDBDataHarmPhasicI.setI3(dataHarmphasicI.getI3Min()); + influxDBDataHarmPhasicI.setI4(dataHarmphasicI.getI4Min()); + influxDBDataHarmPhasicI.setI5(dataHarmphasicI.getI5Min()); + influxDBDataHarmPhasicI.setI6(dataHarmphasicI.getI6Min()); + influxDBDataHarmPhasicI.setI7(dataHarmphasicI.getI7Min()); + influxDBDataHarmPhasicI.setI8(dataHarmphasicI.getI8Min()); + influxDBDataHarmPhasicI.setI9(dataHarmphasicI.getI9Min()); + influxDBDataHarmPhasicI.setI10(dataHarmphasicI.getI10Min()); + influxDBDataHarmPhasicI.setI11(dataHarmphasicI.getI11Min()); + influxDBDataHarmPhasicI.setI12(dataHarmphasicI.getI12Min()); + influxDBDataHarmPhasicI.setI13(dataHarmphasicI.getI13Min()); + influxDBDataHarmPhasicI.setI14(dataHarmphasicI.getI14Min()); + influxDBDataHarmPhasicI.setI15(dataHarmphasicI.getI15Min()); + influxDBDataHarmPhasicI.setI16(dataHarmphasicI.getI16Min()); + influxDBDataHarmPhasicI.setI17(dataHarmphasicI.getI17Min()); + influxDBDataHarmPhasicI.setI18(dataHarmphasicI.getI18Min()); + influxDBDataHarmPhasicI.setI19(dataHarmphasicI.getI19Min()); + influxDBDataHarmPhasicI.setI20(dataHarmphasicI.getI20Min()); + influxDBDataHarmPhasicI.setI21(dataHarmphasicI.getI21Min()); + influxDBDataHarmPhasicI.setI22(dataHarmphasicI.getI22Min()); + influxDBDataHarmPhasicI.setI23(dataHarmphasicI.getI23Min()); + influxDBDataHarmPhasicI.setI24(dataHarmphasicI.getI24Min()); + influxDBDataHarmPhasicI.setI25(dataHarmphasicI.getI25Min()); + influxDBDataHarmPhasicI.setI26(dataHarmphasicI.getI26Min()); + influxDBDataHarmPhasicI.setI27(dataHarmphasicI.getI27Min()); + influxDBDataHarmPhasicI.setI28(dataHarmphasicI.getI28Min()); + influxDBDataHarmPhasicI.setI29(dataHarmphasicI.getI29Min()); + influxDBDataHarmPhasicI.setI30(dataHarmphasicI.getI30Min()); + influxDBDataHarmPhasicI.setI31(dataHarmphasicI.getI31Min()); + influxDBDataHarmPhasicI.setI32(dataHarmphasicI.getI32Min()); + influxDBDataHarmPhasicI.setI33(dataHarmphasicI.getI33Min()); + influxDBDataHarmPhasicI.setI34(dataHarmphasicI.getI34Min()); + influxDBDataHarmPhasicI.setI35(dataHarmphasicI.getI35Min()); + influxDBDataHarmPhasicI.setI36(dataHarmphasicI.getI36Min()); + influxDBDataHarmPhasicI.setI37(dataHarmphasicI.getI37Min()); + influxDBDataHarmPhasicI.setI38(dataHarmphasicI.getI38Min()); + influxDBDataHarmPhasicI.setI39(dataHarmphasicI.getI39Min()); + influxDBDataHarmPhasicI.setI40(dataHarmphasicI.getI40Min()); + influxDBDataHarmPhasicI.setI41(dataHarmphasicI.getI41Min()); + influxDBDataHarmPhasicI.setI42(dataHarmphasicI.getI42Min()); + influxDBDataHarmPhasicI.setI43(dataHarmphasicI.getI43Min()); + influxDBDataHarmPhasicI.setI44(dataHarmphasicI.getI44Min()); + influxDBDataHarmPhasicI.setI45(dataHarmphasicI.getI45Min()); + influxDBDataHarmPhasicI.setI46(dataHarmphasicI.getI46Min()); + influxDBDataHarmPhasicI.setI47(dataHarmphasicI.getI47Min()); + influxDBDataHarmPhasicI.setI48(dataHarmphasicI.getI48Min()); + influxDBDataHarmPhasicI.setI49(dataHarmphasicI.getI49Min()); + influxDBDataHarmPhasicI.setI50(dataHarmphasicI.getI50Min()); + } + else if (valueType.equals("CP95")){ + influxDBDataHarmPhasicI.setI1(dataHarmphasicI.getI1Cp95()); + influxDBDataHarmPhasicI.setI2(dataHarmphasicI.getI2Cp95()); + influxDBDataHarmPhasicI.setI3(dataHarmphasicI.getI3Cp95()); + influxDBDataHarmPhasicI.setI4(dataHarmphasicI.getI4Cp95()); + influxDBDataHarmPhasicI.setI5(dataHarmphasicI.getI5Cp95()); + influxDBDataHarmPhasicI.setI6(dataHarmphasicI.getI6Cp95()); + influxDBDataHarmPhasicI.setI7(dataHarmphasicI.getI7Cp95()); + influxDBDataHarmPhasicI.setI8(dataHarmphasicI.getI8Cp95()); + influxDBDataHarmPhasicI.setI9(dataHarmphasicI.getI9Cp95()); + influxDBDataHarmPhasicI.setI10(dataHarmphasicI.getI10Cp95()); + influxDBDataHarmPhasicI.setI11(dataHarmphasicI.getI11Cp95()); + influxDBDataHarmPhasicI.setI12(dataHarmphasicI.getI12Cp95()); + influxDBDataHarmPhasicI.setI13(dataHarmphasicI.getI13Cp95()); + influxDBDataHarmPhasicI.setI14(dataHarmphasicI.getI14Cp95()); + influxDBDataHarmPhasicI.setI15(dataHarmphasicI.getI15Cp95()); + influxDBDataHarmPhasicI.setI16(dataHarmphasicI.getI16Cp95()); + influxDBDataHarmPhasicI.setI17(dataHarmphasicI.getI17Cp95()); + influxDBDataHarmPhasicI.setI18(dataHarmphasicI.getI18Cp95()); + influxDBDataHarmPhasicI.setI19(dataHarmphasicI.getI19Cp95()); + influxDBDataHarmPhasicI.setI20(dataHarmphasicI.getI20Cp95()); + influxDBDataHarmPhasicI.setI21(dataHarmphasicI.getI21Cp95()); + influxDBDataHarmPhasicI.setI22(dataHarmphasicI.getI22Cp95()); + influxDBDataHarmPhasicI.setI23(dataHarmphasicI.getI23Cp95()); + influxDBDataHarmPhasicI.setI24(dataHarmphasicI.getI24Cp95()); + influxDBDataHarmPhasicI.setI25(dataHarmphasicI.getI25Cp95()); + influxDBDataHarmPhasicI.setI26(dataHarmphasicI.getI26Cp95()); + influxDBDataHarmPhasicI.setI27(dataHarmphasicI.getI27Cp95()); + influxDBDataHarmPhasicI.setI28(dataHarmphasicI.getI28Cp95()); + influxDBDataHarmPhasicI.setI29(dataHarmphasicI.getI29Cp95()); + influxDBDataHarmPhasicI.setI30(dataHarmphasicI.getI30Cp95()); + influxDBDataHarmPhasicI.setI31(dataHarmphasicI.getI31Cp95()); + influxDBDataHarmPhasicI.setI32(dataHarmphasicI.getI32Cp95()); + influxDBDataHarmPhasicI.setI33(dataHarmphasicI.getI33Cp95()); + influxDBDataHarmPhasicI.setI34(dataHarmphasicI.getI34Cp95()); + influxDBDataHarmPhasicI.setI35(dataHarmphasicI.getI35Cp95()); + influxDBDataHarmPhasicI.setI36(dataHarmphasicI.getI36Cp95()); + influxDBDataHarmPhasicI.setI37(dataHarmphasicI.getI37Cp95()); + influxDBDataHarmPhasicI.setI38(dataHarmphasicI.getI38Cp95()); + influxDBDataHarmPhasicI.setI39(dataHarmphasicI.getI39Cp95()); + influxDBDataHarmPhasicI.setI40(dataHarmphasicI.getI40Cp95()); + influxDBDataHarmPhasicI.setI41(dataHarmphasicI.getI41Cp95()); + influxDBDataHarmPhasicI.setI42(dataHarmphasicI.getI42Cp95()); + influxDBDataHarmPhasicI.setI43(dataHarmphasicI.getI43Cp95()); + influxDBDataHarmPhasicI.setI44(dataHarmphasicI.getI44Cp95()); + influxDBDataHarmPhasicI.setI45(dataHarmphasicI.getI45Cp95()); + influxDBDataHarmPhasicI.setI46(dataHarmphasicI.getI46Cp95()); + influxDBDataHarmPhasicI.setI47(dataHarmphasicI.getI47Cp95()); + influxDBDataHarmPhasicI.setI48(dataHarmphasicI.getI48Cp95()); + influxDBDataHarmPhasicI.setI49(dataHarmphasicI.getI49Cp95()); + influxDBDataHarmPhasicI.setI50(dataHarmphasicI.getI50Cp95()); + } + + influxDBDataHarmPhasicIList.add(influxDBDataHarmPhasicI); + + } + + + + return influxDBDataHarmPhasicIList; + } +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPhasicV.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPhasicV.java new file mode 100644 index 0000000..b6a0503 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPhasicV.java @@ -0,0 +1,430 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataHarmphasicI; +import com.njcn.oracle.bo.po.DataHarmphasicV; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 9:13 + */ +@Data +@Measurement(name = "data_harmphasic_v") +public class InfluxDBDataHarmPhasicV { + + @TimeColumn + @Column(name = "time",tag = true) + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag") + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "v_1") + private Float v1; + + @Column(name = "v_2") + private Float v2; + + @Column(name = "v_3") + private Float v3; + + @Column(name = "v_4") + private Float v4; + + @Column(name = "v_5") + private Float v5; + + @Column(name = "v_6") + private Float v6; + + @Column(name = "v_7") + private Float v7; + + @Column(name = "v_8") + private Float v8; + + @Column(name = "v_9") + private Float v9; + + @Column(name = "v_10") + private Float v10; + + @Column(name = "v_11") + private Float v11; + + @Column(name = "v_12") + private Float v12; + + @Column(name = "v_13") + private Float v13; + + @Column(name = "v_14") + private Float v14; + + @Column(name = "v_15") + private Float v15; + + @Column(name = "v_16") + private Float v16; + + @Column(name = "v_17") + private Float v17; + + @Column(name = "v_18") + private Float v18; + + @Column(name = "v_19") + private Float v19; + + @Column(name = "v_20") + private Float v20; + + @Column(name = "v_21") + private Float v21; + + @Column(name = "v_22") + private Float v22; + + @Column(name = "v_23") + private Float v23; + + @Column(name = "v_24") + private Float v24; + + @Column(name = "v_25") + private Float v25; + + @Column(name = "v_26") + private Float v26; + + @Column(name = "v_27") + private Float v27; + + @Column(name = "v_28") + private Float v28; + + @Column(name = "v_29") + private Float v29; + + @Column(name = "v_30") + private Float v30; + + @Column(name = "v_31") + private Float v31; + + @Column(name = "v_32") + private Float v32; + + @Column(name = "v_33") + private Float v33; + + @Column(name = "v_34") + private Float v34; + + @Column(name = "v_35") + private Float v35; + + @Column(name = "v_36") + private Float v36; + + @Column(name = "v_37") + private Float v37; + + @Column(name = "v_38") + private Float v38; + + @Column(name = "v_39") + private Float v39; + + @Column(name = "v_40") + private Float v40; + + @Column(name = "v_41") + private Float v41; + + @Column(name = "v_42") + private Float v42; + + @Column(name = "v_43") + private Float v43; + + @Column(name = "v_44") + private Float v44; + + @Column(name = "v_45") + private Float v45; + + @Column(name = "v_46") + private Float v46; + + @Column(name = "v_47") + private Float v47; + + @Column(name = "v_48") + private Float v48; + + @Column(name = "v_49") + private Float v49; + + @Column(name = "v_50") + private Float v50; + + public static List oralceToInfluxDB(DataHarmphasicV dataHarmphasicV) { + if (dataHarmphasicV == null) { + return null; + } + List influxDBDataHarmPhasicVList = new ArrayList<>(); + List valueTypeList = Stream.of("AVG", "MAX", "MIN", "CP95").collect(Collectors.toList()); + for (String valueType : valueTypeList) { + InfluxDBDataHarmPhasicV influxDBDataHarmPhasicV = new InfluxDBDataHarmPhasicV(); + Instant instant = dataHarmphasicV.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataHarmPhasicV.setTime(instant); + influxDBDataHarmPhasicV.setLineId(dataHarmphasicV.getLineid()+""); + influxDBDataHarmPhasicV.setPhaseType(dataHarmphasicV.getPhasicType()); + influxDBDataHarmPhasicV.setQualityFlag(dataHarmphasicV.getQualityflag()+""); + influxDBDataHarmPhasicV.setValueType(valueType); + if (valueType.equals("AVG")) { + influxDBDataHarmPhasicV.setV1(dataHarmphasicV.getV1()); + influxDBDataHarmPhasicV.setV2(dataHarmphasicV.getV2()); + influxDBDataHarmPhasicV.setV3(dataHarmphasicV.getV3()); + influxDBDataHarmPhasicV.setV4(dataHarmphasicV.getV4()); + influxDBDataHarmPhasicV.setV5(dataHarmphasicV.getV5()); + influxDBDataHarmPhasicV.setV6(dataHarmphasicV.getV6()); + influxDBDataHarmPhasicV.setV7(dataHarmphasicV.getV7()); + influxDBDataHarmPhasicV.setV8(dataHarmphasicV.getV8()); + influxDBDataHarmPhasicV.setV9(dataHarmphasicV.getV9()); + influxDBDataHarmPhasicV.setV10(dataHarmphasicV.getV10()); + influxDBDataHarmPhasicV.setV11(dataHarmphasicV.getV11()); + influxDBDataHarmPhasicV.setV12(dataHarmphasicV.getV12()); + influxDBDataHarmPhasicV.setV13(dataHarmphasicV.getV13()); + influxDBDataHarmPhasicV.setV14(dataHarmphasicV.getV14()); + influxDBDataHarmPhasicV.setV15(dataHarmphasicV.getV15()); + influxDBDataHarmPhasicV.setV16(dataHarmphasicV.getV16()); + influxDBDataHarmPhasicV.setV17(dataHarmphasicV.getV17()); + influxDBDataHarmPhasicV.setV18(dataHarmphasicV.getV18()); + influxDBDataHarmPhasicV.setV19(dataHarmphasicV.getV19()); + influxDBDataHarmPhasicV.setV20(dataHarmphasicV.getV20()); + influxDBDataHarmPhasicV.setV21(dataHarmphasicV.getV21()); + influxDBDataHarmPhasicV.setV22(dataHarmphasicV.getV22()); + influxDBDataHarmPhasicV.setV23(dataHarmphasicV.getV23()); + influxDBDataHarmPhasicV.setV24(dataHarmphasicV.getV24()); + influxDBDataHarmPhasicV.setV25(dataHarmphasicV.getV25()); + influxDBDataHarmPhasicV.setV26(dataHarmphasicV.getV26()); + influxDBDataHarmPhasicV.setV27(dataHarmphasicV.getV27()); + influxDBDataHarmPhasicV.setV28(dataHarmphasicV.getV28()); + influxDBDataHarmPhasicV.setV29(dataHarmphasicV.getV29()); + influxDBDataHarmPhasicV.setV30(dataHarmphasicV.getV30()); + influxDBDataHarmPhasicV.setV31(dataHarmphasicV.getV31()); + influxDBDataHarmPhasicV.setV32(dataHarmphasicV.getV32()); + influxDBDataHarmPhasicV.setV33(dataHarmphasicV.getV33()); + influxDBDataHarmPhasicV.setV34(dataHarmphasicV.getV34()); + influxDBDataHarmPhasicV.setV35(dataHarmphasicV.getV35()); + influxDBDataHarmPhasicV.setV36(dataHarmphasicV.getV36()); + influxDBDataHarmPhasicV.setV37(dataHarmphasicV.getV37()); + influxDBDataHarmPhasicV.setV38(dataHarmphasicV.getV38()); + influxDBDataHarmPhasicV.setV39(dataHarmphasicV.getV39()); + influxDBDataHarmPhasicV.setV40(dataHarmphasicV.getV40()); + influxDBDataHarmPhasicV.setV41(dataHarmphasicV.getV41()); + influxDBDataHarmPhasicV.setV42(dataHarmphasicV.getV42()); + influxDBDataHarmPhasicV.setV43(dataHarmphasicV.getV43()); + influxDBDataHarmPhasicV.setV44(dataHarmphasicV.getV44()); + influxDBDataHarmPhasicV.setV45(dataHarmphasicV.getV45()); + influxDBDataHarmPhasicV.setV46(dataHarmphasicV.getV46()); + influxDBDataHarmPhasicV.setV47(dataHarmphasicV.getV47()); + influxDBDataHarmPhasicV.setV48(dataHarmphasicV.getV48()); + influxDBDataHarmPhasicV.setV49(dataHarmphasicV.getV49()); + influxDBDataHarmPhasicV.setV50(dataHarmphasicV.getV50()); + } + else if (valueType.equals("MAX")){ + influxDBDataHarmPhasicV.setV1(dataHarmphasicV.getV1Max()); + influxDBDataHarmPhasicV.setV2(dataHarmphasicV.getV2Max()); + influxDBDataHarmPhasicV.setV3(dataHarmphasicV.getV3Max()); + influxDBDataHarmPhasicV.setV4(dataHarmphasicV.getV4Max()); + influxDBDataHarmPhasicV.setV5(dataHarmphasicV.getV5Max()); + influxDBDataHarmPhasicV.setV6(dataHarmphasicV.getV6Max()); + influxDBDataHarmPhasicV.setV7(dataHarmphasicV.getV7Max()); + influxDBDataHarmPhasicV.setV8(dataHarmphasicV.getV8Max()); + influxDBDataHarmPhasicV.setV9(dataHarmphasicV.getV9Max()); + influxDBDataHarmPhasicV.setV10(dataHarmphasicV.getV10Max()); + influxDBDataHarmPhasicV.setV11(dataHarmphasicV.getV11Max()); + influxDBDataHarmPhasicV.setV12(dataHarmphasicV.getV12Max()); + influxDBDataHarmPhasicV.setV13(dataHarmphasicV.getV13Max()); + influxDBDataHarmPhasicV.setV14(dataHarmphasicV.getV14Max()); + influxDBDataHarmPhasicV.setV15(dataHarmphasicV.getV15Max()); + influxDBDataHarmPhasicV.setV16(dataHarmphasicV.getV16Max()); + influxDBDataHarmPhasicV.setV17(dataHarmphasicV.getV17Max()); + influxDBDataHarmPhasicV.setV18(dataHarmphasicV.getV18Max()); + influxDBDataHarmPhasicV.setV19(dataHarmphasicV.getV19Max()); + influxDBDataHarmPhasicV.setV20(dataHarmphasicV.getV20Max()); + influxDBDataHarmPhasicV.setV21(dataHarmphasicV.getV21Max()); + influxDBDataHarmPhasicV.setV22(dataHarmphasicV.getV22Max()); + influxDBDataHarmPhasicV.setV23(dataHarmphasicV.getV23Max()); + influxDBDataHarmPhasicV.setV24(dataHarmphasicV.getV24Max()); + influxDBDataHarmPhasicV.setV25(dataHarmphasicV.getV25Max()); + influxDBDataHarmPhasicV.setV26(dataHarmphasicV.getV26Max()); + influxDBDataHarmPhasicV.setV27(dataHarmphasicV.getV27Max()); + influxDBDataHarmPhasicV.setV28(dataHarmphasicV.getV28Max()); + influxDBDataHarmPhasicV.setV29(dataHarmphasicV.getV29Max()); + influxDBDataHarmPhasicV.setV30(dataHarmphasicV.getV30Max()); + influxDBDataHarmPhasicV.setV31(dataHarmphasicV.getV31Max()); + influxDBDataHarmPhasicV.setV32(dataHarmphasicV.getV32Max()); + influxDBDataHarmPhasicV.setV33(dataHarmphasicV.getV33Max()); + influxDBDataHarmPhasicV.setV34(dataHarmphasicV.getV34Max()); + influxDBDataHarmPhasicV.setV35(dataHarmphasicV.getV35Max()); + influxDBDataHarmPhasicV.setV36(dataHarmphasicV.getV36Max()); + influxDBDataHarmPhasicV.setV37(dataHarmphasicV.getV37Max()); + influxDBDataHarmPhasicV.setV38(dataHarmphasicV.getV38Max()); + influxDBDataHarmPhasicV.setV39(dataHarmphasicV.getV39Max()); + influxDBDataHarmPhasicV.setV40(dataHarmphasicV.getV40Max()); + influxDBDataHarmPhasicV.setV41(dataHarmphasicV.getV41Max()); + influxDBDataHarmPhasicV.setV42(dataHarmphasicV.getV42Max()); + influxDBDataHarmPhasicV.setV43(dataHarmphasicV.getV43Max()); + influxDBDataHarmPhasicV.setV44(dataHarmphasicV.getV44Max()); + influxDBDataHarmPhasicV.setV45(dataHarmphasicV.getV45Max()); + influxDBDataHarmPhasicV.setV46(dataHarmphasicV.getV46Max()); + influxDBDataHarmPhasicV.setV47(dataHarmphasicV.getV47Max()); + influxDBDataHarmPhasicV.setV48(dataHarmphasicV.getV48Max()); + influxDBDataHarmPhasicV.setV49(dataHarmphasicV.getV49Max()); + influxDBDataHarmPhasicV.setV50(dataHarmphasicV.getV50Max()); + } + else if (valueType.equals("MIN")){ + influxDBDataHarmPhasicV.setV1(dataHarmphasicV.getV1Min()); + influxDBDataHarmPhasicV.setV2(dataHarmphasicV.getV2Min()); + influxDBDataHarmPhasicV.setV3(dataHarmphasicV.getV3Min()); + influxDBDataHarmPhasicV.setV4(dataHarmphasicV.getV4Min()); + influxDBDataHarmPhasicV.setV5(dataHarmphasicV.getV5Min()); + influxDBDataHarmPhasicV.setV6(dataHarmphasicV.getV6Min()); + influxDBDataHarmPhasicV.setV7(dataHarmphasicV.getV7Min()); + influxDBDataHarmPhasicV.setV8(dataHarmphasicV.getV8Min()); + influxDBDataHarmPhasicV.setV9(dataHarmphasicV.getV9Min()); + influxDBDataHarmPhasicV.setV10(dataHarmphasicV.getV10Min()); + influxDBDataHarmPhasicV.setV11(dataHarmphasicV.getV11Min()); + influxDBDataHarmPhasicV.setV12(dataHarmphasicV.getV12Min()); + influxDBDataHarmPhasicV.setV13(dataHarmphasicV.getV13Min()); + influxDBDataHarmPhasicV.setV14(dataHarmphasicV.getV14Min()); + influxDBDataHarmPhasicV.setV15(dataHarmphasicV.getV15Min()); + influxDBDataHarmPhasicV.setV16(dataHarmphasicV.getV16Min()); + influxDBDataHarmPhasicV.setV17(dataHarmphasicV.getV17Min()); + influxDBDataHarmPhasicV.setV18(dataHarmphasicV.getV18Min()); + influxDBDataHarmPhasicV.setV19(dataHarmphasicV.getV19Min()); + influxDBDataHarmPhasicV.setV20(dataHarmphasicV.getV20Min()); + influxDBDataHarmPhasicV.setV21(dataHarmphasicV.getV21Min()); + influxDBDataHarmPhasicV.setV22(dataHarmphasicV.getV22Min()); + influxDBDataHarmPhasicV.setV23(dataHarmphasicV.getV23Min()); + influxDBDataHarmPhasicV.setV24(dataHarmphasicV.getV24Min()); + influxDBDataHarmPhasicV.setV25(dataHarmphasicV.getV25Min()); + influxDBDataHarmPhasicV.setV26(dataHarmphasicV.getV26Min()); + influxDBDataHarmPhasicV.setV27(dataHarmphasicV.getV27Min()); + influxDBDataHarmPhasicV.setV28(dataHarmphasicV.getV28Min()); + influxDBDataHarmPhasicV.setV29(dataHarmphasicV.getV29Min()); + influxDBDataHarmPhasicV.setV30(dataHarmphasicV.getV30Min()); + influxDBDataHarmPhasicV.setV31(dataHarmphasicV.getV31Min()); + influxDBDataHarmPhasicV.setV32(dataHarmphasicV.getV32Min()); + influxDBDataHarmPhasicV.setV33(dataHarmphasicV.getV33Min()); + influxDBDataHarmPhasicV.setV34(dataHarmphasicV.getV34Min()); + influxDBDataHarmPhasicV.setV35(dataHarmphasicV.getV35Min()); + influxDBDataHarmPhasicV.setV36(dataHarmphasicV.getV36Min()); + influxDBDataHarmPhasicV.setV37(dataHarmphasicV.getV37Min()); + influxDBDataHarmPhasicV.setV38(dataHarmphasicV.getV38Min()); + influxDBDataHarmPhasicV.setV39(dataHarmphasicV.getV39Min()); + influxDBDataHarmPhasicV.setV40(dataHarmphasicV.getV40Min()); + influxDBDataHarmPhasicV.setV41(dataHarmphasicV.getV41Min()); + influxDBDataHarmPhasicV.setV42(dataHarmphasicV.getV42Min()); + influxDBDataHarmPhasicV.setV43(dataHarmphasicV.getV43Min()); + influxDBDataHarmPhasicV.setV44(dataHarmphasicV.getV44Min()); + influxDBDataHarmPhasicV.setV45(dataHarmphasicV.getV45Min()); + influxDBDataHarmPhasicV.setV46(dataHarmphasicV.getV46Min()); + influxDBDataHarmPhasicV.setV47(dataHarmphasicV.getV47Min()); + influxDBDataHarmPhasicV.setV48(dataHarmphasicV.getV48Min()); + influxDBDataHarmPhasicV.setV49(dataHarmphasicV.getV49Min()); + influxDBDataHarmPhasicV.setV50(dataHarmphasicV.getV50Min()); + } + else if (valueType.equals("CP95")){ + influxDBDataHarmPhasicV.setV1(dataHarmphasicV.getV1Cp95()); + influxDBDataHarmPhasicV.setV2(dataHarmphasicV.getV2Cp95()); + influxDBDataHarmPhasicV.setV3(dataHarmphasicV.getV3Cp95()); + influxDBDataHarmPhasicV.setV4(dataHarmphasicV.getV4Cp95()); + influxDBDataHarmPhasicV.setV5(dataHarmphasicV.getV5Cp95()); + influxDBDataHarmPhasicV.setV6(dataHarmphasicV.getV6Cp95()); + influxDBDataHarmPhasicV.setV7(dataHarmphasicV.getV7Cp95()); + influxDBDataHarmPhasicV.setV8(dataHarmphasicV.getV8Cp95()); + influxDBDataHarmPhasicV.setV9(dataHarmphasicV.getV9Cp95()); + influxDBDataHarmPhasicV.setV10(dataHarmphasicV.getV10Cp95()); + influxDBDataHarmPhasicV.setV11(dataHarmphasicV.getV11Cp95()); + influxDBDataHarmPhasicV.setV12(dataHarmphasicV.getV12Cp95()); + influxDBDataHarmPhasicV.setV13(dataHarmphasicV.getV13Cp95()); + influxDBDataHarmPhasicV.setV14(dataHarmphasicV.getV14Cp95()); + influxDBDataHarmPhasicV.setV15(dataHarmphasicV.getV15Cp95()); + influxDBDataHarmPhasicV.setV16(dataHarmphasicV.getV16Cp95()); + influxDBDataHarmPhasicV.setV17(dataHarmphasicV.getV17Cp95()); + influxDBDataHarmPhasicV.setV18(dataHarmphasicV.getV18Cp95()); + influxDBDataHarmPhasicV.setV19(dataHarmphasicV.getV19Cp95()); + influxDBDataHarmPhasicV.setV20(dataHarmphasicV.getV20Cp95()); + influxDBDataHarmPhasicV.setV21(dataHarmphasicV.getV21Cp95()); + influxDBDataHarmPhasicV.setV22(dataHarmphasicV.getV22Cp95()); + influxDBDataHarmPhasicV.setV23(dataHarmphasicV.getV23Cp95()); + influxDBDataHarmPhasicV.setV24(dataHarmphasicV.getV24Cp95()); + influxDBDataHarmPhasicV.setV25(dataHarmphasicV.getV25Cp95()); + influxDBDataHarmPhasicV.setV26(dataHarmphasicV.getV26Cp95()); + influxDBDataHarmPhasicV.setV27(dataHarmphasicV.getV27Cp95()); + influxDBDataHarmPhasicV.setV28(dataHarmphasicV.getV28Cp95()); + influxDBDataHarmPhasicV.setV29(dataHarmphasicV.getV29Cp95()); + influxDBDataHarmPhasicV.setV30(dataHarmphasicV.getV30Cp95()); + influxDBDataHarmPhasicV.setV31(dataHarmphasicV.getV31Cp95()); + influxDBDataHarmPhasicV.setV32(dataHarmphasicV.getV32Cp95()); + influxDBDataHarmPhasicV.setV33(dataHarmphasicV.getV33Cp95()); + influxDBDataHarmPhasicV.setV34(dataHarmphasicV.getV34Cp95()); + influxDBDataHarmPhasicV.setV35(dataHarmphasicV.getV35Cp95()); + influxDBDataHarmPhasicV.setV36(dataHarmphasicV.getV36Cp95()); + influxDBDataHarmPhasicV.setV37(dataHarmphasicV.getV37Cp95()); + influxDBDataHarmPhasicV.setV38(dataHarmphasicV.getV38Cp95()); + influxDBDataHarmPhasicV.setV39(dataHarmphasicV.getV39Cp95()); + influxDBDataHarmPhasicV.setV40(dataHarmphasicV.getV40Cp95()); + influxDBDataHarmPhasicV.setV41(dataHarmphasicV.getV41Cp95()); + influxDBDataHarmPhasicV.setV42(dataHarmphasicV.getV42Cp95()); + influxDBDataHarmPhasicV.setV43(dataHarmphasicV.getV43Cp95()); + influxDBDataHarmPhasicV.setV44(dataHarmphasicV.getV44Cp95()); + influxDBDataHarmPhasicV.setV45(dataHarmphasicV.getV45Cp95()); + influxDBDataHarmPhasicV.setV46(dataHarmphasicV.getV46Cp95()); + influxDBDataHarmPhasicV.setV47(dataHarmphasicV.getV47Cp95()); + influxDBDataHarmPhasicV.setV48(dataHarmphasicV.getV48Cp95()); + influxDBDataHarmPhasicV.setV49(dataHarmphasicV.getV49Cp95()); + influxDBDataHarmPhasicV.setV50(dataHarmphasicV.getV50Cp95()); + } + + influxDBDataHarmPhasicVList.add(influxDBDataHarmPhasicV); + + } + + + + return influxDBDataHarmPhasicVList; + } + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPowerP.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPowerP.java new file mode 100644 index 0000000..60c9c9d --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPowerP.java @@ -0,0 +1,438 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataHarmpowerP; +import com.njcn.oracle.bo.po.DataHarmpowerP; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 9:13 + */ +@Data +@Measurement(name = "data_harmpower_p") +public class InfluxDBDataHarmPowerP { + + @TimeColumn + @Column(name = "time",tag = true) + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag") + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "df") + private Float df; + + @Column(name = "pf") + private Float pf; + + @Column(name = "p") + private Float p; + + @Column(name = "p_1") + private Float p1; + + @Column(name = "p_2") + private Float p2; + + @Column(name = "p_3") + private Float p3; + + @Column(name = "p_4") + private Float p4; + + @Column(name = "p_5") + private Float p5; + + @Column(name = "p_6") + private Float p6; + + @Column(name = "p_7") + private Float p7; + + @Column(name = "p_8") + private Float p8; + + @Column(name = "p_9") + private Float p9; + + @Column(name = "p_10") + private Float p10; + + @Column(name = "p_11") + private Float p11; + + @Column(name = "p_12") + private Float p12; + + @Column(name = "p_13") + private Float p13; + + @Column(name = "p_14") + private Float p14; + + @Column(name = "p_15") + private Float p15; + + @Column(name = "p_16") + private Float p16; + + @Column(name = "p_17") + private Float p17; + + @Column(name = "p_18") + private Float p18; + + @Column(name = "p_19") + private Float p19; + + @Column(name = "p_20") + private Float p20; + + @Column(name = "p_21") + private Float p21; + + @Column(name = "p_22") + private Float p22; + + @Column(name = "p_23") + private Float p23; + + @Column(name = "p_24") + private Float p24; + + @Column(name = "p_25") + private Float p25; + + @Column(name = "p_26") + private Float p26; + + @Column(name = "p_27") + private Float p27; + + @Column(name = "p_28") + private Float p28; + + @Column(name = "p_29") + private Float p29; + + @Column(name = "p_30") + private Float p30; + + @Column(name = "p_31") + private Float p31; + + @Column(name = "p_32") + private Float p32; + + @Column(name = "p_33") + private Float p33; + + @Column(name = "p_34") + private Float p34; + + @Column(name = "p_35") + private Float p35; + + @Column(name = "p_36") + private Float p36; + + @Column(name = "p_37") + private Float p37; + + @Column(name = "p_38") + private Float p38; + + @Column(name = "p_39") + private Float p39; + + @Column(name = "p_40") + private Float p40; + + @Column(name = "p_41") + private Float p41; + + @Column(name = "p_42") + private Float p42; + + @Column(name = "p_43") + private Float p43; + + @Column(name = "p_44") + private Float p44; + + @Column(name = "p_45") + private Float p45; + + @Column(name = "p_46") + private Float p46; + + @Column(name = "p_47") + private Float p47; + + @Column(name = "p_48") + private Float p48; + + @Column(name = "p_49") + private Float p49; + + @Column(name = "p_50") + private Float p50; + + public static List oralceToInfluxDB(DataHarmpowerP dataHarmpowerP) { + if (dataHarmpowerP == null) { + return null; + } + List influxDBDataHarmPhasicVList = new ArrayList<>(); + List valueTypeList = Stream.of("AVG", "MAX", "MIN", "CP95").collect(Collectors.toList()); + for (String valueType : valueTypeList) { + InfluxDBDataHarmPowerP influxDBDataHarmPhasicV = new InfluxDBDataHarmPowerP(); + Instant instant = dataHarmpowerP.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataHarmPhasicV.setTime(instant); + influxDBDataHarmPhasicV.setLineId(dataHarmpowerP.getLineid()+""); + influxDBDataHarmPhasicV.setPhaseType(dataHarmpowerP.getPhasicType()); + influxDBDataHarmPhasicV.setQualityFlag(dataHarmpowerP.getQualityflag()+""); + influxDBDataHarmPhasicV.setValueType(valueType); + if (valueType.equals("AVG")) { + influxDBDataHarmPhasicV.setP1(dataHarmpowerP.getP1()); + influxDBDataHarmPhasicV.setP2(dataHarmpowerP.getP2()); + influxDBDataHarmPhasicV.setP3(dataHarmpowerP.getP3()); + influxDBDataHarmPhasicV.setP4(dataHarmpowerP.getP4()); + influxDBDataHarmPhasicV.setP5(dataHarmpowerP.getP5()); + influxDBDataHarmPhasicV.setP6(dataHarmpowerP.getP6()); + influxDBDataHarmPhasicV.setP7(dataHarmpowerP.getP7()); + influxDBDataHarmPhasicV.setP8(dataHarmpowerP.getP8()); + influxDBDataHarmPhasicV.setP9(dataHarmpowerP.getP9()); + influxDBDataHarmPhasicV.setP10(dataHarmpowerP.getP10()); + influxDBDataHarmPhasicV.setP11(dataHarmpowerP.getP11()); + influxDBDataHarmPhasicV.setP12(dataHarmpowerP.getP12()); + influxDBDataHarmPhasicV.setP13(dataHarmpowerP.getP13()); + influxDBDataHarmPhasicV.setP14(dataHarmpowerP.getP14()); + influxDBDataHarmPhasicV.setP15(dataHarmpowerP.getP15()); + influxDBDataHarmPhasicV.setP16(dataHarmpowerP.getP16()); + influxDBDataHarmPhasicV.setP17(dataHarmpowerP.getP17()); + influxDBDataHarmPhasicV.setP18(dataHarmpowerP.getP18()); + influxDBDataHarmPhasicV.setP19(dataHarmpowerP.getP19()); + influxDBDataHarmPhasicV.setP20(dataHarmpowerP.getP20()); + influxDBDataHarmPhasicV.setP21(dataHarmpowerP.getP21()); + influxDBDataHarmPhasicV.setP22(dataHarmpowerP.getP22()); + influxDBDataHarmPhasicV.setP23(dataHarmpowerP.getP23()); + influxDBDataHarmPhasicV.setP24(dataHarmpowerP.getP24()); + influxDBDataHarmPhasicV.setP25(dataHarmpowerP.getP25()); + influxDBDataHarmPhasicV.setP26(dataHarmpowerP.getP26()); + influxDBDataHarmPhasicV.setP27(dataHarmpowerP.getP27()); + influxDBDataHarmPhasicV.setP28(dataHarmpowerP.getP28()); + influxDBDataHarmPhasicV.setP29(dataHarmpowerP.getP29()); + influxDBDataHarmPhasicV.setP30(dataHarmpowerP.getP30()); + influxDBDataHarmPhasicV.setP31(dataHarmpowerP.getP31()); + influxDBDataHarmPhasicV.setP32(dataHarmpowerP.getP32()); + influxDBDataHarmPhasicV.setP33(dataHarmpowerP.getP33()); + influxDBDataHarmPhasicV.setP34(dataHarmpowerP.getP34()); + influxDBDataHarmPhasicV.setP35(dataHarmpowerP.getP35()); + influxDBDataHarmPhasicV.setP36(dataHarmpowerP.getP36()); + influxDBDataHarmPhasicV.setP37(dataHarmpowerP.getP37()); + influxDBDataHarmPhasicV.setP38(dataHarmpowerP.getP38()); + influxDBDataHarmPhasicV.setP39(dataHarmpowerP.getP39()); + influxDBDataHarmPhasicV.setP40(dataHarmpowerP.getP40()); + influxDBDataHarmPhasicV.setP41(dataHarmpowerP.getP41()); + influxDBDataHarmPhasicV.setP42(dataHarmpowerP.getP42()); + influxDBDataHarmPhasicV.setP43(dataHarmpowerP.getP43()); + influxDBDataHarmPhasicV.setP44(dataHarmpowerP.getP44()); + influxDBDataHarmPhasicV.setP45(dataHarmpowerP.getP45()); + influxDBDataHarmPhasicV.setP46(dataHarmpowerP.getP46()); + influxDBDataHarmPhasicV.setP47(dataHarmpowerP.getP47()); + influxDBDataHarmPhasicV.setP48(dataHarmpowerP.getP48()); + influxDBDataHarmPhasicV.setP49(dataHarmpowerP.getP49()); + influxDBDataHarmPhasicV.setP50(dataHarmpowerP.getP50()); + } + else if (valueType.equals("MAX")){ + influxDBDataHarmPhasicV.setP1(dataHarmpowerP.getP1Max()); + influxDBDataHarmPhasicV.setP2(dataHarmpowerP.getP2Max()); + influxDBDataHarmPhasicV.setP3(dataHarmpowerP.getP3Max()); + influxDBDataHarmPhasicV.setP4(dataHarmpowerP.getP4Max()); + influxDBDataHarmPhasicV.setP5(dataHarmpowerP.getP5Max()); + influxDBDataHarmPhasicV.setP6(dataHarmpowerP.getP6Max()); + influxDBDataHarmPhasicV.setP7(dataHarmpowerP.getP7Max()); + influxDBDataHarmPhasicV.setP8(dataHarmpowerP.getP8Max()); + influxDBDataHarmPhasicV.setP9(dataHarmpowerP.getP9Max()); + influxDBDataHarmPhasicV.setP10(dataHarmpowerP.getP10Max()); + influxDBDataHarmPhasicV.setP11(dataHarmpowerP.getP11Max()); + influxDBDataHarmPhasicV.setP12(dataHarmpowerP.getP12Max()); + influxDBDataHarmPhasicV.setP13(dataHarmpowerP.getP13Max()); + influxDBDataHarmPhasicV.setP14(dataHarmpowerP.getP14Max()); + influxDBDataHarmPhasicV.setP15(dataHarmpowerP.getP15Max()); + influxDBDataHarmPhasicV.setP16(dataHarmpowerP.getP16Max()); + influxDBDataHarmPhasicV.setP17(dataHarmpowerP.getP17Max()); + influxDBDataHarmPhasicV.setP18(dataHarmpowerP.getP18Max()); + influxDBDataHarmPhasicV.setP19(dataHarmpowerP.getP19Max()); + influxDBDataHarmPhasicV.setP20(dataHarmpowerP.getP20Max()); + influxDBDataHarmPhasicV.setP21(dataHarmpowerP.getP21Max()); + influxDBDataHarmPhasicV.setP22(dataHarmpowerP.getP22Max()); + influxDBDataHarmPhasicV.setP23(dataHarmpowerP.getP23Max()); + influxDBDataHarmPhasicV.setP24(dataHarmpowerP.getP24Max()); + influxDBDataHarmPhasicV.setP25(dataHarmpowerP.getP25Max()); + influxDBDataHarmPhasicV.setP26(dataHarmpowerP.getP26Max()); + influxDBDataHarmPhasicV.setP27(dataHarmpowerP.getP27Max()); + influxDBDataHarmPhasicV.setP28(dataHarmpowerP.getP28Max()); + influxDBDataHarmPhasicV.setP29(dataHarmpowerP.getP29Max()); + influxDBDataHarmPhasicV.setP30(dataHarmpowerP.getP30Max()); + influxDBDataHarmPhasicV.setP31(dataHarmpowerP.getP31Max()); + influxDBDataHarmPhasicV.setP32(dataHarmpowerP.getP32Max()); + influxDBDataHarmPhasicV.setP33(dataHarmpowerP.getP33Max()); + influxDBDataHarmPhasicV.setP34(dataHarmpowerP.getP34Max()); + influxDBDataHarmPhasicV.setP35(dataHarmpowerP.getP35Max()); + influxDBDataHarmPhasicV.setP36(dataHarmpowerP.getP36Max()); + influxDBDataHarmPhasicV.setP37(dataHarmpowerP.getP37Max()); + influxDBDataHarmPhasicV.setP38(dataHarmpowerP.getP38Max()); + influxDBDataHarmPhasicV.setP39(dataHarmpowerP.getP39Max()); + influxDBDataHarmPhasicV.setP40(dataHarmpowerP.getP40Max()); + influxDBDataHarmPhasicV.setP41(dataHarmpowerP.getP41Max()); + influxDBDataHarmPhasicV.setP42(dataHarmpowerP.getP42Max()); + influxDBDataHarmPhasicV.setP43(dataHarmpowerP.getP43Max()); + influxDBDataHarmPhasicV.setP44(dataHarmpowerP.getP44Max()); + influxDBDataHarmPhasicV.setP45(dataHarmpowerP.getP45Max()); + influxDBDataHarmPhasicV.setP46(dataHarmpowerP.getP46Max()); + influxDBDataHarmPhasicV.setP47(dataHarmpowerP.getP47Max()); + influxDBDataHarmPhasicV.setP48(dataHarmpowerP.getP48Max()); + influxDBDataHarmPhasicV.setP49(dataHarmpowerP.getP49Max()); + influxDBDataHarmPhasicV.setP50(dataHarmpowerP.getP50Max()); + } + else if (valueType.equals("MIN")){ + influxDBDataHarmPhasicV.setP1(dataHarmpowerP.getP1Min()); + influxDBDataHarmPhasicV.setP2(dataHarmpowerP.getP2Min()); + influxDBDataHarmPhasicV.setP3(dataHarmpowerP.getP3Min()); + influxDBDataHarmPhasicV.setP4(dataHarmpowerP.getP4Min()); + influxDBDataHarmPhasicV.setP5(dataHarmpowerP.getP5Min()); + influxDBDataHarmPhasicV.setP6(dataHarmpowerP.getP6Min()); + influxDBDataHarmPhasicV.setP7(dataHarmpowerP.getP7Min()); + influxDBDataHarmPhasicV.setP8(dataHarmpowerP.getP8Min()); + influxDBDataHarmPhasicV.setP9(dataHarmpowerP.getP9Min()); + influxDBDataHarmPhasicV.setP10(dataHarmpowerP.getP10Min()); + influxDBDataHarmPhasicV.setP11(dataHarmpowerP.getP11Min()); + influxDBDataHarmPhasicV.setP12(dataHarmpowerP.getP12Min()); + influxDBDataHarmPhasicV.setP13(dataHarmpowerP.getP13Min()); + influxDBDataHarmPhasicV.setP14(dataHarmpowerP.getP14Min()); + influxDBDataHarmPhasicV.setP15(dataHarmpowerP.getP15Min()); + influxDBDataHarmPhasicV.setP16(dataHarmpowerP.getP16Min()); + influxDBDataHarmPhasicV.setP17(dataHarmpowerP.getP17Min()); + influxDBDataHarmPhasicV.setP18(dataHarmpowerP.getP18Min()); + influxDBDataHarmPhasicV.setP19(dataHarmpowerP.getP19Min()); + influxDBDataHarmPhasicV.setP20(dataHarmpowerP.getP20Min()); + influxDBDataHarmPhasicV.setP21(dataHarmpowerP.getP21Min()); + influxDBDataHarmPhasicV.setP22(dataHarmpowerP.getP22Min()); + influxDBDataHarmPhasicV.setP23(dataHarmpowerP.getP23Min()); + influxDBDataHarmPhasicV.setP24(dataHarmpowerP.getP24Min()); + influxDBDataHarmPhasicV.setP25(dataHarmpowerP.getP25Min()); + influxDBDataHarmPhasicV.setP26(dataHarmpowerP.getP26Min()); + influxDBDataHarmPhasicV.setP27(dataHarmpowerP.getP27Min()); + influxDBDataHarmPhasicV.setP28(dataHarmpowerP.getP28Min()); + influxDBDataHarmPhasicV.setP29(dataHarmpowerP.getP29Min()); + influxDBDataHarmPhasicV.setP30(dataHarmpowerP.getP30Min()); + influxDBDataHarmPhasicV.setP31(dataHarmpowerP.getP31Min()); + influxDBDataHarmPhasicV.setP32(dataHarmpowerP.getP32Min()); + influxDBDataHarmPhasicV.setP33(dataHarmpowerP.getP33Min()); + influxDBDataHarmPhasicV.setP34(dataHarmpowerP.getP34Min()); + influxDBDataHarmPhasicV.setP35(dataHarmpowerP.getP35Min()); + influxDBDataHarmPhasicV.setP36(dataHarmpowerP.getP36Min()); + influxDBDataHarmPhasicV.setP37(dataHarmpowerP.getP37Min()); + influxDBDataHarmPhasicV.setP38(dataHarmpowerP.getP38Min()); + influxDBDataHarmPhasicV.setP39(dataHarmpowerP.getP39Min()); + influxDBDataHarmPhasicV.setP40(dataHarmpowerP.getP40Min()); + influxDBDataHarmPhasicV.setP41(dataHarmpowerP.getP41Min()); + influxDBDataHarmPhasicV.setP42(dataHarmpowerP.getP42Min()); + influxDBDataHarmPhasicV.setP43(dataHarmpowerP.getP43Min()); + influxDBDataHarmPhasicV.setP44(dataHarmpowerP.getP44Min()); + influxDBDataHarmPhasicV.setP45(dataHarmpowerP.getP45Min()); + influxDBDataHarmPhasicV.setP46(dataHarmpowerP.getP46Min()); + influxDBDataHarmPhasicV.setP47(dataHarmpowerP.getP47Min()); + influxDBDataHarmPhasicV.setP48(dataHarmpowerP.getP48Min()); + influxDBDataHarmPhasicV.setP49(dataHarmpowerP.getP49Min()); + influxDBDataHarmPhasicV.setP50(dataHarmpowerP.getP50Min()); + } + else if (valueType.equals("CP95")){ + influxDBDataHarmPhasicV.setP1(dataHarmpowerP.getP1Cp95()); + influxDBDataHarmPhasicV.setP2(dataHarmpowerP.getP2Cp95()); + influxDBDataHarmPhasicV.setP3(dataHarmpowerP.getP3Cp95()); + influxDBDataHarmPhasicV.setP4(dataHarmpowerP.getP4Cp95()); + influxDBDataHarmPhasicV.setP5(dataHarmpowerP.getP5Cp95()); + influxDBDataHarmPhasicV.setP6(dataHarmpowerP.getP6Cp95()); + influxDBDataHarmPhasicV.setP7(dataHarmpowerP.getP7Cp95()); + influxDBDataHarmPhasicV.setP8(dataHarmpowerP.getP8Cp95()); + influxDBDataHarmPhasicV.setP9(dataHarmpowerP.getP9Cp95()); + influxDBDataHarmPhasicV.setP10(dataHarmpowerP.getP10Cp95()); + influxDBDataHarmPhasicV.setP11(dataHarmpowerP.getP11Cp95()); + influxDBDataHarmPhasicV.setP12(dataHarmpowerP.getP12Cp95()); + influxDBDataHarmPhasicV.setP13(dataHarmpowerP.getP13Cp95()); + influxDBDataHarmPhasicV.setP14(dataHarmpowerP.getP14Cp95()); + influxDBDataHarmPhasicV.setP15(dataHarmpowerP.getP15Cp95()); + influxDBDataHarmPhasicV.setP16(dataHarmpowerP.getP16Cp95()); + influxDBDataHarmPhasicV.setP17(dataHarmpowerP.getP17Cp95()); + influxDBDataHarmPhasicV.setP18(dataHarmpowerP.getP18Cp95()); + influxDBDataHarmPhasicV.setP19(dataHarmpowerP.getP19Cp95()); + influxDBDataHarmPhasicV.setP20(dataHarmpowerP.getP20Cp95()); + influxDBDataHarmPhasicV.setP21(dataHarmpowerP.getP21Cp95()); + influxDBDataHarmPhasicV.setP22(dataHarmpowerP.getP22Cp95()); + influxDBDataHarmPhasicV.setP23(dataHarmpowerP.getP23Cp95()); + influxDBDataHarmPhasicV.setP24(dataHarmpowerP.getP24Cp95()); + influxDBDataHarmPhasicV.setP25(dataHarmpowerP.getP25Cp95()); + influxDBDataHarmPhasicV.setP26(dataHarmpowerP.getP26Cp95()); + influxDBDataHarmPhasicV.setP27(dataHarmpowerP.getP27Cp95()); + influxDBDataHarmPhasicV.setP28(dataHarmpowerP.getP28Cp95()); + influxDBDataHarmPhasicV.setP29(dataHarmpowerP.getP29Cp95()); + influxDBDataHarmPhasicV.setP30(dataHarmpowerP.getP30Cp95()); + influxDBDataHarmPhasicV.setP31(dataHarmpowerP.getP31Cp95()); + influxDBDataHarmPhasicV.setP32(dataHarmpowerP.getP32Cp95()); + influxDBDataHarmPhasicV.setP33(dataHarmpowerP.getP33Cp95()); + influxDBDataHarmPhasicV.setP34(dataHarmpowerP.getP34Cp95()); + influxDBDataHarmPhasicV.setP35(dataHarmpowerP.getP35Cp95()); + influxDBDataHarmPhasicV.setP36(dataHarmpowerP.getP36Cp95()); + influxDBDataHarmPhasicV.setP37(dataHarmpowerP.getP37Cp95()); + influxDBDataHarmPhasicV.setP38(dataHarmpowerP.getP38Cp95()); + influxDBDataHarmPhasicV.setP39(dataHarmpowerP.getP39Cp95()); + influxDBDataHarmPhasicV.setP40(dataHarmpowerP.getP40Cp95()); + influxDBDataHarmPhasicV.setP41(dataHarmpowerP.getP41Cp95()); + influxDBDataHarmPhasicV.setP42(dataHarmpowerP.getP42Cp95()); + influxDBDataHarmPhasicV.setP43(dataHarmpowerP.getP43Cp95()); + influxDBDataHarmPhasicV.setP44(dataHarmpowerP.getP44Cp95()); + influxDBDataHarmPhasicV.setP45(dataHarmpowerP.getP45Cp95()); + influxDBDataHarmPhasicV.setP46(dataHarmpowerP.getP46Cp95()); + influxDBDataHarmPhasicV.setP47(dataHarmpowerP.getP47Cp95()); + influxDBDataHarmPhasicV.setP48(dataHarmpowerP.getP48Cp95()); + influxDBDataHarmPhasicV.setP49(dataHarmpowerP.getP49Cp95()); + influxDBDataHarmPhasicV.setP50(dataHarmpowerP.getP50Cp95()); + } + + influxDBDataHarmPhasicVList.add(influxDBDataHarmPhasicV); + + } + + + + return influxDBDataHarmPhasicVList; + } +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPowerQ.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPowerQ.java new file mode 100644 index 0000000..3df7664 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPowerQ.java @@ -0,0 +1,433 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataHarmpowerQ; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 9:13 + */ +@Data +@Measurement(name = "data_harmpower_q") +public class InfluxDBDataHarmPowerQ { + + @TimeColumn + @Column(name = "time",tag = true) + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag") + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "q") + private Float q; + + @Column(name = "q_1") + private Float q1; + + @Column(name = "q_2") + private Float q2; + + @Column(name = "q_3") + private Float q3; + + @Column(name = "q_4") + private Float q4; + + @Column(name = "q_5") + private Float q5; + + @Column(name = "q_6") + private Float q6; + + @Column(name = "q_7") + private Float q7; + + @Column(name = "q_8") + private Float q8; + + @Column(name = "q_9") + private Float q9; + + @Column(name = "q_10") + private Float q10; + + @Column(name = "q_11") + private Float q11; + + @Column(name = "q_12") + private Float q12; + + @Column(name = "q_13") + private Float q13; + + @Column(name = "q_14") + private Float q14; + + @Column(name = "q_15") + private Float q15; + + @Column(name = "q_16") + private Float q16; + + @Column(name = "q_17") + private Float q17; + + @Column(name = "q_18") + private Float q18; + + @Column(name = "q_19") + private Float q19; + + @Column(name = "q_20") + private Float q20; + + @Column(name = "q_21") + private Float q21; + + @Column(name = "q_22") + private Float q22; + + @Column(name = "q_23") + private Float q23; + + @Column(name = "q_24") + private Float q24; + + @Column(name = "q_25") + private Float q25; + + @Column(name = "q_26") + private Float q26; + + @Column(name = "q_27") + private Float q27; + + @Column(name = "q_28") + private Float q28; + + @Column(name = "q_29") + private Float q29; + + @Column(name = "q_30") + private Float q30; + + @Column(name = "q_31") + private Float q31; + + @Column(name = "q_32") + private Float q32; + + @Column(name = "q_33") + private Float q33; + + @Column(name = "q_34") + private Float q34; + + @Column(name = "q_35") + private Float q35; + + @Column(name = "q_36") + private Float q36; + + @Column(name = "q_37") + private Float q37; + + @Column(name = "q_38") + private Float q38; + + @Column(name = "q_39") + private Float q39; + + @Column(name = "q_40") + private Float q40; + + @Column(name = "q_41") + private Float q41; + + @Column(name = "q_42") + private Float q42; + + @Column(name = "q_43") + private Float q43; + + @Column(name = "q_44") + private Float q44; + + @Column(name = "q_45") + private Float q45; + + @Column(name = "q_46") + private Float q46; + + @Column(name = "q_47") + private Float q47; + + @Column(name = "q_48") + private Float q48; + + @Column(name = "q_49") + private Float q49; + + @Column(name = "q_50") + private Float q50; + + public static List oralceToInfluxDB(DataHarmpowerQ dataHarmpowerQ) { + if (dataHarmpowerQ == null) { + return null; + } + List influxDBDataHarmPhasicVList = new ArrayList<>(); + List valueTypeList = Stream.of("AVG", "MAX", "MIN", "CP95").collect(Collectors.toList()); + for (String valueType : valueTypeList) { + InfluxDBDataHarmPowerQ influxDBDataHarmPhasicV = new InfluxDBDataHarmPowerQ(); + Instant instant = dataHarmpowerQ.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataHarmPhasicV.setTime(instant); + influxDBDataHarmPhasicV.setLineId(dataHarmpowerQ.getLineid()+""); + influxDBDataHarmPhasicV.setPhaseType(dataHarmpowerQ.getPhasicType()); + influxDBDataHarmPhasicV.setQualityFlag(dataHarmpowerQ.getQualityflag()+""); + influxDBDataHarmPhasicV.setValueType(valueType); + if (valueType.equals("AVG")) { + influxDBDataHarmPhasicV.setQ1(dataHarmpowerQ.getQ1()); + influxDBDataHarmPhasicV.setQ2(dataHarmpowerQ.getQ2()); + influxDBDataHarmPhasicV.setQ3(dataHarmpowerQ.getQ3()); + influxDBDataHarmPhasicV.setQ4(dataHarmpowerQ.getQ4()); + influxDBDataHarmPhasicV.setQ5(dataHarmpowerQ.getQ5()); + influxDBDataHarmPhasicV.setQ6(dataHarmpowerQ.getQ6()); + influxDBDataHarmPhasicV.setQ7(dataHarmpowerQ.getQ7()); + influxDBDataHarmPhasicV.setQ8(dataHarmpowerQ.getQ8()); + influxDBDataHarmPhasicV.setQ9(dataHarmpowerQ.getQ9()); + influxDBDataHarmPhasicV.setQ10(dataHarmpowerQ.getQ10()); + influxDBDataHarmPhasicV.setQ11(dataHarmpowerQ.getQ11()); + influxDBDataHarmPhasicV.setQ12(dataHarmpowerQ.getQ12()); + influxDBDataHarmPhasicV.setQ13(dataHarmpowerQ.getQ13()); + influxDBDataHarmPhasicV.setQ14(dataHarmpowerQ.getQ14()); + influxDBDataHarmPhasicV.setQ15(dataHarmpowerQ.getQ15()); + influxDBDataHarmPhasicV.setQ16(dataHarmpowerQ.getQ16()); + influxDBDataHarmPhasicV.setQ17(dataHarmpowerQ.getQ17()); + influxDBDataHarmPhasicV.setQ18(dataHarmpowerQ.getQ18()); + influxDBDataHarmPhasicV.setQ19(dataHarmpowerQ.getQ19()); + influxDBDataHarmPhasicV.setQ20(dataHarmpowerQ.getQ20()); + influxDBDataHarmPhasicV.setQ21(dataHarmpowerQ.getQ21()); + influxDBDataHarmPhasicV.setQ22(dataHarmpowerQ.getQ22()); + influxDBDataHarmPhasicV.setQ23(dataHarmpowerQ.getQ23()); + influxDBDataHarmPhasicV.setQ24(dataHarmpowerQ.getQ24()); + influxDBDataHarmPhasicV.setQ25(dataHarmpowerQ.getQ25()); + influxDBDataHarmPhasicV.setQ26(dataHarmpowerQ.getQ26()); + influxDBDataHarmPhasicV.setQ27(dataHarmpowerQ.getQ27()); + influxDBDataHarmPhasicV.setQ28(dataHarmpowerQ.getQ28()); + influxDBDataHarmPhasicV.setQ29(dataHarmpowerQ.getQ29()); + influxDBDataHarmPhasicV.setQ30(dataHarmpowerQ.getQ30()); + influxDBDataHarmPhasicV.setQ31(dataHarmpowerQ.getQ31()); + influxDBDataHarmPhasicV.setQ32(dataHarmpowerQ.getQ32()); + influxDBDataHarmPhasicV.setQ33(dataHarmpowerQ.getQ33()); + influxDBDataHarmPhasicV.setQ34(dataHarmpowerQ.getQ34()); + influxDBDataHarmPhasicV.setQ35(dataHarmpowerQ.getQ35()); + influxDBDataHarmPhasicV.setQ36(dataHarmpowerQ.getQ36()); + influxDBDataHarmPhasicV.setQ37(dataHarmpowerQ.getQ37()); + influxDBDataHarmPhasicV.setQ38(dataHarmpowerQ.getQ38()); + influxDBDataHarmPhasicV.setQ39(dataHarmpowerQ.getQ39()); + influxDBDataHarmPhasicV.setQ40(dataHarmpowerQ.getQ40()); + influxDBDataHarmPhasicV.setQ41(dataHarmpowerQ.getQ41()); + influxDBDataHarmPhasicV.setQ42(dataHarmpowerQ.getQ42()); + influxDBDataHarmPhasicV.setQ43(dataHarmpowerQ.getQ43()); + influxDBDataHarmPhasicV.setQ44(dataHarmpowerQ.getQ44()); + influxDBDataHarmPhasicV.setQ45(dataHarmpowerQ.getQ45()); + influxDBDataHarmPhasicV.setQ46(dataHarmpowerQ.getQ46()); + influxDBDataHarmPhasicV.setQ47(dataHarmpowerQ.getQ47()); + influxDBDataHarmPhasicV.setQ48(dataHarmpowerQ.getQ48()); + influxDBDataHarmPhasicV.setQ49(dataHarmpowerQ.getQ49()); + influxDBDataHarmPhasicV.setQ50(dataHarmpowerQ.getQ50()); + } + else if (valueType.equals("MAX")){ + influxDBDataHarmPhasicV.setQ1(dataHarmpowerQ.getQ1Max()); + influxDBDataHarmPhasicV.setQ2(dataHarmpowerQ.getQ2Max()); + influxDBDataHarmPhasicV.setQ3(dataHarmpowerQ.getQ3Max()); + influxDBDataHarmPhasicV.setQ4(dataHarmpowerQ.getQ4Max()); + influxDBDataHarmPhasicV.setQ5(dataHarmpowerQ.getQ5Max()); + influxDBDataHarmPhasicV.setQ6(dataHarmpowerQ.getQ6Max()); + influxDBDataHarmPhasicV.setQ7(dataHarmpowerQ.getQ7Max()); + influxDBDataHarmPhasicV.setQ8(dataHarmpowerQ.getQ8Max()); + influxDBDataHarmPhasicV.setQ9(dataHarmpowerQ.getQ9Max()); + influxDBDataHarmPhasicV.setQ10(dataHarmpowerQ.getQ10Max()); + influxDBDataHarmPhasicV.setQ11(dataHarmpowerQ.getQ11Max()); + influxDBDataHarmPhasicV.setQ12(dataHarmpowerQ.getQ12Max()); + influxDBDataHarmPhasicV.setQ13(dataHarmpowerQ.getQ13Max()); + influxDBDataHarmPhasicV.setQ14(dataHarmpowerQ.getQ14Max()); + influxDBDataHarmPhasicV.setQ15(dataHarmpowerQ.getQ15Max()); + influxDBDataHarmPhasicV.setQ16(dataHarmpowerQ.getQ16Max()); + influxDBDataHarmPhasicV.setQ17(dataHarmpowerQ.getQ17Max()); + influxDBDataHarmPhasicV.setQ18(dataHarmpowerQ.getQ18Max()); + influxDBDataHarmPhasicV.setQ19(dataHarmpowerQ.getQ19Max()); + influxDBDataHarmPhasicV.setQ20(dataHarmpowerQ.getQ20Max()); + influxDBDataHarmPhasicV.setQ21(dataHarmpowerQ.getQ21Max()); + influxDBDataHarmPhasicV.setQ22(dataHarmpowerQ.getQ22Max()); + influxDBDataHarmPhasicV.setQ23(dataHarmpowerQ.getQ23Max()); + influxDBDataHarmPhasicV.setQ24(dataHarmpowerQ.getQ24Max()); + influxDBDataHarmPhasicV.setQ25(dataHarmpowerQ.getQ25Max()); + influxDBDataHarmPhasicV.setQ26(dataHarmpowerQ.getQ26Max()); + influxDBDataHarmPhasicV.setQ27(dataHarmpowerQ.getQ27Max()); + influxDBDataHarmPhasicV.setQ28(dataHarmpowerQ.getQ28Max()); + influxDBDataHarmPhasicV.setQ29(dataHarmpowerQ.getQ29Max()); + influxDBDataHarmPhasicV.setQ30(dataHarmpowerQ.getQ30Max()); + influxDBDataHarmPhasicV.setQ31(dataHarmpowerQ.getQ31Max()); + influxDBDataHarmPhasicV.setQ32(dataHarmpowerQ.getQ32Max()); + influxDBDataHarmPhasicV.setQ33(dataHarmpowerQ.getQ33Max()); + influxDBDataHarmPhasicV.setQ34(dataHarmpowerQ.getQ34Max()); + influxDBDataHarmPhasicV.setQ35(dataHarmpowerQ.getQ35Max()); + influxDBDataHarmPhasicV.setQ36(dataHarmpowerQ.getQ36Max()); + influxDBDataHarmPhasicV.setQ37(dataHarmpowerQ.getQ37Max()); + influxDBDataHarmPhasicV.setQ38(dataHarmpowerQ.getQ38Max()); + influxDBDataHarmPhasicV.setQ39(dataHarmpowerQ.getQ39Max()); + influxDBDataHarmPhasicV.setQ40(dataHarmpowerQ.getQ40Max()); + influxDBDataHarmPhasicV.setQ41(dataHarmpowerQ.getQ41Max()); + influxDBDataHarmPhasicV.setQ42(dataHarmpowerQ.getQ42Max()); + influxDBDataHarmPhasicV.setQ43(dataHarmpowerQ.getQ43Max()); + influxDBDataHarmPhasicV.setQ44(dataHarmpowerQ.getQ44Max()); + influxDBDataHarmPhasicV.setQ45(dataHarmpowerQ.getQ45Max()); + influxDBDataHarmPhasicV.setQ46(dataHarmpowerQ.getQ46Max()); + influxDBDataHarmPhasicV.setQ47(dataHarmpowerQ.getQ47Max()); + influxDBDataHarmPhasicV.setQ48(dataHarmpowerQ.getQ48Max()); + influxDBDataHarmPhasicV.setQ49(dataHarmpowerQ.getQ49Max()); + influxDBDataHarmPhasicV.setQ50(dataHarmpowerQ.getQ50Max()); + } + else if (valueType.equals("MIN")){ + influxDBDataHarmPhasicV.setQ1(dataHarmpowerQ.getQ1Min()); + influxDBDataHarmPhasicV.setQ2(dataHarmpowerQ.getQ2Min()); + influxDBDataHarmPhasicV.setQ3(dataHarmpowerQ.getQ3Min()); + influxDBDataHarmPhasicV.setQ4(dataHarmpowerQ.getQ4Min()); + influxDBDataHarmPhasicV.setQ5(dataHarmpowerQ.getQ5Min()); + influxDBDataHarmPhasicV.setQ6(dataHarmpowerQ.getQ6Min()); + influxDBDataHarmPhasicV.setQ7(dataHarmpowerQ.getQ7Min()); + influxDBDataHarmPhasicV.setQ8(dataHarmpowerQ.getQ8Min()); + influxDBDataHarmPhasicV.setQ9(dataHarmpowerQ.getQ9Min()); + influxDBDataHarmPhasicV.setQ10(dataHarmpowerQ.getQ10Min()); + influxDBDataHarmPhasicV.setQ11(dataHarmpowerQ.getQ11Min()); + influxDBDataHarmPhasicV.setQ12(dataHarmpowerQ.getQ12Min()); + influxDBDataHarmPhasicV.setQ13(dataHarmpowerQ.getQ13Min()); + influxDBDataHarmPhasicV.setQ14(dataHarmpowerQ.getQ14Min()); + influxDBDataHarmPhasicV.setQ15(dataHarmpowerQ.getQ15Min()); + influxDBDataHarmPhasicV.setQ16(dataHarmpowerQ.getQ16Min()); + influxDBDataHarmPhasicV.setQ17(dataHarmpowerQ.getQ17Min()); + influxDBDataHarmPhasicV.setQ18(dataHarmpowerQ.getQ18Min()); + influxDBDataHarmPhasicV.setQ19(dataHarmpowerQ.getQ19Min()); + influxDBDataHarmPhasicV.setQ20(dataHarmpowerQ.getQ20Min()); + influxDBDataHarmPhasicV.setQ21(dataHarmpowerQ.getQ21Min()); + influxDBDataHarmPhasicV.setQ22(dataHarmpowerQ.getQ22Min()); + influxDBDataHarmPhasicV.setQ23(dataHarmpowerQ.getQ23Min()); + influxDBDataHarmPhasicV.setQ24(dataHarmpowerQ.getQ24Min()); + influxDBDataHarmPhasicV.setQ25(dataHarmpowerQ.getQ25Min()); + influxDBDataHarmPhasicV.setQ26(dataHarmpowerQ.getQ26Min()); + influxDBDataHarmPhasicV.setQ27(dataHarmpowerQ.getQ27Min()); + influxDBDataHarmPhasicV.setQ28(dataHarmpowerQ.getQ28Min()); + influxDBDataHarmPhasicV.setQ29(dataHarmpowerQ.getQ29Min()); + influxDBDataHarmPhasicV.setQ30(dataHarmpowerQ.getQ30Min()); + influxDBDataHarmPhasicV.setQ31(dataHarmpowerQ.getQ31Min()); + influxDBDataHarmPhasicV.setQ32(dataHarmpowerQ.getQ32Min()); + influxDBDataHarmPhasicV.setQ33(dataHarmpowerQ.getQ33Min()); + influxDBDataHarmPhasicV.setQ34(dataHarmpowerQ.getQ34Min()); + influxDBDataHarmPhasicV.setQ35(dataHarmpowerQ.getQ35Min()); + influxDBDataHarmPhasicV.setQ36(dataHarmpowerQ.getQ36Min()); + influxDBDataHarmPhasicV.setQ37(dataHarmpowerQ.getQ37Min()); + influxDBDataHarmPhasicV.setQ38(dataHarmpowerQ.getQ38Min()); + influxDBDataHarmPhasicV.setQ39(dataHarmpowerQ.getQ39Min()); + influxDBDataHarmPhasicV.setQ40(dataHarmpowerQ.getQ40Min()); + influxDBDataHarmPhasicV.setQ41(dataHarmpowerQ.getQ41Min()); + influxDBDataHarmPhasicV.setQ42(dataHarmpowerQ.getQ42Min()); + influxDBDataHarmPhasicV.setQ43(dataHarmpowerQ.getQ43Min()); + influxDBDataHarmPhasicV.setQ44(dataHarmpowerQ.getQ44Min()); + influxDBDataHarmPhasicV.setQ45(dataHarmpowerQ.getQ45Min()); + influxDBDataHarmPhasicV.setQ46(dataHarmpowerQ.getQ46Min()); + influxDBDataHarmPhasicV.setQ47(dataHarmpowerQ.getQ47Min()); + influxDBDataHarmPhasicV.setQ48(dataHarmpowerQ.getQ48Min()); + influxDBDataHarmPhasicV.setQ49(dataHarmpowerQ.getQ49Min()); + influxDBDataHarmPhasicV.setQ50(dataHarmpowerQ.getQ50Min()); + } + else if (valueType.equals("CP95")){ + influxDBDataHarmPhasicV.setQ1(dataHarmpowerQ.getQ1Cp95()); + influxDBDataHarmPhasicV.setQ2(dataHarmpowerQ.getQ2Cp95()); + influxDBDataHarmPhasicV.setQ3(dataHarmpowerQ.getQ3Cp95()); + influxDBDataHarmPhasicV.setQ4(dataHarmpowerQ.getQ4Cp95()); + influxDBDataHarmPhasicV.setQ5(dataHarmpowerQ.getQ5Cp95()); + influxDBDataHarmPhasicV.setQ6(dataHarmpowerQ.getQ6Cp95()); + influxDBDataHarmPhasicV.setQ7(dataHarmpowerQ.getQ7Cp95()); + influxDBDataHarmPhasicV.setQ8(dataHarmpowerQ.getQ8Cp95()); + influxDBDataHarmPhasicV.setQ9(dataHarmpowerQ.getQ9Cp95()); + influxDBDataHarmPhasicV.setQ10(dataHarmpowerQ.getQ10Cp95()); + influxDBDataHarmPhasicV.setQ11(dataHarmpowerQ.getQ11Cp95()); + influxDBDataHarmPhasicV.setQ12(dataHarmpowerQ.getQ12Cp95()); + influxDBDataHarmPhasicV.setQ13(dataHarmpowerQ.getQ13Cp95()); + influxDBDataHarmPhasicV.setQ14(dataHarmpowerQ.getQ14Cp95()); + influxDBDataHarmPhasicV.setQ15(dataHarmpowerQ.getQ15Cp95()); + influxDBDataHarmPhasicV.setQ16(dataHarmpowerQ.getQ16Cp95()); + influxDBDataHarmPhasicV.setQ17(dataHarmpowerQ.getQ17Cp95()); + influxDBDataHarmPhasicV.setQ18(dataHarmpowerQ.getQ18Cp95()); + influxDBDataHarmPhasicV.setQ19(dataHarmpowerQ.getQ19Cp95()); + influxDBDataHarmPhasicV.setQ20(dataHarmpowerQ.getQ20Cp95()); + influxDBDataHarmPhasicV.setQ21(dataHarmpowerQ.getQ21Cp95()); + influxDBDataHarmPhasicV.setQ22(dataHarmpowerQ.getQ22Cp95()); + influxDBDataHarmPhasicV.setQ23(dataHarmpowerQ.getQ23Cp95()); + influxDBDataHarmPhasicV.setQ24(dataHarmpowerQ.getQ24Cp95()); + influxDBDataHarmPhasicV.setQ25(dataHarmpowerQ.getQ25Cp95()); + influxDBDataHarmPhasicV.setQ26(dataHarmpowerQ.getQ26Cp95()); + influxDBDataHarmPhasicV.setQ27(dataHarmpowerQ.getQ27Cp95()); + influxDBDataHarmPhasicV.setQ28(dataHarmpowerQ.getQ28Cp95()); + influxDBDataHarmPhasicV.setQ29(dataHarmpowerQ.getQ29Cp95()); + influxDBDataHarmPhasicV.setQ30(dataHarmpowerQ.getQ30Cp95()); + influxDBDataHarmPhasicV.setQ31(dataHarmpowerQ.getQ31Cp95()); + influxDBDataHarmPhasicV.setQ32(dataHarmpowerQ.getQ32Cp95()); + influxDBDataHarmPhasicV.setQ33(dataHarmpowerQ.getQ33Cp95()); + influxDBDataHarmPhasicV.setQ34(dataHarmpowerQ.getQ34Cp95()); + influxDBDataHarmPhasicV.setQ35(dataHarmpowerQ.getQ35Cp95()); + influxDBDataHarmPhasicV.setQ36(dataHarmpowerQ.getQ36Cp95()); + influxDBDataHarmPhasicV.setQ37(dataHarmpowerQ.getQ37Cp95()); + influxDBDataHarmPhasicV.setQ38(dataHarmpowerQ.getQ38Cp95()); + influxDBDataHarmPhasicV.setQ39(dataHarmpowerQ.getQ39Cp95()); + influxDBDataHarmPhasicV.setQ40(dataHarmpowerQ.getQ40Cp95()); + influxDBDataHarmPhasicV.setQ41(dataHarmpowerQ.getQ41Cp95()); + influxDBDataHarmPhasicV.setQ42(dataHarmpowerQ.getQ42Cp95()); + influxDBDataHarmPhasicV.setQ43(dataHarmpowerQ.getQ43Cp95()); + influxDBDataHarmPhasicV.setQ44(dataHarmpowerQ.getQ44Cp95()); + influxDBDataHarmPhasicV.setQ45(dataHarmpowerQ.getQ45Cp95()); + influxDBDataHarmPhasicV.setQ46(dataHarmpowerQ.getQ46Cp95()); + influxDBDataHarmPhasicV.setQ47(dataHarmpowerQ.getQ47Cp95()); + influxDBDataHarmPhasicV.setQ48(dataHarmpowerQ.getQ48Cp95()); + influxDBDataHarmPhasicV.setQ49(dataHarmpowerQ.getQ49Cp95()); + influxDBDataHarmPhasicV.setQ50(dataHarmpowerQ.getQ50Cp95()); + } + + influxDBDataHarmPhasicVList.add(influxDBDataHarmPhasicV); + + } + + + + return influxDBDataHarmPhasicVList; + } + + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPowerS.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPowerS.java new file mode 100644 index 0000000..8c1d3b2 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmPowerS.java @@ -0,0 +1,432 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataHarmpowerS; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 9:13 + */ +@Data +@Measurement(name = "data_harmpower_s") +public class InfluxDBDataHarmPowerS { + + @TimeColumn + @Column(name = "time",tag = true) + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag") + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "s") + private Float s; + + @Column(name = "s_1") + private Float s1; + + @Column(name = "s_2") + private Float s2; + + @Column(name = "s_3") + private Float s3; + + @Column(name = "s_4") + private Float s4; + + @Column(name = "s_5") + private Float s5; + + @Column(name = "s_6") + private Float s6; + + @Column(name = "s_7") + private Float s7; + + @Column(name = "s_8") + private Float s8; + + @Column(name = "s_9") + private Float s9; + + @Column(name = "s_10") + private Float s10; + + @Column(name = "s_11") + private Float s11; + + @Column(name = "s_12") + private Float s12; + + @Column(name = "s_13") + private Float s13; + + @Column(name = "s_14") + private Float s14; + + @Column(name = "s_15") + private Float s15; + + @Column(name = "s_16") + private Float s16; + + @Column(name = "s_17") + private Float s17; + + @Column(name = "s_18") + private Float s18; + + @Column(name = "s_19") + private Float s19; + + @Column(name = "s_20") + private Float s20; + + @Column(name = "s_21") + private Float s21; + + @Column(name = "s_22") + private Float s22; + + @Column(name = "s_23") + private Float s23; + + @Column(name = "s_24") + private Float s24; + + @Column(name = "s_25") + private Float s25; + + @Column(name = "s_26") + private Float s26; + + @Column(name = "s_27") + private Float s27; + + @Column(name = "s_28") + private Float s28; + + @Column(name = "s_29") + private Float s29; + + @Column(name = "s_30") + private Float s30; + + @Column(name = "s_31") + private Float s31; + + @Column(name = "s_32") + private Float s32; + + @Column(name = "s_33") + private Float s33; + + @Column(name = "s_34") + private Float s34; + + @Column(name = "s_35") + private Float s35; + + @Column(name = "s_36") + private Float s36; + + @Column(name = "s_37") + private Float s37; + + @Column(name = "s_38") + private Float s38; + + @Column(name = "s_39") + private Float s39; + + @Column(name = "s_40") + private Float s40; + + @Column(name = "s_41") + private Float s41; + + @Column(name = "s_42") + private Float s42; + + @Column(name = "s_43") + private Float s43; + + @Column(name = "s_44") + private Float s44; + + @Column(name = "s_45") + private Float s45; + + @Column(name = "s_46") + private Float s46; + + @Column(name = "s_47") + private Float s47; + + @Column(name = "s_48") + private Float s48; + + @Column(name = "s_49") + private Float s49; + + @Column(name = "s_50") + private Float s50; + + public static List oralceToInfluxDB(DataHarmpowerS dataHarmpowerS) { + if (dataHarmpowerS == null) { + return null; + } + List influxDBDataHarmPhasicVList = new ArrayList<>(); + List valueTypeList = Stream.of("AVG", "MAX", "MIN", "CP95").collect(Collectors.toList()); + for (String valueType : valueTypeList) { + InfluxDBDataHarmPowerS influxDBDataHarmPhasicV = new InfluxDBDataHarmPowerS(); + Instant instant = dataHarmpowerS.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataHarmPhasicV.setTime(instant); + influxDBDataHarmPhasicV.setLineId(dataHarmpowerS.getLineid()+""); + influxDBDataHarmPhasicV.setPhaseType(dataHarmpowerS.getPhasicType()); + influxDBDataHarmPhasicV.setQualityFlag(dataHarmpowerS.getQualityflag()+""); + influxDBDataHarmPhasicV.setValueType(valueType); + if (valueType.equals("AVG")) { + influxDBDataHarmPhasicV.setS1(dataHarmpowerS.getS1()); + influxDBDataHarmPhasicV.setS2(dataHarmpowerS.getS2()); + influxDBDataHarmPhasicV.setS3(dataHarmpowerS.getS3()); + influxDBDataHarmPhasicV.setS4(dataHarmpowerS.getS4()); + influxDBDataHarmPhasicV.setS5(dataHarmpowerS.getS5()); + influxDBDataHarmPhasicV.setS6(dataHarmpowerS.getS6()); + influxDBDataHarmPhasicV.setS7(dataHarmpowerS.getS7()); + influxDBDataHarmPhasicV.setS8(dataHarmpowerS.getS8()); + influxDBDataHarmPhasicV.setS9(dataHarmpowerS.getS9()); + influxDBDataHarmPhasicV.setS10(dataHarmpowerS.getS10()); + influxDBDataHarmPhasicV.setS11(dataHarmpowerS.getS11()); + influxDBDataHarmPhasicV.setS12(dataHarmpowerS.getS12()); + influxDBDataHarmPhasicV.setS13(dataHarmpowerS.getS13()); + influxDBDataHarmPhasicV.setS14(dataHarmpowerS.getS14()); + influxDBDataHarmPhasicV.setS15(dataHarmpowerS.getS15()); + influxDBDataHarmPhasicV.setS16(dataHarmpowerS.getS16()); + influxDBDataHarmPhasicV.setS17(dataHarmpowerS.getS17()); + influxDBDataHarmPhasicV.setS18(dataHarmpowerS.getS18()); + influxDBDataHarmPhasicV.setS19(dataHarmpowerS.getS19()); + influxDBDataHarmPhasicV.setS20(dataHarmpowerS.getS20()); + influxDBDataHarmPhasicV.setS21(dataHarmpowerS.getS21()); + influxDBDataHarmPhasicV.setS22(dataHarmpowerS.getS22()); + influxDBDataHarmPhasicV.setS23(dataHarmpowerS.getS23()); + influxDBDataHarmPhasicV.setS24(dataHarmpowerS.getS24()); + influxDBDataHarmPhasicV.setS25(dataHarmpowerS.getS25()); + influxDBDataHarmPhasicV.setS26(dataHarmpowerS.getS26()); + influxDBDataHarmPhasicV.setS27(dataHarmpowerS.getS27()); + influxDBDataHarmPhasicV.setS28(dataHarmpowerS.getS28()); + influxDBDataHarmPhasicV.setS29(dataHarmpowerS.getS29()); + influxDBDataHarmPhasicV.setS30(dataHarmpowerS.getS30()); + influxDBDataHarmPhasicV.setS31(dataHarmpowerS.getS31()); + influxDBDataHarmPhasicV.setS32(dataHarmpowerS.getS32()); + influxDBDataHarmPhasicV.setS33(dataHarmpowerS.getS33()); + influxDBDataHarmPhasicV.setS34(dataHarmpowerS.getS34()); + influxDBDataHarmPhasicV.setS35(dataHarmpowerS.getS35()); + influxDBDataHarmPhasicV.setS36(dataHarmpowerS.getS36()); + influxDBDataHarmPhasicV.setS37(dataHarmpowerS.getS37()); + influxDBDataHarmPhasicV.setS38(dataHarmpowerS.getS38()); + influxDBDataHarmPhasicV.setS39(dataHarmpowerS.getS39()); + influxDBDataHarmPhasicV.setS40(dataHarmpowerS.getS40()); + influxDBDataHarmPhasicV.setS41(dataHarmpowerS.getS41()); + influxDBDataHarmPhasicV.setS42(dataHarmpowerS.getS42()); + influxDBDataHarmPhasicV.setS43(dataHarmpowerS.getS43()); + influxDBDataHarmPhasicV.setS44(dataHarmpowerS.getS44()); + influxDBDataHarmPhasicV.setS45(dataHarmpowerS.getS45()); + influxDBDataHarmPhasicV.setS46(dataHarmpowerS.getS46()); + influxDBDataHarmPhasicV.setS47(dataHarmpowerS.getS47()); + influxDBDataHarmPhasicV.setS48(dataHarmpowerS.getS48()); + influxDBDataHarmPhasicV.setS49(dataHarmpowerS.getS49()); + influxDBDataHarmPhasicV.setS50(dataHarmpowerS.getS50()); + } + else if (valueType.equals("MAX")){ + influxDBDataHarmPhasicV.setS1(dataHarmpowerS.getS1Max()); + influxDBDataHarmPhasicV.setS2(dataHarmpowerS.getS2Max()); + influxDBDataHarmPhasicV.setS3(dataHarmpowerS.getS3Max()); + influxDBDataHarmPhasicV.setS4(dataHarmpowerS.getS4Max()); + influxDBDataHarmPhasicV.setS5(dataHarmpowerS.getS5Max()); + influxDBDataHarmPhasicV.setS6(dataHarmpowerS.getS6Max()); + influxDBDataHarmPhasicV.setS7(dataHarmpowerS.getS7Max()); + influxDBDataHarmPhasicV.setS8(dataHarmpowerS.getS8Max()); + influxDBDataHarmPhasicV.setS9(dataHarmpowerS.getS9Max()); + influxDBDataHarmPhasicV.setS10(dataHarmpowerS.getS10Max()); + influxDBDataHarmPhasicV.setS11(dataHarmpowerS.getS11Max()); + influxDBDataHarmPhasicV.setS12(dataHarmpowerS.getS12Max()); + influxDBDataHarmPhasicV.setS13(dataHarmpowerS.getS13Max()); + influxDBDataHarmPhasicV.setS14(dataHarmpowerS.getS14Max()); + influxDBDataHarmPhasicV.setS15(dataHarmpowerS.getS15Max()); + influxDBDataHarmPhasicV.setS16(dataHarmpowerS.getS16Max()); + influxDBDataHarmPhasicV.setS17(dataHarmpowerS.getS17Max()); + influxDBDataHarmPhasicV.setS18(dataHarmpowerS.getS18Max()); + influxDBDataHarmPhasicV.setS19(dataHarmpowerS.getS19Max()); + influxDBDataHarmPhasicV.setS20(dataHarmpowerS.getS20Max()); + influxDBDataHarmPhasicV.setS21(dataHarmpowerS.getS21Max()); + influxDBDataHarmPhasicV.setS22(dataHarmpowerS.getS22Max()); + influxDBDataHarmPhasicV.setS23(dataHarmpowerS.getS23Max()); + influxDBDataHarmPhasicV.setS24(dataHarmpowerS.getS24Max()); + influxDBDataHarmPhasicV.setS25(dataHarmpowerS.getS25Max()); + influxDBDataHarmPhasicV.setS26(dataHarmpowerS.getS26Max()); + influxDBDataHarmPhasicV.setS27(dataHarmpowerS.getS27Max()); + influxDBDataHarmPhasicV.setS28(dataHarmpowerS.getS28Max()); + influxDBDataHarmPhasicV.setS29(dataHarmpowerS.getS29Max()); + influxDBDataHarmPhasicV.setS30(dataHarmpowerS.getS30Max()); + influxDBDataHarmPhasicV.setS31(dataHarmpowerS.getS31Max()); + influxDBDataHarmPhasicV.setS32(dataHarmpowerS.getS32Max()); + influxDBDataHarmPhasicV.setS33(dataHarmpowerS.getS33Max()); + influxDBDataHarmPhasicV.setS34(dataHarmpowerS.getS34Max()); + influxDBDataHarmPhasicV.setS35(dataHarmpowerS.getS35Max()); + influxDBDataHarmPhasicV.setS36(dataHarmpowerS.getS36Max()); + influxDBDataHarmPhasicV.setS37(dataHarmpowerS.getS37Max()); + influxDBDataHarmPhasicV.setS38(dataHarmpowerS.getS38Max()); + influxDBDataHarmPhasicV.setS39(dataHarmpowerS.getS39Max()); + influxDBDataHarmPhasicV.setS40(dataHarmpowerS.getS40Max()); + influxDBDataHarmPhasicV.setS41(dataHarmpowerS.getS41Max()); + influxDBDataHarmPhasicV.setS42(dataHarmpowerS.getS42Max()); + influxDBDataHarmPhasicV.setS43(dataHarmpowerS.getS43Max()); + influxDBDataHarmPhasicV.setS44(dataHarmpowerS.getS44Max()); + influxDBDataHarmPhasicV.setS45(dataHarmpowerS.getS45Max()); + influxDBDataHarmPhasicV.setS46(dataHarmpowerS.getS46Max()); + influxDBDataHarmPhasicV.setS47(dataHarmpowerS.getS47Max()); + influxDBDataHarmPhasicV.setS48(dataHarmpowerS.getS48Max()); + influxDBDataHarmPhasicV.setS49(dataHarmpowerS.getS49Max()); + influxDBDataHarmPhasicV.setS50(dataHarmpowerS.getS50Max()); + } + else if (valueType.equals("MIN")){ + influxDBDataHarmPhasicV.setS1(dataHarmpowerS.getS1Min()); + influxDBDataHarmPhasicV.setS2(dataHarmpowerS.getS2Min()); + influxDBDataHarmPhasicV.setS3(dataHarmpowerS.getS3Min()); + influxDBDataHarmPhasicV.setS4(dataHarmpowerS.getS4Min()); + influxDBDataHarmPhasicV.setS5(dataHarmpowerS.getS5Min()); + influxDBDataHarmPhasicV.setS6(dataHarmpowerS.getS6Min()); + influxDBDataHarmPhasicV.setS7(dataHarmpowerS.getS7Min()); + influxDBDataHarmPhasicV.setS8(dataHarmpowerS.getS8Min()); + influxDBDataHarmPhasicV.setS9(dataHarmpowerS.getS9Min()); + influxDBDataHarmPhasicV.setS10(dataHarmpowerS.getS10Min()); + influxDBDataHarmPhasicV.setS11(dataHarmpowerS.getS11Min()); + influxDBDataHarmPhasicV.setS12(dataHarmpowerS.getS12Min()); + influxDBDataHarmPhasicV.setS13(dataHarmpowerS.getS13Min()); + influxDBDataHarmPhasicV.setS14(dataHarmpowerS.getS14Min()); + influxDBDataHarmPhasicV.setS15(dataHarmpowerS.getS15Min()); + influxDBDataHarmPhasicV.setS16(dataHarmpowerS.getS16Min()); + influxDBDataHarmPhasicV.setS17(dataHarmpowerS.getS17Min()); + influxDBDataHarmPhasicV.setS18(dataHarmpowerS.getS18Min()); + influxDBDataHarmPhasicV.setS19(dataHarmpowerS.getS19Min()); + influxDBDataHarmPhasicV.setS20(dataHarmpowerS.getS20Min()); + influxDBDataHarmPhasicV.setS21(dataHarmpowerS.getS21Min()); + influxDBDataHarmPhasicV.setS22(dataHarmpowerS.getS22Min()); + influxDBDataHarmPhasicV.setS23(dataHarmpowerS.getS23Min()); + influxDBDataHarmPhasicV.setS24(dataHarmpowerS.getS24Min()); + influxDBDataHarmPhasicV.setS25(dataHarmpowerS.getS25Min()); + influxDBDataHarmPhasicV.setS26(dataHarmpowerS.getS26Min()); + influxDBDataHarmPhasicV.setS27(dataHarmpowerS.getS27Min()); + influxDBDataHarmPhasicV.setS28(dataHarmpowerS.getS28Min()); + influxDBDataHarmPhasicV.setS29(dataHarmpowerS.getS29Min()); + influxDBDataHarmPhasicV.setS30(dataHarmpowerS.getS30Min()); + influxDBDataHarmPhasicV.setS31(dataHarmpowerS.getS31Min()); + influxDBDataHarmPhasicV.setS32(dataHarmpowerS.getS32Min()); + influxDBDataHarmPhasicV.setS33(dataHarmpowerS.getS33Min()); + influxDBDataHarmPhasicV.setS34(dataHarmpowerS.getS34Min()); + influxDBDataHarmPhasicV.setS35(dataHarmpowerS.getS35Min()); + influxDBDataHarmPhasicV.setS36(dataHarmpowerS.getS36Min()); + influxDBDataHarmPhasicV.setS37(dataHarmpowerS.getS37Min()); + influxDBDataHarmPhasicV.setS38(dataHarmpowerS.getS38Min()); + influxDBDataHarmPhasicV.setS39(dataHarmpowerS.getS39Min()); + influxDBDataHarmPhasicV.setS40(dataHarmpowerS.getS40Min()); + influxDBDataHarmPhasicV.setS41(dataHarmpowerS.getS41Min()); + influxDBDataHarmPhasicV.setS42(dataHarmpowerS.getS42Min()); + influxDBDataHarmPhasicV.setS43(dataHarmpowerS.getS43Min()); + influxDBDataHarmPhasicV.setS44(dataHarmpowerS.getS44Min()); + influxDBDataHarmPhasicV.setS45(dataHarmpowerS.getS45Min()); + influxDBDataHarmPhasicV.setS46(dataHarmpowerS.getS46Min()); + influxDBDataHarmPhasicV.setS47(dataHarmpowerS.getS47Min()); + influxDBDataHarmPhasicV.setS48(dataHarmpowerS.getS48Min()); + influxDBDataHarmPhasicV.setS49(dataHarmpowerS.getS49Min()); + influxDBDataHarmPhasicV.setS50(dataHarmpowerS.getS50Min()); + } + else if (valueType.equals("CP95")){ + influxDBDataHarmPhasicV.setS1(dataHarmpowerS.getS1Cp95()); + influxDBDataHarmPhasicV.setS2(dataHarmpowerS.getS2Cp95()); + influxDBDataHarmPhasicV.setS3(dataHarmpowerS.getS3Cp95()); + influxDBDataHarmPhasicV.setS4(dataHarmpowerS.getS4Cp95()); + influxDBDataHarmPhasicV.setS5(dataHarmpowerS.getS5Cp95()); + influxDBDataHarmPhasicV.setS6(dataHarmpowerS.getS6Cp95()); + influxDBDataHarmPhasicV.setS7(dataHarmpowerS.getS7Cp95()); + influxDBDataHarmPhasicV.setS8(dataHarmpowerS.getS8Cp95()); + influxDBDataHarmPhasicV.setS9(dataHarmpowerS.getS9Cp95()); + influxDBDataHarmPhasicV.setS10(dataHarmpowerS.getS10Cp95()); + influxDBDataHarmPhasicV.setS11(dataHarmpowerS.getS11Cp95()); + influxDBDataHarmPhasicV.setS12(dataHarmpowerS.getS12Cp95()); + influxDBDataHarmPhasicV.setS13(dataHarmpowerS.getS13Cp95()); + influxDBDataHarmPhasicV.setS14(dataHarmpowerS.getS14Cp95()); + influxDBDataHarmPhasicV.setS15(dataHarmpowerS.getS15Cp95()); + influxDBDataHarmPhasicV.setS16(dataHarmpowerS.getS16Cp95()); + influxDBDataHarmPhasicV.setS17(dataHarmpowerS.getS17Cp95()); + influxDBDataHarmPhasicV.setS18(dataHarmpowerS.getS18Cp95()); + influxDBDataHarmPhasicV.setS19(dataHarmpowerS.getS19Cp95()); + influxDBDataHarmPhasicV.setS20(dataHarmpowerS.getS20Cp95()); + influxDBDataHarmPhasicV.setS21(dataHarmpowerS.getS21Cp95()); + influxDBDataHarmPhasicV.setS22(dataHarmpowerS.getS22Cp95()); + influxDBDataHarmPhasicV.setS23(dataHarmpowerS.getS23Cp95()); + influxDBDataHarmPhasicV.setS24(dataHarmpowerS.getS24Cp95()); + influxDBDataHarmPhasicV.setS25(dataHarmpowerS.getS25Cp95()); + influxDBDataHarmPhasicV.setS26(dataHarmpowerS.getS26Cp95()); + influxDBDataHarmPhasicV.setS27(dataHarmpowerS.getS27Cp95()); + influxDBDataHarmPhasicV.setS28(dataHarmpowerS.getS28Cp95()); + influxDBDataHarmPhasicV.setS29(dataHarmpowerS.getS29Cp95()); + influxDBDataHarmPhasicV.setS30(dataHarmpowerS.getS30Cp95()); + influxDBDataHarmPhasicV.setS31(dataHarmpowerS.getS31Cp95()); + influxDBDataHarmPhasicV.setS32(dataHarmpowerS.getS32Cp95()); + influxDBDataHarmPhasicV.setS33(dataHarmpowerS.getS33Cp95()); + influxDBDataHarmPhasicV.setS34(dataHarmpowerS.getS34Cp95()); + influxDBDataHarmPhasicV.setS35(dataHarmpowerS.getS35Cp95()); + influxDBDataHarmPhasicV.setS36(dataHarmpowerS.getS36Cp95()); + influxDBDataHarmPhasicV.setS37(dataHarmpowerS.getS37Cp95()); + influxDBDataHarmPhasicV.setS38(dataHarmpowerS.getS38Cp95()); + influxDBDataHarmPhasicV.setS39(dataHarmpowerS.getS39Cp95()); + influxDBDataHarmPhasicV.setS40(dataHarmpowerS.getS40Cp95()); + influxDBDataHarmPhasicV.setS41(dataHarmpowerS.getS41Cp95()); + influxDBDataHarmPhasicV.setS42(dataHarmpowerS.getS42Cp95()); + influxDBDataHarmPhasicV.setS43(dataHarmpowerS.getS43Cp95()); + influxDBDataHarmPhasicV.setS44(dataHarmpowerS.getS44Cp95()); + influxDBDataHarmPhasicV.setS45(dataHarmpowerS.getS45Cp95()); + influxDBDataHarmPhasicV.setS46(dataHarmpowerS.getS46Cp95()); + influxDBDataHarmPhasicV.setS47(dataHarmpowerS.getS47Cp95()); + influxDBDataHarmPhasicV.setS48(dataHarmpowerS.getS48Cp95()); + influxDBDataHarmPhasicV.setS49(dataHarmpowerS.getS49Cp95()); + influxDBDataHarmPhasicV.setS50(dataHarmpowerS.getS50Cp95()); + } + + influxDBDataHarmPhasicVList.add(influxDBDataHarmPhasicV); + + } + + + + return influxDBDataHarmPhasicVList; + } + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmRateI.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmRateI.java new file mode 100644 index 0000000..e02ebde --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmRateI.java @@ -0,0 +1,429 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataHarmrateI; +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 11:27 + */ +@Data +@Measurement(name = "data_harmrate_i") +public class InfluxDBDataHarmRateI { + @TimeColumn + @Column(name = "time",tag = true) + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag") + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "i_1") + private Float i1; + + @Column(name = "i_2") + private Float i2; + + @Column(name = "i_3") + private Float i3; + + @Column(name = "i_4") + private Float i4; + + @Column(name = "i_5") + private Float i5; + + @Column(name = "i_6") + private Float i6; + + @Column(name = "i_7") + private Float i7; + + @Column(name = "i_8") + private Float i8; + + @Column(name = "i_9") + private Float i9; + + @Column(name = "i_10") + private Float i10; + + @Column(name = "i_11") + private Float i11; + + @Column(name = "i_12") + private Float i12; + + @Column(name = "i_13") + private Float i13; + + @Column(name = "i_14") + private Float i14; + + @Column(name = "i_15") + private Float i15; + + @Column(name = "i_16") + private Float i16; + + @Column(name = "i_17") + private Float i17; + + @Column(name = "i_18") + private Float i18; + + @Column(name = "i_19") + private Float i19; + + @Column(name = "i_20") + private Float i20; + + @Column(name = "i_21") + private Float i21; + + @Column(name = "i_22") + private Float i22; + + @Column(name = "i_23") + private Float i23; + + @Column(name = "i_24") + private Float i24; + + @Column(name = "i_25") + private Float i25; + + @Column(name = "i_26") + private Float i26; + + @Column(name = "i_27") + private Float i27; + + @Column(name = "i_28") + private Float i28; + + @Column(name = "i_29") + private Float i29; + + @Column(name = "i_30") + private Float i30; + + @Column(name = "i_31") + private Float i31; + + @Column(name = "i_32") + private Float i32; + + @Column(name = "i_33") + private Float i33; + + @Column(name = "i_34") + private Float i34; + + @Column(name = "i_35") + private Float i35; + + @Column(name = "i_36") + private Float i36; + + @Column(name = "i_37") + private Float i37; + + @Column(name = "i_38") + private Float i38; + + @Column(name = "i_39") + private Float i39; + + @Column(name = "i_40") + private Float i40; + + @Column(name = "i_41") + private Float i41; + + @Column(name = "i_42") + private Float i42; + + @Column(name = "i_43") + private Float i43; + + @Column(name = "i_44") + private Float i44; + + @Column(name = "i_45") + private Float i45; + + @Column(name = "i_46") + private Float i46; + + @Column(name = "i_47") + private Float i47; + + @Column(name = "i_48") + private Float i48; + + @Column(name = "i_49") + private Float i49; + + @Column(name = "i_50") + private Float i50; + + public static List oralceToInfluxDB(DataHarmrateI dataHarmrateI) { + if (dataHarmrateI == null) { + return null; + } + List influxDBDataHarmRateIList = new ArrayList<>(); + List valueTypeList = Stream.of("AVG", "MAX", "MIN", "CP95").collect(Collectors.toList()); + for (String valueType : valueTypeList) { + InfluxDBDataHarmRateI influxDBDataHarmRateI = new InfluxDBDataHarmRateI(); + Instant instant = dataHarmrateI.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataHarmRateI.setTime(instant); + influxDBDataHarmRateI.setLineId(dataHarmrateI.getLineid()+""); + influxDBDataHarmRateI.setPhaseType(dataHarmrateI.getPhasicType()); + influxDBDataHarmRateI.setQualityFlag(dataHarmrateI.getQualityflag()+""); + influxDBDataHarmRateI.setValueType(valueType); + if (valueType.equals("AVG")) { + influxDBDataHarmRateI.setI1(dataHarmrateI.getI1()); + influxDBDataHarmRateI.setI2(dataHarmrateI.getI2()); + influxDBDataHarmRateI.setI3(dataHarmrateI.getI3()); + influxDBDataHarmRateI.setI4(dataHarmrateI.getI4()); + influxDBDataHarmRateI.setI5(dataHarmrateI.getI5()); + influxDBDataHarmRateI.setI6(dataHarmrateI.getI6()); + influxDBDataHarmRateI.setI7(dataHarmrateI.getI7()); + influxDBDataHarmRateI.setI8(dataHarmrateI.getI8()); + influxDBDataHarmRateI.setI9(dataHarmrateI.getI9()); + influxDBDataHarmRateI.setI10(dataHarmrateI.getI10()); + influxDBDataHarmRateI.setI11(dataHarmrateI.getI11()); + influxDBDataHarmRateI.setI12(dataHarmrateI.getI12()); + influxDBDataHarmRateI.setI13(dataHarmrateI.getI13()); + influxDBDataHarmRateI.setI14(dataHarmrateI.getI14()); + influxDBDataHarmRateI.setI15(dataHarmrateI.getI15()); + influxDBDataHarmRateI.setI16(dataHarmrateI.getI16()); + influxDBDataHarmRateI.setI17(dataHarmrateI.getI17()); + influxDBDataHarmRateI.setI18(dataHarmrateI.getI18()); + influxDBDataHarmRateI.setI19(dataHarmrateI.getI19()); + influxDBDataHarmRateI.setI20(dataHarmrateI.getI20()); + influxDBDataHarmRateI.setI21(dataHarmrateI.getI21()); + influxDBDataHarmRateI.setI22(dataHarmrateI.getI22()); + influxDBDataHarmRateI.setI23(dataHarmrateI.getI23()); + influxDBDataHarmRateI.setI24(dataHarmrateI.getI24()); + influxDBDataHarmRateI.setI25(dataHarmrateI.getI25()); + influxDBDataHarmRateI.setI26(dataHarmrateI.getI26()); + influxDBDataHarmRateI.setI27(dataHarmrateI.getI27()); + influxDBDataHarmRateI.setI28(dataHarmrateI.getI28()); + influxDBDataHarmRateI.setI29(dataHarmrateI.getI29()); + influxDBDataHarmRateI.setI30(dataHarmrateI.getI30()); + influxDBDataHarmRateI.setI31(dataHarmrateI.getI31()); + influxDBDataHarmRateI.setI32(dataHarmrateI.getI32()); + influxDBDataHarmRateI.setI33(dataHarmrateI.getI33()); + influxDBDataHarmRateI.setI34(dataHarmrateI.getI34()); + influxDBDataHarmRateI.setI35(dataHarmrateI.getI35()); + influxDBDataHarmRateI.setI36(dataHarmrateI.getI36()); + influxDBDataHarmRateI.setI37(dataHarmrateI.getI37()); + influxDBDataHarmRateI.setI38(dataHarmrateI.getI38()); + influxDBDataHarmRateI.setI39(dataHarmrateI.getI39()); + influxDBDataHarmRateI.setI40(dataHarmrateI.getI40()); + influxDBDataHarmRateI.setI41(dataHarmrateI.getI41()); + influxDBDataHarmRateI.setI42(dataHarmrateI.getI42()); + influxDBDataHarmRateI.setI43(dataHarmrateI.getI43()); + influxDBDataHarmRateI.setI44(dataHarmrateI.getI44()); + influxDBDataHarmRateI.setI45(dataHarmrateI.getI45()); + influxDBDataHarmRateI.setI46(dataHarmrateI.getI46()); + influxDBDataHarmRateI.setI47(dataHarmrateI.getI47()); + influxDBDataHarmRateI.setI48(dataHarmrateI.getI48()); + influxDBDataHarmRateI.setI49(dataHarmrateI.getI49()); + influxDBDataHarmRateI.setI50(dataHarmrateI.getI50()); + } + else if (valueType.equals("MAX")){ + influxDBDataHarmRateI.setI1(dataHarmrateI.getI1Max()); + influxDBDataHarmRateI.setI2(dataHarmrateI.getI2Max()); + influxDBDataHarmRateI.setI3(dataHarmrateI.getI3Max()); + influxDBDataHarmRateI.setI4(dataHarmrateI.getI4Max()); + influxDBDataHarmRateI.setI5(dataHarmrateI.getI5Max()); + influxDBDataHarmRateI.setI6(dataHarmrateI.getI6Max()); + influxDBDataHarmRateI.setI7(dataHarmrateI.getI7Max()); + influxDBDataHarmRateI.setI8(dataHarmrateI.getI8Max()); + influxDBDataHarmRateI.setI9(dataHarmrateI.getI9Max()); + influxDBDataHarmRateI.setI10(dataHarmrateI.getI10Max()); + influxDBDataHarmRateI.setI11(dataHarmrateI.getI11Max()); + influxDBDataHarmRateI.setI12(dataHarmrateI.getI12Max()); + influxDBDataHarmRateI.setI13(dataHarmrateI.getI13Max()); + influxDBDataHarmRateI.setI14(dataHarmrateI.getI14Max()); + influxDBDataHarmRateI.setI15(dataHarmrateI.getI15Max()); + influxDBDataHarmRateI.setI16(dataHarmrateI.getI16Max()); + influxDBDataHarmRateI.setI17(dataHarmrateI.getI17Max()); + influxDBDataHarmRateI.setI18(dataHarmrateI.getI18Max()); + influxDBDataHarmRateI.setI19(dataHarmrateI.getI19Max()); + influxDBDataHarmRateI.setI20(dataHarmrateI.getI20Max()); + influxDBDataHarmRateI.setI21(dataHarmrateI.getI21Max()); + influxDBDataHarmRateI.setI22(dataHarmrateI.getI22Max()); + influxDBDataHarmRateI.setI23(dataHarmrateI.getI23Max()); + influxDBDataHarmRateI.setI24(dataHarmrateI.getI24Max()); + influxDBDataHarmRateI.setI25(dataHarmrateI.getI25Max()); + influxDBDataHarmRateI.setI26(dataHarmrateI.getI26Max()); + influxDBDataHarmRateI.setI27(dataHarmrateI.getI27Max()); + influxDBDataHarmRateI.setI28(dataHarmrateI.getI28Max()); + influxDBDataHarmRateI.setI29(dataHarmrateI.getI29Max()); + influxDBDataHarmRateI.setI30(dataHarmrateI.getI30Max()); + influxDBDataHarmRateI.setI31(dataHarmrateI.getI31Max()); + influxDBDataHarmRateI.setI32(dataHarmrateI.getI32Max()); + influxDBDataHarmRateI.setI33(dataHarmrateI.getI33Max()); + influxDBDataHarmRateI.setI34(dataHarmrateI.getI34Max()); + influxDBDataHarmRateI.setI35(dataHarmrateI.getI35Max()); + influxDBDataHarmRateI.setI36(dataHarmrateI.getI36Max()); + influxDBDataHarmRateI.setI37(dataHarmrateI.getI37Max()); + influxDBDataHarmRateI.setI38(dataHarmrateI.getI38Max()); + influxDBDataHarmRateI.setI39(dataHarmrateI.getI39Max()); + influxDBDataHarmRateI.setI40(dataHarmrateI.getI40Max()); + influxDBDataHarmRateI.setI41(dataHarmrateI.getI41Max()); + influxDBDataHarmRateI.setI42(dataHarmrateI.getI42Max()); + influxDBDataHarmRateI.setI43(dataHarmrateI.getI43Max()); + influxDBDataHarmRateI.setI44(dataHarmrateI.getI44Max()); + influxDBDataHarmRateI.setI45(dataHarmrateI.getI45Max()); + influxDBDataHarmRateI.setI46(dataHarmrateI.getI46Max()); + influxDBDataHarmRateI.setI47(dataHarmrateI.getI47Max()); + influxDBDataHarmRateI.setI48(dataHarmrateI.getI48Max()); + influxDBDataHarmRateI.setI49(dataHarmrateI.getI49Max()); + influxDBDataHarmRateI.setI50(dataHarmrateI.getI50Max()); + } + else if (valueType.equals("MIN")){ + influxDBDataHarmRateI.setI1(dataHarmrateI.getI1Min()); + influxDBDataHarmRateI.setI2(dataHarmrateI.getI2Min()); + influxDBDataHarmRateI.setI3(dataHarmrateI.getI3Min()); + influxDBDataHarmRateI.setI4(dataHarmrateI.getI4Min()); + influxDBDataHarmRateI.setI5(dataHarmrateI.getI5Min()); + influxDBDataHarmRateI.setI6(dataHarmrateI.getI6Min()); + influxDBDataHarmRateI.setI7(dataHarmrateI.getI7Min()); + influxDBDataHarmRateI.setI8(dataHarmrateI.getI8Min()); + influxDBDataHarmRateI.setI9(dataHarmrateI.getI9Min()); + influxDBDataHarmRateI.setI10(dataHarmrateI.getI10Min()); + influxDBDataHarmRateI.setI11(dataHarmrateI.getI11Min()); + influxDBDataHarmRateI.setI12(dataHarmrateI.getI12Min()); + influxDBDataHarmRateI.setI13(dataHarmrateI.getI13Min()); + influxDBDataHarmRateI.setI14(dataHarmrateI.getI14Min()); + influxDBDataHarmRateI.setI15(dataHarmrateI.getI15Min()); + influxDBDataHarmRateI.setI16(dataHarmrateI.getI16Min()); + influxDBDataHarmRateI.setI17(dataHarmrateI.getI17Min()); + influxDBDataHarmRateI.setI18(dataHarmrateI.getI18Min()); + influxDBDataHarmRateI.setI19(dataHarmrateI.getI19Min()); + influxDBDataHarmRateI.setI20(dataHarmrateI.getI20Min()); + influxDBDataHarmRateI.setI21(dataHarmrateI.getI21Min()); + influxDBDataHarmRateI.setI22(dataHarmrateI.getI22Min()); + influxDBDataHarmRateI.setI23(dataHarmrateI.getI23Min()); + influxDBDataHarmRateI.setI24(dataHarmrateI.getI24Min()); + influxDBDataHarmRateI.setI25(dataHarmrateI.getI25Min()); + influxDBDataHarmRateI.setI26(dataHarmrateI.getI26Min()); + influxDBDataHarmRateI.setI27(dataHarmrateI.getI27Min()); + influxDBDataHarmRateI.setI28(dataHarmrateI.getI28Min()); + influxDBDataHarmRateI.setI29(dataHarmrateI.getI29Min()); + influxDBDataHarmRateI.setI30(dataHarmrateI.getI30Min()); + influxDBDataHarmRateI.setI31(dataHarmrateI.getI31Min()); + influxDBDataHarmRateI.setI32(dataHarmrateI.getI32Min()); + influxDBDataHarmRateI.setI33(dataHarmrateI.getI33Min()); + influxDBDataHarmRateI.setI34(dataHarmrateI.getI34Min()); + influxDBDataHarmRateI.setI35(dataHarmrateI.getI35Min()); + influxDBDataHarmRateI.setI36(dataHarmrateI.getI36Min()); + influxDBDataHarmRateI.setI37(dataHarmrateI.getI37Min()); + influxDBDataHarmRateI.setI38(dataHarmrateI.getI38Min()); + influxDBDataHarmRateI.setI39(dataHarmrateI.getI39Min()); + influxDBDataHarmRateI.setI40(dataHarmrateI.getI40Min()); + influxDBDataHarmRateI.setI41(dataHarmrateI.getI41Min()); + influxDBDataHarmRateI.setI42(dataHarmrateI.getI42Min()); + influxDBDataHarmRateI.setI43(dataHarmrateI.getI43Min()); + influxDBDataHarmRateI.setI44(dataHarmrateI.getI44Min()); + influxDBDataHarmRateI.setI45(dataHarmrateI.getI45Min()); + influxDBDataHarmRateI.setI46(dataHarmrateI.getI46Min()); + influxDBDataHarmRateI.setI47(dataHarmrateI.getI47Min()); + influxDBDataHarmRateI.setI48(dataHarmrateI.getI48Min()); + influxDBDataHarmRateI.setI49(dataHarmrateI.getI49Min()); + influxDBDataHarmRateI.setI50(dataHarmrateI.getI50Min()); + } + else if (valueType.equals("CP95")){ + influxDBDataHarmRateI.setI1(dataHarmrateI.getI1Cp95()); + influxDBDataHarmRateI.setI2(dataHarmrateI.getI2Cp95()); + influxDBDataHarmRateI.setI3(dataHarmrateI.getI3Cp95()); + influxDBDataHarmRateI.setI4(dataHarmrateI.getI4Cp95()); + influxDBDataHarmRateI.setI5(dataHarmrateI.getI5Cp95()); + influxDBDataHarmRateI.setI6(dataHarmrateI.getI6Cp95()); + influxDBDataHarmRateI.setI7(dataHarmrateI.getI7Cp95()); + influxDBDataHarmRateI.setI8(dataHarmrateI.getI8Cp95()); + influxDBDataHarmRateI.setI9(dataHarmrateI.getI9Cp95()); + influxDBDataHarmRateI.setI10(dataHarmrateI.getI10Cp95()); + influxDBDataHarmRateI.setI11(dataHarmrateI.getI11Cp95()); + influxDBDataHarmRateI.setI12(dataHarmrateI.getI12Cp95()); + influxDBDataHarmRateI.setI13(dataHarmrateI.getI13Cp95()); + influxDBDataHarmRateI.setI14(dataHarmrateI.getI14Cp95()); + influxDBDataHarmRateI.setI15(dataHarmrateI.getI15Cp95()); + influxDBDataHarmRateI.setI16(dataHarmrateI.getI16Cp95()); + influxDBDataHarmRateI.setI17(dataHarmrateI.getI17Cp95()); + influxDBDataHarmRateI.setI18(dataHarmrateI.getI18Cp95()); + influxDBDataHarmRateI.setI19(dataHarmrateI.getI19Cp95()); + influxDBDataHarmRateI.setI20(dataHarmrateI.getI20Cp95()); + influxDBDataHarmRateI.setI21(dataHarmrateI.getI21Cp95()); + influxDBDataHarmRateI.setI22(dataHarmrateI.getI22Cp95()); + influxDBDataHarmRateI.setI23(dataHarmrateI.getI23Cp95()); + influxDBDataHarmRateI.setI24(dataHarmrateI.getI24Cp95()); + influxDBDataHarmRateI.setI25(dataHarmrateI.getI25Cp95()); + influxDBDataHarmRateI.setI26(dataHarmrateI.getI26Cp95()); + influxDBDataHarmRateI.setI27(dataHarmrateI.getI27Cp95()); + influxDBDataHarmRateI.setI28(dataHarmrateI.getI28Cp95()); + influxDBDataHarmRateI.setI29(dataHarmrateI.getI29Cp95()); + influxDBDataHarmRateI.setI30(dataHarmrateI.getI30Cp95()); + influxDBDataHarmRateI.setI31(dataHarmrateI.getI31Cp95()); + influxDBDataHarmRateI.setI32(dataHarmrateI.getI32Cp95()); + influxDBDataHarmRateI.setI33(dataHarmrateI.getI33Cp95()); + influxDBDataHarmRateI.setI34(dataHarmrateI.getI34Cp95()); + influxDBDataHarmRateI.setI35(dataHarmrateI.getI35Cp95()); + influxDBDataHarmRateI.setI36(dataHarmrateI.getI36Cp95()); + influxDBDataHarmRateI.setI37(dataHarmrateI.getI37Cp95()); + influxDBDataHarmRateI.setI38(dataHarmrateI.getI38Cp95()); + influxDBDataHarmRateI.setI39(dataHarmrateI.getI39Cp95()); + influxDBDataHarmRateI.setI40(dataHarmrateI.getI40Cp95()); + influxDBDataHarmRateI.setI41(dataHarmrateI.getI41Cp95()); + influxDBDataHarmRateI.setI42(dataHarmrateI.getI42Cp95()); + influxDBDataHarmRateI.setI43(dataHarmrateI.getI43Cp95()); + influxDBDataHarmRateI.setI44(dataHarmrateI.getI44Cp95()); + influxDBDataHarmRateI.setI45(dataHarmrateI.getI45Cp95()); + influxDBDataHarmRateI.setI46(dataHarmrateI.getI46Cp95()); + influxDBDataHarmRateI.setI47(dataHarmrateI.getI47Cp95()); + influxDBDataHarmRateI.setI48(dataHarmrateI.getI48Cp95()); + influxDBDataHarmRateI.setI49(dataHarmrateI.getI49Cp95()); + influxDBDataHarmRateI.setI50(dataHarmrateI.getI50Cp95()); + } + + influxDBDataHarmRateIList.add(influxDBDataHarmRateI); + + } + + + + return influxDBDataHarmRateIList; + } + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmRateV.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmRateV.java new file mode 100644 index 0000000..210bdf8 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataHarmRateV.java @@ -0,0 +1,428 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataHarmrateV; +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 11:27 + */ +@Data +@Measurement(name = "data_harmrate_v") +public class InfluxDBDataHarmRateV { + @TimeColumn + @Column(name = "time",tag = true) + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag") + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "v_1") + private Float v1; + + @Column(name = "v_2") + private Float v2; + + @Column(name = "v_3") + private Float v3; + + @Column(name = "v_4") + private Float v4; + + @Column(name = "v_5") + private Float v5; + + @Column(name = "v_6") + private Float v6; + + @Column(name = "v_7") + private Float v7; + + @Column(name = "v_8") + private Float v8; + + @Column(name = "v_9") + private Float v9; + + @Column(name = "v_10") + private Float v10; + + @Column(name = "v_11") + private Float v11; + + @Column(name = "v_12") + private Float v12; + + @Column(name = "v_13") + private Float v13; + + @Column(name = "v_14") + private Float v14; + + @Column(name = "v_15") + private Float v15; + + @Column(name = "v_16") + private Float v16; + + @Column(name = "v_17") + private Float v17; + + @Column(name = "v_18") + private Float v18; + + @Column(name = "v_19") + private Float v19; + + @Column(name = "v_20") + private Float v20; + + @Column(name = "v_21") + private Float v21; + + @Column(name = "v_22") + private Float v22; + + @Column(name = "v_23") + private Float v23; + + @Column(name = "v_24") + private Float v24; + + @Column(name = "v_25") + private Float v25; + + @Column(name = "v_26") + private Float v26; + + @Column(name = "v_27") + private Float v27; + + @Column(name = "v_28") + private Float v28; + + @Column(name = "v_29") + private Float v29; + + @Column(name = "v_30") + private Float v30; + + @Column(name = "v_31") + private Float v31; + + @Column(name = "v_32") + private Float v32; + + @Column(name = "v_33") + private Float v33; + + @Column(name = "v_34") + private Float v34; + + @Column(name = "v_35") + private Float v35; + + @Column(name = "v_36") + private Float v36; + + @Column(name = "v_37") + private Float v37; + + @Column(name = "v_38") + private Float v38; + + @Column(name = "v_39") + private Float v39; + + @Column(name = "v_40") + private Float v40; + + @Column(name = "v_41") + private Float v41; + + @Column(name = "v_42") + private Float v42; + + @Column(name = "v_43") + private Float v43; + + @Column(name = "v_44") + private Float v44; + + @Column(name = "v_45") + private Float v45; + + @Column(name = "v_46") + private Float v46; + + @Column(name = "v_47") + private Float v47; + + @Column(name = "v_48") + private Float v48; + + @Column(name = "v_49") + private Float v49; + + @Column(name = "v_50") + private Float v50; + + public static List oralceToInfluxDB(DataHarmrateV dataHarmrateV) { + if (dataHarmrateV == null) { + return null; + } + List influxDBDataHarmRateVList = new ArrayList<>(); + List valueTypeList = Stream.of("AVG", "MAX", "MIN", "CP95").collect(Collectors.toList()); + for (String valueType : valueTypeList) { + InfluxDBDataHarmRateV influxDBDataHarmRateV = new InfluxDBDataHarmRateV(); + Instant instant = dataHarmrateV.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataHarmRateV.setTime(instant); + influxDBDataHarmRateV.setLineId(dataHarmrateV.getLineid()+""); + influxDBDataHarmRateV.setPhaseType(dataHarmrateV.getPhasicType()); + influxDBDataHarmRateV.setQualityFlag(dataHarmrateV.getQualityflag()+""); + influxDBDataHarmRateV.setValueType(valueType); + if (valueType.equals("AVG")) { + influxDBDataHarmRateV.setV1(dataHarmrateV.getV1()); + influxDBDataHarmRateV.setV2(dataHarmrateV.getV2()); + influxDBDataHarmRateV.setV3(dataHarmrateV.getV3()); + influxDBDataHarmRateV.setV4(dataHarmrateV.getV4()); + influxDBDataHarmRateV.setV5(dataHarmrateV.getV5()); + influxDBDataHarmRateV.setV6(dataHarmrateV.getV6()); + influxDBDataHarmRateV.setV7(dataHarmrateV.getV7()); + influxDBDataHarmRateV.setV8(dataHarmrateV.getV8()); + influxDBDataHarmRateV.setV9(dataHarmrateV.getV9()); + influxDBDataHarmRateV.setV10(dataHarmrateV.getV10()); + influxDBDataHarmRateV.setV11(dataHarmrateV.getV11()); + influxDBDataHarmRateV.setV12(dataHarmrateV.getV12()); + influxDBDataHarmRateV.setV13(dataHarmrateV.getV13()); + influxDBDataHarmRateV.setV14(dataHarmrateV.getV14()); + influxDBDataHarmRateV.setV15(dataHarmrateV.getV15()); + influxDBDataHarmRateV.setV16(dataHarmrateV.getV16()); + influxDBDataHarmRateV.setV17(dataHarmrateV.getV17()); + influxDBDataHarmRateV.setV18(dataHarmrateV.getV18()); + influxDBDataHarmRateV.setV19(dataHarmrateV.getV19()); + influxDBDataHarmRateV.setV20(dataHarmrateV.getV20()); + influxDBDataHarmRateV.setV21(dataHarmrateV.getV21()); + influxDBDataHarmRateV.setV22(dataHarmrateV.getV22()); + influxDBDataHarmRateV.setV23(dataHarmrateV.getV23()); + influxDBDataHarmRateV.setV24(dataHarmrateV.getV24()); + influxDBDataHarmRateV.setV25(dataHarmrateV.getV25()); + influxDBDataHarmRateV.setV26(dataHarmrateV.getV26()); + influxDBDataHarmRateV.setV27(dataHarmrateV.getV27()); + influxDBDataHarmRateV.setV28(dataHarmrateV.getV28()); + influxDBDataHarmRateV.setV29(dataHarmrateV.getV29()); + influxDBDataHarmRateV.setV30(dataHarmrateV.getV30()); + influxDBDataHarmRateV.setV31(dataHarmrateV.getV31()); + influxDBDataHarmRateV.setV32(dataHarmrateV.getV32()); + influxDBDataHarmRateV.setV33(dataHarmrateV.getV33()); + influxDBDataHarmRateV.setV34(dataHarmrateV.getV34()); + influxDBDataHarmRateV.setV35(dataHarmrateV.getV35()); + influxDBDataHarmRateV.setV36(dataHarmrateV.getV36()); + influxDBDataHarmRateV.setV37(dataHarmrateV.getV37()); + influxDBDataHarmRateV.setV38(dataHarmrateV.getV38()); + influxDBDataHarmRateV.setV39(dataHarmrateV.getV39()); + influxDBDataHarmRateV.setV40(dataHarmrateV.getV40()); + influxDBDataHarmRateV.setV41(dataHarmrateV.getV41()); + influxDBDataHarmRateV.setV42(dataHarmrateV.getV42()); + influxDBDataHarmRateV.setV43(dataHarmrateV.getV43()); + influxDBDataHarmRateV.setV44(dataHarmrateV.getV44()); + influxDBDataHarmRateV.setV45(dataHarmrateV.getV45()); + influxDBDataHarmRateV.setV46(dataHarmrateV.getV46()); + influxDBDataHarmRateV.setV47(dataHarmrateV.getV47()); + influxDBDataHarmRateV.setV48(dataHarmrateV.getV48()); + influxDBDataHarmRateV.setV49(dataHarmrateV.getV49()); + influxDBDataHarmRateV.setV50(dataHarmrateV.getV50()); + } + else if (valueType.equals("MAX")){ + influxDBDataHarmRateV.setV1(dataHarmrateV.getV1Max()); + influxDBDataHarmRateV.setV2(dataHarmrateV.getV2Max()); + influxDBDataHarmRateV.setV3(dataHarmrateV.getV3Max()); + influxDBDataHarmRateV.setV4(dataHarmrateV.getV4Max()); + influxDBDataHarmRateV.setV5(dataHarmrateV.getV5Max()); + influxDBDataHarmRateV.setV6(dataHarmrateV.getV6Max()); + influxDBDataHarmRateV.setV7(dataHarmrateV.getV7Max()); + influxDBDataHarmRateV.setV8(dataHarmrateV.getV8Max()); + influxDBDataHarmRateV.setV9(dataHarmrateV.getV9Max()); + influxDBDataHarmRateV.setV10(dataHarmrateV.getV10Max()); + influxDBDataHarmRateV.setV11(dataHarmrateV.getV11Max()); + influxDBDataHarmRateV.setV12(dataHarmrateV.getV12Max()); + influxDBDataHarmRateV.setV13(dataHarmrateV.getV13Max()); + influxDBDataHarmRateV.setV14(dataHarmrateV.getV14Max()); + influxDBDataHarmRateV.setV15(dataHarmrateV.getV15Max()); + influxDBDataHarmRateV.setV16(dataHarmrateV.getV16Max()); + influxDBDataHarmRateV.setV17(dataHarmrateV.getV17Max()); + influxDBDataHarmRateV.setV18(dataHarmrateV.getV18Max()); + influxDBDataHarmRateV.setV19(dataHarmrateV.getV19Max()); + influxDBDataHarmRateV.setV20(dataHarmrateV.getV20Max()); + influxDBDataHarmRateV.setV21(dataHarmrateV.getV21Max()); + influxDBDataHarmRateV.setV22(dataHarmrateV.getV22Max()); + influxDBDataHarmRateV.setV23(dataHarmrateV.getV23Max()); + influxDBDataHarmRateV.setV24(dataHarmrateV.getV24Max()); + influxDBDataHarmRateV.setV25(dataHarmrateV.getV25Max()); + influxDBDataHarmRateV.setV26(dataHarmrateV.getV26Max()); + influxDBDataHarmRateV.setV27(dataHarmrateV.getV27Max()); + influxDBDataHarmRateV.setV28(dataHarmrateV.getV28Max()); + influxDBDataHarmRateV.setV29(dataHarmrateV.getV29Max()); + influxDBDataHarmRateV.setV30(dataHarmrateV.getV30Max()); + influxDBDataHarmRateV.setV31(dataHarmrateV.getV31Max()); + influxDBDataHarmRateV.setV32(dataHarmrateV.getV32Max()); + influxDBDataHarmRateV.setV33(dataHarmrateV.getV33Max()); + influxDBDataHarmRateV.setV34(dataHarmrateV.getV34Max()); + influxDBDataHarmRateV.setV35(dataHarmrateV.getV35Max()); + influxDBDataHarmRateV.setV36(dataHarmrateV.getV36Max()); + influxDBDataHarmRateV.setV37(dataHarmrateV.getV37Max()); + influxDBDataHarmRateV.setV38(dataHarmrateV.getV38Max()); + influxDBDataHarmRateV.setV39(dataHarmrateV.getV39Max()); + influxDBDataHarmRateV.setV40(dataHarmrateV.getV40Max()); + influxDBDataHarmRateV.setV41(dataHarmrateV.getV41Max()); + influxDBDataHarmRateV.setV42(dataHarmrateV.getV42Max()); + influxDBDataHarmRateV.setV43(dataHarmrateV.getV43Max()); + influxDBDataHarmRateV.setV44(dataHarmrateV.getV44Max()); + influxDBDataHarmRateV.setV45(dataHarmrateV.getV45Max()); + influxDBDataHarmRateV.setV46(dataHarmrateV.getV46Max()); + influxDBDataHarmRateV.setV47(dataHarmrateV.getV47Max()); + influxDBDataHarmRateV.setV48(dataHarmrateV.getV48Max()); + influxDBDataHarmRateV.setV49(dataHarmrateV.getV49Max()); + influxDBDataHarmRateV.setV50(dataHarmrateV.getV50Max()); + } + else if (valueType.equals("MIN")){ + influxDBDataHarmRateV.setV1(dataHarmrateV.getV1Min()); + influxDBDataHarmRateV.setV2(dataHarmrateV.getV2Min()); + influxDBDataHarmRateV.setV3(dataHarmrateV.getV3Min()); + influxDBDataHarmRateV.setV4(dataHarmrateV.getV4Min()); + influxDBDataHarmRateV.setV5(dataHarmrateV.getV5Min()); + influxDBDataHarmRateV.setV6(dataHarmrateV.getV6Min()); + influxDBDataHarmRateV.setV7(dataHarmrateV.getV7Min()); + influxDBDataHarmRateV.setV8(dataHarmrateV.getV8Min()); + influxDBDataHarmRateV.setV9(dataHarmrateV.getV9Min()); + influxDBDataHarmRateV.setV10(dataHarmrateV.getV10Min()); + influxDBDataHarmRateV.setV11(dataHarmrateV.getV11Min()); + influxDBDataHarmRateV.setV12(dataHarmrateV.getV12Min()); + influxDBDataHarmRateV.setV13(dataHarmrateV.getV13Min()); + influxDBDataHarmRateV.setV14(dataHarmrateV.getV14Min()); + influxDBDataHarmRateV.setV15(dataHarmrateV.getV15Min()); + influxDBDataHarmRateV.setV16(dataHarmrateV.getV16Min()); + influxDBDataHarmRateV.setV17(dataHarmrateV.getV17Min()); + influxDBDataHarmRateV.setV18(dataHarmrateV.getV18Min()); + influxDBDataHarmRateV.setV19(dataHarmrateV.getV19Min()); + influxDBDataHarmRateV.setV20(dataHarmrateV.getV20Min()); + influxDBDataHarmRateV.setV21(dataHarmrateV.getV21Min()); + influxDBDataHarmRateV.setV22(dataHarmrateV.getV22Min()); + influxDBDataHarmRateV.setV23(dataHarmrateV.getV23Min()); + influxDBDataHarmRateV.setV24(dataHarmrateV.getV24Min()); + influxDBDataHarmRateV.setV25(dataHarmrateV.getV25Min()); + influxDBDataHarmRateV.setV26(dataHarmrateV.getV26Min()); + influxDBDataHarmRateV.setV27(dataHarmrateV.getV27Min()); + influxDBDataHarmRateV.setV28(dataHarmrateV.getV28Min()); + influxDBDataHarmRateV.setV29(dataHarmrateV.getV29Min()); + influxDBDataHarmRateV.setV30(dataHarmrateV.getV30Min()); + influxDBDataHarmRateV.setV31(dataHarmrateV.getV31Min()); + influxDBDataHarmRateV.setV32(dataHarmrateV.getV32Min()); + influxDBDataHarmRateV.setV33(dataHarmrateV.getV33Min()); + influxDBDataHarmRateV.setV34(dataHarmrateV.getV34Min()); + influxDBDataHarmRateV.setV35(dataHarmrateV.getV35Min()); + influxDBDataHarmRateV.setV36(dataHarmrateV.getV36Min()); + influxDBDataHarmRateV.setV37(dataHarmrateV.getV37Min()); + influxDBDataHarmRateV.setV38(dataHarmrateV.getV38Min()); + influxDBDataHarmRateV.setV39(dataHarmrateV.getV39Min()); + influxDBDataHarmRateV.setV40(dataHarmrateV.getV40Min()); + influxDBDataHarmRateV.setV41(dataHarmrateV.getV41Min()); + influxDBDataHarmRateV.setV42(dataHarmrateV.getV42Min()); + influxDBDataHarmRateV.setV43(dataHarmrateV.getV43Min()); + influxDBDataHarmRateV.setV44(dataHarmrateV.getV44Min()); + influxDBDataHarmRateV.setV45(dataHarmrateV.getV45Min()); + influxDBDataHarmRateV.setV46(dataHarmrateV.getV46Min()); + influxDBDataHarmRateV.setV47(dataHarmrateV.getV47Min()); + influxDBDataHarmRateV.setV48(dataHarmrateV.getV48Min()); + influxDBDataHarmRateV.setV49(dataHarmrateV.getV49Min()); + influxDBDataHarmRateV.setV50(dataHarmrateV.getV50Min()); + } + else if (valueType.equals("CP95")){ + influxDBDataHarmRateV.setV1(dataHarmrateV.getV1Cp95()); + influxDBDataHarmRateV.setV2(dataHarmrateV.getV2Cp95()); + influxDBDataHarmRateV.setV3(dataHarmrateV.getV3Cp95()); + influxDBDataHarmRateV.setV4(dataHarmrateV.getV4Cp95()); + influxDBDataHarmRateV.setV5(dataHarmrateV.getV5Cp95()); + influxDBDataHarmRateV.setV6(dataHarmrateV.getV6Cp95()); + influxDBDataHarmRateV.setV7(dataHarmrateV.getV7Cp95()); + influxDBDataHarmRateV.setV8(dataHarmrateV.getV8Cp95()); + influxDBDataHarmRateV.setV9(dataHarmrateV.getV9Cp95()); + influxDBDataHarmRateV.setV10(dataHarmrateV.getV10Cp95()); + influxDBDataHarmRateV.setV11(dataHarmrateV.getV11Cp95()); + influxDBDataHarmRateV.setV12(dataHarmrateV.getV12Cp95()); + influxDBDataHarmRateV.setV13(dataHarmrateV.getV13Cp95()); + influxDBDataHarmRateV.setV14(dataHarmrateV.getV14Cp95()); + influxDBDataHarmRateV.setV15(dataHarmrateV.getV15Cp95()); + influxDBDataHarmRateV.setV16(dataHarmrateV.getV16Cp95()); + influxDBDataHarmRateV.setV17(dataHarmrateV.getV17Cp95()); + influxDBDataHarmRateV.setV18(dataHarmrateV.getV18Cp95()); + influxDBDataHarmRateV.setV19(dataHarmrateV.getV19Cp95()); + influxDBDataHarmRateV.setV20(dataHarmrateV.getV20Cp95()); + influxDBDataHarmRateV.setV21(dataHarmrateV.getV21Cp95()); + influxDBDataHarmRateV.setV22(dataHarmrateV.getV22Cp95()); + influxDBDataHarmRateV.setV23(dataHarmrateV.getV23Cp95()); + influxDBDataHarmRateV.setV24(dataHarmrateV.getV24Cp95()); + influxDBDataHarmRateV.setV25(dataHarmrateV.getV25Cp95()); + influxDBDataHarmRateV.setV26(dataHarmrateV.getV26Cp95()); + influxDBDataHarmRateV.setV27(dataHarmrateV.getV27Cp95()); + influxDBDataHarmRateV.setV28(dataHarmrateV.getV28Cp95()); + influxDBDataHarmRateV.setV29(dataHarmrateV.getV29Cp95()); + influxDBDataHarmRateV.setV30(dataHarmrateV.getV30Cp95()); + influxDBDataHarmRateV.setV31(dataHarmrateV.getV31Cp95()); + influxDBDataHarmRateV.setV32(dataHarmrateV.getV32Cp95()); + influxDBDataHarmRateV.setV33(dataHarmrateV.getV33Cp95()); + influxDBDataHarmRateV.setV34(dataHarmrateV.getV34Cp95()); + influxDBDataHarmRateV.setV35(dataHarmrateV.getV35Cp95()); + influxDBDataHarmRateV.setV36(dataHarmrateV.getV36Cp95()); + influxDBDataHarmRateV.setV37(dataHarmrateV.getV37Cp95()); + influxDBDataHarmRateV.setV38(dataHarmrateV.getV38Cp95()); + influxDBDataHarmRateV.setV39(dataHarmrateV.getV39Cp95()); + influxDBDataHarmRateV.setV40(dataHarmrateV.getV40Cp95()); + influxDBDataHarmRateV.setV41(dataHarmrateV.getV41Cp95()); + influxDBDataHarmRateV.setV42(dataHarmrateV.getV42Cp95()); + influxDBDataHarmRateV.setV43(dataHarmrateV.getV43Cp95()); + influxDBDataHarmRateV.setV44(dataHarmrateV.getV44Cp95()); + influxDBDataHarmRateV.setV45(dataHarmrateV.getV45Cp95()); + influxDBDataHarmRateV.setV46(dataHarmrateV.getV46Cp95()); + influxDBDataHarmRateV.setV47(dataHarmrateV.getV47Cp95()); + influxDBDataHarmRateV.setV48(dataHarmrateV.getV48Cp95()); + influxDBDataHarmRateV.setV49(dataHarmrateV.getV49Cp95()); + influxDBDataHarmRateV.setV50(dataHarmrateV.getV50Cp95()); + } + + influxDBDataHarmRateVList.add(influxDBDataHarmRateV); + + } + + + + return influxDBDataHarmRateVList; + } +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataI.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataI.java new file mode 100644 index 0000000..4743fe7 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataI.java @@ -0,0 +1,479 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataI; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/11 15:13 + */ +@Data +@Measurement(name = "data_i") +public class InfluxDBDataI { + + @Column(name = "time",tag =true) + @JsonSerialize(using = InstantDateSerializer.class) + @TimeColumn + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag") + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "i_neg") + private Float iNeg; + + @Column(name = "i_pos") + private Float iPos; + + @Column(name = "i_thd") + private Float iThd; + + @Column(name = "i_unbalance") + private Float iUnbalance; + + @Column(name = "i_zero") + private Float iZero; + + @Column(name = "rms") + private Float rms; + + @Column(name = "i_1") + private Float i1; + + @Column(name = "i_2") + private Float i2; + + @Column(name = "i_3") + private Float i3; + + @Column(name = "i_4") + private Float i4; + + @Column(name = "i_5") + private Float i5; + + @Column(name = "i_6") + private Float i6; + + @Column(name = "i_7") + private Float i7; + + @Column(name = "i_8") + private Float i8; + + @Column(name = "i_9") + private Float i9; + + @Column(name = "i_10") + private Float i10; + + @Column(name = "i_11") + private Float i11; + + @Column(name = "i_12") + private Float i12; + + @Column(name = "i_13") + private Float i13; + + @Column(name = "i_14") + private Float i14; + + @Column(name = "i_15") + private Float i15; + + @Column(name = "i_16") + private Float i16; + + @Column(name = "i_17") + private Float i17; + + @Column(name = "i_18") + private Float i18; + + @Column(name = "i_19") + private Float i19; + + @Column(name = "i_20") + private Float i20; + + @Column(name = "i_21") + private Float i21; + + @Column(name = "i_22") + private Float i22; + + @Column(name = "i_23") + private Float i23; + + @Column(name = "i_24") + private Float i24; + + @Column(name = "i_25") + private Float i25; + + @Column(name = "i_26") + private Float i26; + + @Column(name = "i_27") + private Float i27; + + @Column(name = "i_28") + private Float i28; + + @Column(name = "i_29") + private Float i29; + + @Column(name = "i_30") + private Float i30; + + @Column(name = "i_31") + private Float i31; + + @Column(name = "i_32") + private Float i32; + + @Column(name = "i_33") + private Float i33; + + @Column(name = "i_34") + private Float i34; + + @Column(name = "i_35") + private Float i35; + + @Column(name = "i_36") + private Float i36; + + @Column(name = "i_37") + private Float i37; + + @Column(name = "i_38") + private Float i38; + + @Column(name = "i_39") + private Float i39; + + @Column(name = "i_40") + private Float i40; + + @Column(name = "i_41") + private Float i41; + + @Column(name = "i_42") + private Float i42; + + @Column(name = "i_43") + private Float i43; + + @Column(name = "i_44") + private Float i44; + + @Column(name = "i_45") + private Float i45; + + @Column(name = "i_46") + private Float i46; + + @Column(name = "i_47") + private Float i47; + + @Column(name = "i_48") + private Float i48; + + @Column(name = "i_49") + private Float i49; + + @Column(name = "i_50") + private Float i50; + + public static List oralceToInfluxDB(DataI dataI) { + if (dataI == null) { + return null; + } + List influxDBDataIList = new ArrayList<>(); + List valueTypeList = Stream.of("AVG", "MAX", "MIN", "CP95").collect(Collectors.toList()); + for (String valueType : valueTypeList) { + InfluxDBDataI influxDBDataI = new InfluxDBDataI(); + Instant instant = dataI.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataI.setTime(instant); + influxDBDataI.setLineId(dataI.getLineid()+""); + influxDBDataI.setPhaseType(dataI.getPhasicType()); + influxDBDataI.setQualityFlag(dataI.getQualityflag()+""); + influxDBDataI.setValueType(valueType); + if (valueType.equals("AVG")) { + + influxDBDataI.setINeg(dataI.getINeg()); + influxDBDataI.setIPos(dataI.getIPos()); + influxDBDataI.setIThd(dataI.getIThd()); + influxDBDataI.setIUnbalance(dataI.getIUnbalance()); + influxDBDataI.setIZero(dataI.getIZero()); + influxDBDataI.setRms(dataI.getRms()); + + + influxDBDataI.setI1(dataI.getI1()); + influxDBDataI.setI2(dataI.getI2()); + influxDBDataI.setI3(dataI.getI3()); + influxDBDataI.setI4(dataI.getI4()); + influxDBDataI.setI5(dataI.getI5()); + influxDBDataI.setI6(dataI.getI6()); + influxDBDataI.setI7(dataI.getI7()); + influxDBDataI.setI8(dataI.getI8()); + influxDBDataI.setI9(dataI.getI9()); + influxDBDataI.setI10(dataI.getI10()); + influxDBDataI.setI11(dataI.getI11()); + influxDBDataI.setI12(dataI.getI12()); + influxDBDataI.setI13(dataI.getI13()); + influxDBDataI.setI14(dataI.getI14()); + influxDBDataI.setI15(dataI.getI15()); + influxDBDataI.setI16(dataI.getI16()); + influxDBDataI.setI17(dataI.getI17()); + influxDBDataI.setI18(dataI.getI18()); + influxDBDataI.setI19(dataI.getI19()); + influxDBDataI.setI20(dataI.getI20()); + influxDBDataI.setI21(dataI.getI21()); + influxDBDataI.setI22(dataI.getI22()); + influxDBDataI.setI23(dataI.getI23()); + influxDBDataI.setI24(dataI.getI24()); + influxDBDataI.setI25(dataI.getI25()); + influxDBDataI.setI26(dataI.getI26()); + influxDBDataI.setI27(dataI.getI27()); + influxDBDataI.setI28(dataI.getI28()); + influxDBDataI.setI29(dataI.getI29()); + influxDBDataI.setI30(dataI.getI30()); + influxDBDataI.setI31(dataI.getI31()); + influxDBDataI.setI32(dataI.getI32()); + influxDBDataI.setI33(dataI.getI33()); + influxDBDataI.setI34(dataI.getI34()); + influxDBDataI.setI35(dataI.getI35()); + influxDBDataI.setI36(dataI.getI36()); + influxDBDataI.setI37(dataI.getI37()); + influxDBDataI.setI38(dataI.getI38()); + influxDBDataI.setI39(dataI.getI39()); + influxDBDataI.setI40(dataI.getI40()); + influxDBDataI.setI41(dataI.getI41()); + influxDBDataI.setI42(dataI.getI42()); + influxDBDataI.setI43(dataI.getI43()); + influxDBDataI.setI44(dataI.getI44()); + influxDBDataI.setI45(dataI.getI45()); + influxDBDataI.setI46(dataI.getI46()); + influxDBDataI.setI47(dataI.getI47()); + influxDBDataI.setI48(dataI.getI48()); + influxDBDataI.setI49(dataI.getI49()); + influxDBDataI.setI50(dataI.getI50()); + } + else if (valueType.equals("MAX")){ + + influxDBDataI.setINeg(dataI.getINegMax()); + influxDBDataI.setIPos(dataI.getIPosMax()); + influxDBDataI.setIThd(dataI.getIThdMax()); + influxDBDataI.setIUnbalance(dataI.getIUnbalanceMax()); + influxDBDataI.setIZero(dataI.getIZeroMax()); + influxDBDataI.setRms(dataI.getRmsMax()); + + influxDBDataI.setI1(dataI.getI1Max()); + influxDBDataI.setI2(dataI.getI2Max()); + influxDBDataI.setI3(dataI.getI3Max()); + influxDBDataI.setI4(dataI.getI4Max()); + influxDBDataI.setI5(dataI.getI5Max()); + influxDBDataI.setI6(dataI.getI6Max()); + influxDBDataI.setI7(dataI.getI7Max()); + influxDBDataI.setI8(dataI.getI8Max()); + influxDBDataI.setI9(dataI.getI9Max()); + influxDBDataI.setI10(dataI.getI10Max()); + influxDBDataI.setI11(dataI.getI11Max()); + influxDBDataI.setI12(dataI.getI12Max()); + influxDBDataI.setI13(dataI.getI13Max()); + influxDBDataI.setI14(dataI.getI14Max()); + influxDBDataI.setI15(dataI.getI15Max()); + influxDBDataI.setI16(dataI.getI16Max()); + influxDBDataI.setI17(dataI.getI17Max()); + influxDBDataI.setI18(dataI.getI18Max()); + influxDBDataI.setI19(dataI.getI19Max()); + influxDBDataI.setI20(dataI.getI20Max()); + influxDBDataI.setI21(dataI.getI21Max()); + influxDBDataI.setI22(dataI.getI22Max()); + influxDBDataI.setI23(dataI.getI23Max()); + influxDBDataI.setI24(dataI.getI24Max()); + influxDBDataI.setI25(dataI.getI25Max()); + influxDBDataI.setI26(dataI.getI26Max()); + influxDBDataI.setI27(dataI.getI27Max()); + influxDBDataI.setI28(dataI.getI28Max()); + influxDBDataI.setI29(dataI.getI29Max()); + influxDBDataI.setI30(dataI.getI30Max()); + influxDBDataI.setI31(dataI.getI31Max()); + influxDBDataI.setI32(dataI.getI32Max()); + influxDBDataI.setI33(dataI.getI33Max()); + influxDBDataI.setI34(dataI.getI34Max()); + influxDBDataI.setI35(dataI.getI35Max()); + influxDBDataI.setI36(dataI.getI36Max()); + influxDBDataI.setI37(dataI.getI37Max()); + influxDBDataI.setI38(dataI.getI38Max()); + influxDBDataI.setI39(dataI.getI39Max()); + influxDBDataI.setI40(dataI.getI40Max()); + influxDBDataI.setI41(dataI.getI41Max()); + influxDBDataI.setI42(dataI.getI42Max()); + influxDBDataI.setI43(dataI.getI43Max()); + influxDBDataI.setI44(dataI.getI44Max()); + influxDBDataI.setI45(dataI.getI45Max()); + influxDBDataI.setI46(dataI.getI46Max()); + influxDBDataI.setI47(dataI.getI47Max()); + influxDBDataI.setI48(dataI.getI48Max()); + influxDBDataI.setI49(dataI.getI49Max()); + influxDBDataI.setI50(dataI.getI50Max()); + } + else if (valueType.equals("MIN")){ + + influxDBDataI.setINeg(dataI.getINegMin()); + influxDBDataI.setIPos(dataI.getIPosMin()); + influxDBDataI.setIThd(dataI.getIThdMin()); + influxDBDataI.setIUnbalance(dataI.getIUnbalanceMin()); + influxDBDataI.setIZero(dataI.getIZeroMin()); + influxDBDataI.setRms(dataI.getRmsMin()); + + influxDBDataI.setI1(dataI.getI1Min()); + influxDBDataI.setI2(dataI.getI2Min()); + influxDBDataI.setI3(dataI.getI3Min()); + influxDBDataI.setI4(dataI.getI4Min()); + influxDBDataI.setI5(dataI.getI5Min()); + influxDBDataI.setI6(dataI.getI6Min()); + influxDBDataI.setI7(dataI.getI7Min()); + influxDBDataI.setI8(dataI.getI8Min()); + influxDBDataI.setI9(dataI.getI9Min()); + influxDBDataI.setI10(dataI.getI10Min()); + influxDBDataI.setI11(dataI.getI11Min()); + influxDBDataI.setI12(dataI.getI12Min()); + influxDBDataI.setI13(dataI.getI13Min()); + influxDBDataI.setI14(dataI.getI14Min()); + influxDBDataI.setI15(dataI.getI15Min()); + influxDBDataI.setI16(dataI.getI16Min()); + influxDBDataI.setI17(dataI.getI17Min()); + influxDBDataI.setI18(dataI.getI18Min()); + influxDBDataI.setI19(dataI.getI19Min()); + influxDBDataI.setI20(dataI.getI20Min()); + influxDBDataI.setI21(dataI.getI21Min()); + influxDBDataI.setI22(dataI.getI22Min()); + influxDBDataI.setI23(dataI.getI23Min()); + influxDBDataI.setI24(dataI.getI24Min()); + influxDBDataI.setI25(dataI.getI25Min()); + influxDBDataI.setI26(dataI.getI26Min()); + influxDBDataI.setI27(dataI.getI27Min()); + influxDBDataI.setI28(dataI.getI28Min()); + influxDBDataI.setI29(dataI.getI29Min()); + influxDBDataI.setI30(dataI.getI30Min()); + influxDBDataI.setI31(dataI.getI31Min()); + influxDBDataI.setI32(dataI.getI32Min()); + influxDBDataI.setI33(dataI.getI33Min()); + influxDBDataI.setI34(dataI.getI34Min()); + influxDBDataI.setI35(dataI.getI35Min()); + influxDBDataI.setI36(dataI.getI36Min()); + influxDBDataI.setI37(dataI.getI37Min()); + influxDBDataI.setI38(dataI.getI38Min()); + influxDBDataI.setI39(dataI.getI39Min()); + influxDBDataI.setI40(dataI.getI40Min()); + influxDBDataI.setI41(dataI.getI41Min()); + influxDBDataI.setI42(dataI.getI42Min()); + influxDBDataI.setI43(dataI.getI43Min()); + influxDBDataI.setI44(dataI.getI44Min()); + influxDBDataI.setI45(dataI.getI45Min()); + influxDBDataI.setI46(dataI.getI46Min()); + influxDBDataI.setI47(dataI.getI47Min()); + influxDBDataI.setI48(dataI.getI48Min()); + influxDBDataI.setI49(dataI.getI49Min()); + influxDBDataI.setI50(dataI.getI50Min()); + } + else if (valueType.equals("CP95")){ + influxDBDataI.setINeg(dataI.getINegCp95()); + influxDBDataI.setIPos(dataI.getIPosCp95()); + influxDBDataI.setIThd(dataI.getIThdCp95()); + influxDBDataI.setIUnbalance(dataI.getIUnbalanceCp95()); + influxDBDataI.setIZero(dataI.getIZeroCp95()); + influxDBDataI.setRms(dataI.getRmsCp95()); + + influxDBDataI.setI1(dataI.getI1Cp95()); + influxDBDataI.setI2(dataI.getI2Cp95()); + influxDBDataI.setI3(dataI.getI3Cp95()); + influxDBDataI.setI4(dataI.getI4Cp95()); + influxDBDataI.setI5(dataI.getI5Cp95()); + influxDBDataI.setI6(dataI.getI6Cp95()); + influxDBDataI.setI7(dataI.getI7Cp95()); + influxDBDataI.setI8(dataI.getI8Cp95()); + influxDBDataI.setI9(dataI.getI9Cp95()); + influxDBDataI.setI10(dataI.getI10Cp95()); + influxDBDataI.setI11(dataI.getI11Cp95()); + influxDBDataI.setI12(dataI.getI12Cp95()); + influxDBDataI.setI13(dataI.getI13Cp95()); + influxDBDataI.setI14(dataI.getI14Cp95()); + influxDBDataI.setI15(dataI.getI15Cp95()); + influxDBDataI.setI16(dataI.getI16Cp95()); + influxDBDataI.setI17(dataI.getI17Cp95()); + influxDBDataI.setI18(dataI.getI18Cp95()); + influxDBDataI.setI19(dataI.getI19Cp95()); + influxDBDataI.setI20(dataI.getI20Cp95()); + influxDBDataI.setI21(dataI.getI21Cp95()); + influxDBDataI.setI22(dataI.getI22Cp95()); + influxDBDataI.setI23(dataI.getI23Cp95()); + influxDBDataI.setI24(dataI.getI24Cp95()); + influxDBDataI.setI25(dataI.getI25Cp95()); + influxDBDataI.setI26(dataI.getI26Cp95()); + influxDBDataI.setI27(dataI.getI27Cp95()); + influxDBDataI.setI28(dataI.getI28Cp95()); + influxDBDataI.setI29(dataI.getI29Cp95()); + influxDBDataI.setI30(dataI.getI30Cp95()); + influxDBDataI.setI31(dataI.getI31Cp95()); + influxDBDataI.setI32(dataI.getI32Cp95()); + influxDBDataI.setI33(dataI.getI33Cp95()); + influxDBDataI.setI34(dataI.getI34Cp95()); + influxDBDataI.setI35(dataI.getI35Cp95()); + influxDBDataI.setI36(dataI.getI36Cp95()); + influxDBDataI.setI37(dataI.getI37Cp95()); + influxDBDataI.setI38(dataI.getI38Cp95()); + influxDBDataI.setI39(dataI.getI39Cp95()); + influxDBDataI.setI40(dataI.getI40Cp95()); + influxDBDataI.setI41(dataI.getI41Cp95()); + influxDBDataI.setI42(dataI.getI42Cp95()); + influxDBDataI.setI43(dataI.getI43Cp95()); + influxDBDataI.setI44(dataI.getI44Cp95()); + influxDBDataI.setI45(dataI.getI45Cp95()); + influxDBDataI.setI46(dataI.getI46Cp95()); + influxDBDataI.setI47(dataI.getI47Cp95()); + influxDBDataI.setI48(dataI.getI48Cp95()); + influxDBDataI.setI49(dataI.getI49Cp95()); + influxDBDataI.setI50(dataI.getI50Cp95()); + } + + influxDBDataIList.add(influxDBDataI); + + } + + + + return influxDBDataIList; + } + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataInHarmI.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataInHarmI.java new file mode 100644 index 0000000..4acb6c2 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataInHarmI.java @@ -0,0 +1,432 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataInharmI; +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 11:27 + */ +@Data +@Measurement(name = "data_inharm_i") +public class InfluxDBDataInHarmI { + + @TimeColumn + @Column(name = "time",tag = true) + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag") + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "i_1") + private Float i1; + + @Column(name = "i_2") + private Float i2; + + @Column(name = "i_3") + private Float i3; + + @Column(name = "i_4") + private Float i4; + + @Column(name = "i_5") + private Float i5; + + @Column(name = "i_6") + private Float i6; + + @Column(name = "i_7") + private Float i7; + + @Column(name = "i_8") + private Float i8; + + @Column(name = "i_9") + private Float i9; + + @Column(name = "i_10") + private Float i10; + + @Column(name = "i_11") + private Float i11; + + @Column(name = "i_12") + private Float i12; + + @Column(name = "i_13") + private Float i13; + + @Column(name = "i_14") + private Float i14; + + @Column(name = "i_15") + private Float i15; + + @Column(name = "i_16") + private Float i16; + + @Column(name = "i_17") + private Float i17; + + @Column(name = "i_18") + private Float i18; + + @Column(name = "i_19") + private Float i19; + + @Column(name = "i_20") + private Float i20; + + @Column(name = "i_21") + private Float i21; + + @Column(name = "i_22") + private Float i22; + + @Column(name = "i_23") + private Float i23; + + @Column(name = "i_24") + private Float i24; + + @Column(name = "i_25") + private Float i25; + + @Column(name = "i_26") + private Float i26; + + @Column(name = "i_27") + private Float i27; + + @Column(name = "i_28") + private Float i28; + + @Column(name = "i_29") + private Float i29; + + @Column(name = "i_30") + private Float i30; + + @Column(name = "i_31") + private Float i31; + + @Column(name = "i_32") + private Float i32; + + @Column(name = "i_33") + private Float i33; + + @Column(name = "i_34") + private Float i34; + + @Column(name = "i_35") + private Float i35; + + @Column(name = "i_36") + private Float i36; + + @Column(name = "i_37") + private Float i37; + + @Column(name = "i_38") + private Float i38; + + @Column(name = "i_39") + private Float i39; + + @Column(name = "i_40") + private Float i40; + + @Column(name = "i_41") + private Float i41; + + @Column(name = "i_42") + private Float i42; + + @Column(name = "i_43") + private Float i43; + + @Column(name = "i_44") + private Float i44; + + @Column(name = "i_45") + private Float i45; + + @Column(name = "i_46") + private Float i46; + + @Column(name = "i_47") + private Float i47; + + @Column(name = "i_48") + private Float i48; + + @Column(name = "i_49") + private Float i49; + + @Column(name = "i_50") + private Float i50; + + + public static List oralceToInfluxDB(DataInharmI dataInharmI) { + if (dataInharmI == null) { + return null; + } + List influxDBDataInHarmIList = new ArrayList<>(); + List valueTypeList = Stream.of("AVG", "MAX", "MIN", "CP95").collect(Collectors.toList()); + for (String valueType : valueTypeList) { + InfluxDBDataInHarmI influxDBDataInHarmI = new InfluxDBDataInHarmI(); + Instant instant = dataInharmI.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataInHarmI.setTime(instant); + influxDBDataInHarmI.setLineId(dataInharmI.getLineid()+""); + influxDBDataInHarmI.setPhaseType(dataInharmI.getPhasicType()); + influxDBDataInHarmI.setQualityFlag(dataInharmI.getQualityflag()+""); + influxDBDataInHarmI.setValueType(valueType); + if (valueType.equals("AVG")) { + influxDBDataInHarmI.setI1(dataInharmI.getI1()); + influxDBDataInHarmI.setI2(dataInharmI.getI2()); + influxDBDataInHarmI.setI3(dataInharmI.getI3()); + influxDBDataInHarmI.setI4(dataInharmI.getI4()); + influxDBDataInHarmI.setI5(dataInharmI.getI5()); + influxDBDataInHarmI.setI6(dataInharmI.getI6()); + influxDBDataInHarmI.setI7(dataInharmI.getI7()); + influxDBDataInHarmI.setI8(dataInharmI.getI8()); + influxDBDataInHarmI.setI9(dataInharmI.getI9()); + influxDBDataInHarmI.setI10(dataInharmI.getI10()); + influxDBDataInHarmI.setI11(dataInharmI.getI11()); + influxDBDataInHarmI.setI12(dataInharmI.getI12()); + influxDBDataInHarmI.setI13(dataInharmI.getI13()); + influxDBDataInHarmI.setI14(dataInharmI.getI14()); + influxDBDataInHarmI.setI15(dataInharmI.getI15()); + influxDBDataInHarmI.setI16(dataInharmI.getI16()); + influxDBDataInHarmI.setI17(dataInharmI.getI17()); + influxDBDataInHarmI.setI18(dataInharmI.getI18()); + influxDBDataInHarmI.setI19(dataInharmI.getI19()); + influxDBDataInHarmI.setI20(dataInharmI.getI20()); + influxDBDataInHarmI.setI21(dataInharmI.getI21()); + influxDBDataInHarmI.setI22(dataInharmI.getI22()); + influxDBDataInHarmI.setI23(dataInharmI.getI23()); + influxDBDataInHarmI.setI24(dataInharmI.getI24()); + influxDBDataInHarmI.setI25(dataInharmI.getI25()); + influxDBDataInHarmI.setI26(dataInharmI.getI26()); + influxDBDataInHarmI.setI27(dataInharmI.getI27()); + influxDBDataInHarmI.setI28(dataInharmI.getI28()); + influxDBDataInHarmI.setI29(dataInharmI.getI29()); + influxDBDataInHarmI.setI30(dataInharmI.getI30()); + influxDBDataInHarmI.setI31(dataInharmI.getI31()); + influxDBDataInHarmI.setI32(dataInharmI.getI32()); + influxDBDataInHarmI.setI33(dataInharmI.getI33()); + influxDBDataInHarmI.setI34(dataInharmI.getI34()); + influxDBDataInHarmI.setI35(dataInharmI.getI35()); + influxDBDataInHarmI.setI36(dataInharmI.getI36()); + influxDBDataInHarmI.setI37(dataInharmI.getI37()); + influxDBDataInHarmI.setI38(dataInharmI.getI38()); + influxDBDataInHarmI.setI39(dataInharmI.getI39()); + influxDBDataInHarmI.setI40(dataInharmI.getI40()); + influxDBDataInHarmI.setI41(dataInharmI.getI41()); + influxDBDataInHarmI.setI42(dataInharmI.getI42()); + influxDBDataInHarmI.setI43(dataInharmI.getI43()); + influxDBDataInHarmI.setI44(dataInharmI.getI44()); + influxDBDataInHarmI.setI45(dataInharmI.getI45()); + influxDBDataInHarmI.setI46(dataInharmI.getI46()); + influxDBDataInHarmI.setI47(dataInharmI.getI47()); + influxDBDataInHarmI.setI48(dataInharmI.getI48()); + influxDBDataInHarmI.setI49(dataInharmI.getI49()); + influxDBDataInHarmI.setI50(dataInharmI.getI50()); + } + else if (valueType.equals("MAX")){ + influxDBDataInHarmI.setI1(dataInharmI.getI1Max()); + influxDBDataInHarmI.setI2(dataInharmI.getI2Max()); + influxDBDataInHarmI.setI3(dataInharmI.getI3Max()); + influxDBDataInHarmI.setI4(dataInharmI.getI4Max()); + influxDBDataInHarmI.setI5(dataInharmI.getI5Max()); + influxDBDataInHarmI.setI6(dataInharmI.getI6Max()); + influxDBDataInHarmI.setI7(dataInharmI.getI7Max()); + influxDBDataInHarmI.setI8(dataInharmI.getI8Max()); + influxDBDataInHarmI.setI9(dataInharmI.getI9Max()); + influxDBDataInHarmI.setI10(dataInharmI.getI10Max()); + influxDBDataInHarmI.setI11(dataInharmI.getI11Max()); + influxDBDataInHarmI.setI12(dataInharmI.getI12Max()); + influxDBDataInHarmI.setI13(dataInharmI.getI13Max()); + influxDBDataInHarmI.setI14(dataInharmI.getI14Max()); + influxDBDataInHarmI.setI15(dataInharmI.getI15Max()); + influxDBDataInHarmI.setI16(dataInharmI.getI16Max()); + influxDBDataInHarmI.setI17(dataInharmI.getI17Max()); + influxDBDataInHarmI.setI18(dataInharmI.getI18Max()); + influxDBDataInHarmI.setI19(dataInharmI.getI19Max()); + influxDBDataInHarmI.setI20(dataInharmI.getI20Max()); + influxDBDataInHarmI.setI21(dataInharmI.getI21Max()); + influxDBDataInHarmI.setI22(dataInharmI.getI22Max()); + influxDBDataInHarmI.setI23(dataInharmI.getI23Max()); + influxDBDataInHarmI.setI24(dataInharmI.getI24Max()); + influxDBDataInHarmI.setI25(dataInharmI.getI25Max()); + influxDBDataInHarmI.setI26(dataInharmI.getI26Max()); + influxDBDataInHarmI.setI27(dataInharmI.getI27Max()); + influxDBDataInHarmI.setI28(dataInharmI.getI28Max()); + influxDBDataInHarmI.setI29(dataInharmI.getI29Max()); + influxDBDataInHarmI.setI30(dataInharmI.getI30Max()); + influxDBDataInHarmI.setI31(dataInharmI.getI31Max()); + influxDBDataInHarmI.setI32(dataInharmI.getI32Max()); + influxDBDataInHarmI.setI33(dataInharmI.getI33Max()); + influxDBDataInHarmI.setI34(dataInharmI.getI34Max()); + influxDBDataInHarmI.setI35(dataInharmI.getI35Max()); + influxDBDataInHarmI.setI36(dataInharmI.getI36Max()); + influxDBDataInHarmI.setI37(dataInharmI.getI37Max()); + influxDBDataInHarmI.setI38(dataInharmI.getI38Max()); + influxDBDataInHarmI.setI39(dataInharmI.getI39Max()); + influxDBDataInHarmI.setI40(dataInharmI.getI40Max()); + influxDBDataInHarmI.setI41(dataInharmI.getI41Max()); + influxDBDataInHarmI.setI42(dataInharmI.getI42Max()); + influxDBDataInHarmI.setI43(dataInharmI.getI43Max()); + influxDBDataInHarmI.setI44(dataInharmI.getI44Max()); + influxDBDataInHarmI.setI45(dataInharmI.getI45Max()); + influxDBDataInHarmI.setI46(dataInharmI.getI46Max()); + influxDBDataInHarmI.setI47(dataInharmI.getI47Max()); + influxDBDataInHarmI.setI48(dataInharmI.getI48Max()); + influxDBDataInHarmI.setI49(dataInharmI.getI49Max()); + influxDBDataInHarmI.setI50(dataInharmI.getI50Max()); + } + else if (valueType.equals("MIN")){ + influxDBDataInHarmI.setI1(dataInharmI.getI1Min()); + influxDBDataInHarmI.setI2(dataInharmI.getI2Min()); + influxDBDataInHarmI.setI3(dataInharmI.getI3Min()); + influxDBDataInHarmI.setI4(dataInharmI.getI4Min()); + influxDBDataInHarmI.setI5(dataInharmI.getI5Min()); + influxDBDataInHarmI.setI6(dataInharmI.getI6Min()); + influxDBDataInHarmI.setI7(dataInharmI.getI7Min()); + influxDBDataInHarmI.setI8(dataInharmI.getI8Min()); + influxDBDataInHarmI.setI9(dataInharmI.getI9Min()); + influxDBDataInHarmI.setI10(dataInharmI.getI10Min()); + influxDBDataInHarmI.setI11(dataInharmI.getI11Min()); + influxDBDataInHarmI.setI12(dataInharmI.getI12Min()); + influxDBDataInHarmI.setI13(dataInharmI.getI13Min()); + influxDBDataInHarmI.setI14(dataInharmI.getI14Min()); + influxDBDataInHarmI.setI15(dataInharmI.getI15Min()); + influxDBDataInHarmI.setI16(dataInharmI.getI16Min()); + influxDBDataInHarmI.setI17(dataInharmI.getI17Min()); + influxDBDataInHarmI.setI18(dataInharmI.getI18Min()); + influxDBDataInHarmI.setI19(dataInharmI.getI19Min()); + influxDBDataInHarmI.setI20(dataInharmI.getI20Min()); + influxDBDataInHarmI.setI21(dataInharmI.getI21Min()); + influxDBDataInHarmI.setI22(dataInharmI.getI22Min()); + influxDBDataInHarmI.setI23(dataInharmI.getI23Min()); + influxDBDataInHarmI.setI24(dataInharmI.getI24Min()); + influxDBDataInHarmI.setI25(dataInharmI.getI25Min()); + influxDBDataInHarmI.setI26(dataInharmI.getI26Min()); + influxDBDataInHarmI.setI27(dataInharmI.getI27Min()); + influxDBDataInHarmI.setI28(dataInharmI.getI28Min()); + influxDBDataInHarmI.setI29(dataInharmI.getI29Min()); + influxDBDataInHarmI.setI30(dataInharmI.getI30Min()); + influxDBDataInHarmI.setI31(dataInharmI.getI31Min()); + influxDBDataInHarmI.setI32(dataInharmI.getI32Min()); + influxDBDataInHarmI.setI33(dataInharmI.getI33Min()); + influxDBDataInHarmI.setI34(dataInharmI.getI34Min()); + influxDBDataInHarmI.setI35(dataInharmI.getI35Min()); + influxDBDataInHarmI.setI36(dataInharmI.getI36Min()); + influxDBDataInHarmI.setI37(dataInharmI.getI37Min()); + influxDBDataInHarmI.setI38(dataInharmI.getI38Min()); + influxDBDataInHarmI.setI39(dataInharmI.getI39Min()); + influxDBDataInHarmI.setI40(dataInharmI.getI40Min()); + influxDBDataInHarmI.setI41(dataInharmI.getI41Min()); + influxDBDataInHarmI.setI42(dataInharmI.getI42Min()); + influxDBDataInHarmI.setI43(dataInharmI.getI43Min()); + influxDBDataInHarmI.setI44(dataInharmI.getI44Min()); + influxDBDataInHarmI.setI45(dataInharmI.getI45Min()); + influxDBDataInHarmI.setI46(dataInharmI.getI46Min()); + influxDBDataInHarmI.setI47(dataInharmI.getI47Min()); + influxDBDataInHarmI.setI48(dataInharmI.getI48Min()); + influxDBDataInHarmI.setI49(dataInharmI.getI49Min()); + influxDBDataInHarmI.setI50(dataInharmI.getI50Min()); + } + else if (valueType.equals("CP95")){ + influxDBDataInHarmI.setI1(dataInharmI.getI1Cp95()); + influxDBDataInHarmI.setI2(dataInharmI.getI2Cp95()); + influxDBDataInHarmI.setI3(dataInharmI.getI3Cp95()); + influxDBDataInHarmI.setI4(dataInharmI.getI4Cp95()); + influxDBDataInHarmI.setI5(dataInharmI.getI5Cp95()); + influxDBDataInHarmI.setI6(dataInharmI.getI6Cp95()); + influxDBDataInHarmI.setI7(dataInharmI.getI7Cp95()); + influxDBDataInHarmI.setI8(dataInharmI.getI8Cp95()); + influxDBDataInHarmI.setI9(dataInharmI.getI9Cp95()); + influxDBDataInHarmI.setI10(dataInharmI.getI10Cp95()); + influxDBDataInHarmI.setI11(dataInharmI.getI11Cp95()); + influxDBDataInHarmI.setI12(dataInharmI.getI12Cp95()); + influxDBDataInHarmI.setI13(dataInharmI.getI13Cp95()); + influxDBDataInHarmI.setI14(dataInharmI.getI14Cp95()); + influxDBDataInHarmI.setI15(dataInharmI.getI15Cp95()); + influxDBDataInHarmI.setI16(dataInharmI.getI16Cp95()); + influxDBDataInHarmI.setI17(dataInharmI.getI17Cp95()); + influxDBDataInHarmI.setI18(dataInharmI.getI18Cp95()); + influxDBDataInHarmI.setI19(dataInharmI.getI19Cp95()); + influxDBDataInHarmI.setI20(dataInharmI.getI20Cp95()); + influxDBDataInHarmI.setI21(dataInharmI.getI21Cp95()); + influxDBDataInHarmI.setI22(dataInharmI.getI22Cp95()); + influxDBDataInHarmI.setI23(dataInharmI.getI23Cp95()); + influxDBDataInHarmI.setI24(dataInharmI.getI24Cp95()); + influxDBDataInHarmI.setI25(dataInharmI.getI25Cp95()); + influxDBDataInHarmI.setI26(dataInharmI.getI26Cp95()); + influxDBDataInHarmI.setI27(dataInharmI.getI27Cp95()); + influxDBDataInHarmI.setI28(dataInharmI.getI28Cp95()); + influxDBDataInHarmI.setI29(dataInharmI.getI29Cp95()); + influxDBDataInHarmI.setI30(dataInharmI.getI30Cp95()); + influxDBDataInHarmI.setI31(dataInharmI.getI31Cp95()); + influxDBDataInHarmI.setI32(dataInharmI.getI32Cp95()); + influxDBDataInHarmI.setI33(dataInharmI.getI33Cp95()); + influxDBDataInHarmI.setI34(dataInharmI.getI34Cp95()); + influxDBDataInHarmI.setI35(dataInharmI.getI35Cp95()); + influxDBDataInHarmI.setI36(dataInharmI.getI36Cp95()); + influxDBDataInHarmI.setI37(dataInharmI.getI37Cp95()); + influxDBDataInHarmI.setI38(dataInharmI.getI38Cp95()); + influxDBDataInHarmI.setI39(dataInharmI.getI39Cp95()); + influxDBDataInHarmI.setI40(dataInharmI.getI40Cp95()); + influxDBDataInHarmI.setI41(dataInharmI.getI41Cp95()); + influxDBDataInHarmI.setI42(dataInharmI.getI42Cp95()); + influxDBDataInHarmI.setI43(dataInharmI.getI43Cp95()); + influxDBDataInHarmI.setI44(dataInharmI.getI44Cp95()); + influxDBDataInHarmI.setI45(dataInharmI.getI45Cp95()); + influxDBDataInHarmI.setI46(dataInharmI.getI46Cp95()); + influxDBDataInHarmI.setI47(dataInharmI.getI47Cp95()); + influxDBDataInHarmI.setI48(dataInharmI.getI48Cp95()); + influxDBDataInHarmI.setI49(dataInharmI.getI49Cp95()); + influxDBDataInHarmI.setI50(dataInharmI.getI50Cp95()); + } + + influxDBDataInHarmIList.add(influxDBDataInHarmI); + + } + + + + return influxDBDataInHarmIList; + } + + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataInHarmV.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataInHarmV.java new file mode 100644 index 0000000..79563c5 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataInHarmV.java @@ -0,0 +1,429 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataInharmV; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 11:27 + */ +@Data +@Measurement(name = "data_inharm_v") +public class InfluxDBDataInHarmV { + + @Column(name = "time",tag =true) + @TimeColumn + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag") + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "v_1") + private Float v1; + + @Column(name = "v_2") + private Float v2; + + @Column(name = "v_3") + private Float v3; + + @Column(name = "v_4") + private Float v4; + + @Column(name = "v_5") + private Float v5; + + @Column(name = "v_6") + private Float v6; + + @Column(name = "v_7") + private Float v7; + + @Column(name = "v_8") + private Float v8; + + @Column(name = "v_9") + private Float v9; + + @Column(name = "v_10") + private Float v10; + + @Column(name = "v_11") + private Float v11; + + @Column(name = "v_12") + private Float v12; + + @Column(name = "v_13") + private Float v13; + + @Column(name = "v_14") + private Float v14; + + @Column(name = "v_15") + private Float v15; + + @Column(name = "v_16") + private Float v16; + + @Column(name = "v_17") + private Float v17; + + @Column(name = "v_18") + private Float v18; + + @Column(name = "v_19") + private Float v19; + + @Column(name = "v_20") + private Float v20; + + @Column(name = "v_21") + private Float v21; + + @Column(name = "v_22") + private Float v22; + + @Column(name = "v_23") + private Float v23; + + @Column(name = "v_24") + private Float v24; + + @Column(name = "v_25") + private Float v25; + + @Column(name = "v_26") + private Float v26; + + @Column(name = "v_27") + private Float v27; + + @Column(name = "v_28") + private Float v28; + + @Column(name = "v_29") + private Float v29; + + @Column(name = "v_30") + private Float v30; + + @Column(name = "v_31") + private Float v31; + + @Column(name = "v_32") + private Float v32; + + @Column(name = "v_33") + private Float v33; + + @Column(name = "v_34") + private Float v34; + + @Column(name = "v_35") + private Float v35; + + @Column(name = "v_36") + private Float v36; + + @Column(name = "v_37") + private Float v37; + + @Column(name = "v_38") + private Float v38; + + @Column(name = "v_39") + private Float v39; + + @Column(name = "v_40") + private Float v40; + + @Column(name = "v_41") + private Float v41; + + @Column(name = "v_42") + private Float v42; + + @Column(name = "v_43") + private Float v43; + + @Column(name = "v_44") + private Float v44; + + @Column(name = "v_45") + private Float v45; + + @Column(name = "v_46") + private Float v46; + + @Column(name = "v_47") + private Float v47; + + @Column(name = "v_48") + private Float v48; + + @Column(name = "v_49") + private Float v49; + + @Column(name = "v_50") + private Float v50; + + public static List oralceToInfluxDB(DataInharmV dataInharmV) { + if (dataInharmV == null) { + return null; + } + List influxDBDataInHarmVList = new ArrayList<>(); + List valueTypeList = Stream.of("AVG", "MAX", "MIN", "CP95").collect(Collectors.toList()); + for (String valueType : valueTypeList) { + InfluxDBDataInHarmV influxDBDataInHarmV = new InfluxDBDataInHarmV(); + Instant instant = dataInharmV.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataInHarmV.setTime(instant); + influxDBDataInHarmV.setLineId(dataInharmV.getLineid()+""); + influxDBDataInHarmV.setPhaseType(dataInharmV.getPhasicType()); + influxDBDataInHarmV.setQualityFlag(dataInharmV.getQualityflag()+""); + influxDBDataInHarmV.setValueType(valueType); + if (valueType.equals("AVG")) { + influxDBDataInHarmV.setV1(dataInharmV.getV1()); + influxDBDataInHarmV.setV2(dataInharmV.getV2()); + influxDBDataInHarmV.setV3(dataInharmV.getV3()); + influxDBDataInHarmV.setV4(dataInharmV.getV4()); + influxDBDataInHarmV.setV5(dataInharmV.getV5()); + influxDBDataInHarmV.setV6(dataInharmV.getV6()); + influxDBDataInHarmV.setV7(dataInharmV.getV7()); + influxDBDataInHarmV.setV8(dataInharmV.getV8()); + influxDBDataInHarmV.setV9(dataInharmV.getV9()); + influxDBDataInHarmV.setV10(dataInharmV.getV10()); + influxDBDataInHarmV.setV11(dataInharmV.getV11()); + influxDBDataInHarmV.setV12(dataInharmV.getV12()); + influxDBDataInHarmV.setV13(dataInharmV.getV13()); + influxDBDataInHarmV.setV14(dataInharmV.getV14()); + influxDBDataInHarmV.setV15(dataInharmV.getV15()); + influxDBDataInHarmV.setV16(dataInharmV.getV16()); + influxDBDataInHarmV.setV17(dataInharmV.getV17()); + influxDBDataInHarmV.setV18(dataInharmV.getV18()); + influxDBDataInHarmV.setV19(dataInharmV.getV19()); + influxDBDataInHarmV.setV20(dataInharmV.getV20()); + influxDBDataInHarmV.setV21(dataInharmV.getV21()); + influxDBDataInHarmV.setV22(dataInharmV.getV22()); + influxDBDataInHarmV.setV23(dataInharmV.getV23()); + influxDBDataInHarmV.setV24(dataInharmV.getV24()); + influxDBDataInHarmV.setV25(dataInharmV.getV25()); + influxDBDataInHarmV.setV26(dataInharmV.getV26()); + influxDBDataInHarmV.setV27(dataInharmV.getV27()); + influxDBDataInHarmV.setV28(dataInharmV.getV28()); + influxDBDataInHarmV.setV29(dataInharmV.getV29()); + influxDBDataInHarmV.setV30(dataInharmV.getV30()); + influxDBDataInHarmV.setV31(dataInharmV.getV31()); + influxDBDataInHarmV.setV32(dataInharmV.getV32()); + influxDBDataInHarmV.setV33(dataInharmV.getV33()); + influxDBDataInHarmV.setV34(dataInharmV.getV34()); + influxDBDataInHarmV.setV35(dataInharmV.getV35()); + influxDBDataInHarmV.setV36(dataInharmV.getV36()); + influxDBDataInHarmV.setV37(dataInharmV.getV37()); + influxDBDataInHarmV.setV38(dataInharmV.getV38()); + influxDBDataInHarmV.setV39(dataInharmV.getV39()); + influxDBDataInHarmV.setV40(dataInharmV.getV40()); + influxDBDataInHarmV.setV41(dataInharmV.getV41()); + influxDBDataInHarmV.setV42(dataInharmV.getV42()); + influxDBDataInHarmV.setV43(dataInharmV.getV43()); + influxDBDataInHarmV.setV44(dataInharmV.getV44()); + influxDBDataInHarmV.setV45(dataInharmV.getV45()); + influxDBDataInHarmV.setV46(dataInharmV.getV46()); + influxDBDataInHarmV.setV47(dataInharmV.getV47()); + influxDBDataInHarmV.setV48(dataInharmV.getV48()); + influxDBDataInHarmV.setV49(dataInharmV.getV49()); + influxDBDataInHarmV.setV50(dataInharmV.getV50()); + } + else if (valueType.equals("MAX")){ + influxDBDataInHarmV.setV1(dataInharmV.getV1Max()); + influxDBDataInHarmV.setV2(dataInharmV.getV2Max()); + influxDBDataInHarmV.setV3(dataInharmV.getV3Max()); + influxDBDataInHarmV.setV4(dataInharmV.getV4Max()); + influxDBDataInHarmV.setV5(dataInharmV.getV5Max()); + influxDBDataInHarmV.setV6(dataInharmV.getV6Max()); + influxDBDataInHarmV.setV7(dataInharmV.getV7Max()); + influxDBDataInHarmV.setV8(dataInharmV.getV8Max()); + influxDBDataInHarmV.setV9(dataInharmV.getV9Max()); + influxDBDataInHarmV.setV10(dataInharmV.getV10Max()); + influxDBDataInHarmV.setV11(dataInharmV.getV11Max()); + influxDBDataInHarmV.setV12(dataInharmV.getV12Max()); + influxDBDataInHarmV.setV13(dataInharmV.getV13Max()); + influxDBDataInHarmV.setV14(dataInharmV.getV14Max()); + influxDBDataInHarmV.setV15(dataInharmV.getV15Max()); + influxDBDataInHarmV.setV16(dataInharmV.getV16Max()); + influxDBDataInHarmV.setV17(dataInharmV.getV17Max()); + influxDBDataInHarmV.setV18(dataInharmV.getV18Max()); + influxDBDataInHarmV.setV19(dataInharmV.getV19Max()); + influxDBDataInHarmV.setV20(dataInharmV.getV20Max()); + influxDBDataInHarmV.setV21(dataInharmV.getV21Max()); + influxDBDataInHarmV.setV22(dataInharmV.getV22Max()); + influxDBDataInHarmV.setV23(dataInharmV.getV23Max()); + influxDBDataInHarmV.setV24(dataInharmV.getV24Max()); + influxDBDataInHarmV.setV25(dataInharmV.getV25Max()); + influxDBDataInHarmV.setV26(dataInharmV.getV26Max()); + influxDBDataInHarmV.setV27(dataInharmV.getV27Max()); + influxDBDataInHarmV.setV28(dataInharmV.getV28Max()); + influxDBDataInHarmV.setV29(dataInharmV.getV29Max()); + influxDBDataInHarmV.setV30(dataInharmV.getV30Max()); + influxDBDataInHarmV.setV31(dataInharmV.getV31Max()); + influxDBDataInHarmV.setV32(dataInharmV.getV32Max()); + influxDBDataInHarmV.setV33(dataInharmV.getV33Max()); + influxDBDataInHarmV.setV34(dataInharmV.getV34Max()); + influxDBDataInHarmV.setV35(dataInharmV.getV35Max()); + influxDBDataInHarmV.setV36(dataInharmV.getV36Max()); + influxDBDataInHarmV.setV37(dataInharmV.getV37Max()); + influxDBDataInHarmV.setV38(dataInharmV.getV38Max()); + influxDBDataInHarmV.setV39(dataInharmV.getV39Max()); + influxDBDataInHarmV.setV40(dataInharmV.getV40Max()); + influxDBDataInHarmV.setV41(dataInharmV.getV41Max()); + influxDBDataInHarmV.setV42(dataInharmV.getV42Max()); + influxDBDataInHarmV.setV43(dataInharmV.getV43Max()); + influxDBDataInHarmV.setV44(dataInharmV.getV44Max()); + influxDBDataInHarmV.setV45(dataInharmV.getV45Max()); + influxDBDataInHarmV.setV46(dataInharmV.getV46Max()); + influxDBDataInHarmV.setV47(dataInharmV.getV47Max()); + influxDBDataInHarmV.setV48(dataInharmV.getV48Max()); + influxDBDataInHarmV.setV49(dataInharmV.getV49Max()); + influxDBDataInHarmV.setV50(dataInharmV.getV50Max()); + } + else if (valueType.equals("MIN")){ + influxDBDataInHarmV.setV1(dataInharmV.getV1Min()); + influxDBDataInHarmV.setV2(dataInharmV.getV2Min()); + influxDBDataInHarmV.setV3(dataInharmV.getV3Min()); + influxDBDataInHarmV.setV4(dataInharmV.getV4Min()); + influxDBDataInHarmV.setV5(dataInharmV.getV5Min()); + influxDBDataInHarmV.setV6(dataInharmV.getV6Min()); + influxDBDataInHarmV.setV7(dataInharmV.getV7Min()); + influxDBDataInHarmV.setV8(dataInharmV.getV8Min()); + influxDBDataInHarmV.setV9(dataInharmV.getV9Min()); + influxDBDataInHarmV.setV10(dataInharmV.getV10Min()); + influxDBDataInHarmV.setV11(dataInharmV.getV11Min()); + influxDBDataInHarmV.setV12(dataInharmV.getV12Min()); + influxDBDataInHarmV.setV13(dataInharmV.getV13Min()); + influxDBDataInHarmV.setV14(dataInharmV.getV14Min()); + influxDBDataInHarmV.setV15(dataInharmV.getV15Min()); + influxDBDataInHarmV.setV16(dataInharmV.getV16Min()); + influxDBDataInHarmV.setV17(dataInharmV.getV17Min()); + influxDBDataInHarmV.setV18(dataInharmV.getV18Min()); + influxDBDataInHarmV.setV19(dataInharmV.getV19Min()); + influxDBDataInHarmV.setV20(dataInharmV.getV20Min()); + influxDBDataInHarmV.setV21(dataInharmV.getV21Min()); + influxDBDataInHarmV.setV22(dataInharmV.getV22Min()); + influxDBDataInHarmV.setV23(dataInharmV.getV23Min()); + influxDBDataInHarmV.setV24(dataInharmV.getV24Min()); + influxDBDataInHarmV.setV25(dataInharmV.getV25Min()); + influxDBDataInHarmV.setV26(dataInharmV.getV26Min()); + influxDBDataInHarmV.setV27(dataInharmV.getV27Min()); + influxDBDataInHarmV.setV28(dataInharmV.getV28Min()); + influxDBDataInHarmV.setV29(dataInharmV.getV29Min()); + influxDBDataInHarmV.setV30(dataInharmV.getV30Min()); + influxDBDataInHarmV.setV31(dataInharmV.getV31Min()); + influxDBDataInHarmV.setV32(dataInharmV.getV32Min()); + influxDBDataInHarmV.setV33(dataInharmV.getV33Min()); + influxDBDataInHarmV.setV34(dataInharmV.getV34Min()); + influxDBDataInHarmV.setV35(dataInharmV.getV35Min()); + influxDBDataInHarmV.setV36(dataInharmV.getV36Min()); + influxDBDataInHarmV.setV37(dataInharmV.getV37Min()); + influxDBDataInHarmV.setV38(dataInharmV.getV38Min()); + influxDBDataInHarmV.setV39(dataInharmV.getV39Min()); + influxDBDataInHarmV.setV40(dataInharmV.getV40Min()); + influxDBDataInHarmV.setV41(dataInharmV.getV41Min()); + influxDBDataInHarmV.setV42(dataInharmV.getV42Min()); + influxDBDataInHarmV.setV43(dataInharmV.getV43Min()); + influxDBDataInHarmV.setV44(dataInharmV.getV44Min()); + influxDBDataInHarmV.setV45(dataInharmV.getV45Min()); + influxDBDataInHarmV.setV46(dataInharmV.getV46Min()); + influxDBDataInHarmV.setV47(dataInharmV.getV47Min()); + influxDBDataInHarmV.setV48(dataInharmV.getV48Min()); + influxDBDataInHarmV.setV49(dataInharmV.getV49Min()); + influxDBDataInHarmV.setV50(dataInharmV.getV50Min()); + } + else if (valueType.equals("CP95")){ + influxDBDataInHarmV.setV1(dataInharmV.getV1Cp95()); + influxDBDataInHarmV.setV2(dataInharmV.getV2Cp95()); + influxDBDataInHarmV.setV3(dataInharmV.getV3Cp95()); + influxDBDataInHarmV.setV4(dataInharmV.getV4Cp95()); + influxDBDataInHarmV.setV5(dataInharmV.getV5Cp95()); + influxDBDataInHarmV.setV6(dataInharmV.getV6Cp95()); + influxDBDataInHarmV.setV7(dataInharmV.getV7Cp95()); + influxDBDataInHarmV.setV8(dataInharmV.getV8Cp95()); + influxDBDataInHarmV.setV9(dataInharmV.getV9Cp95()); + influxDBDataInHarmV.setV10(dataInharmV.getV10Cp95()); + influxDBDataInHarmV.setV11(dataInharmV.getV11Cp95()); + influxDBDataInHarmV.setV12(dataInharmV.getV12Cp95()); + influxDBDataInHarmV.setV13(dataInharmV.getV13Cp95()); + influxDBDataInHarmV.setV14(dataInharmV.getV14Cp95()); + influxDBDataInHarmV.setV15(dataInharmV.getV15Cp95()); + influxDBDataInHarmV.setV16(dataInharmV.getV16Cp95()); + influxDBDataInHarmV.setV17(dataInharmV.getV17Cp95()); + influxDBDataInHarmV.setV18(dataInharmV.getV18Cp95()); + influxDBDataInHarmV.setV19(dataInharmV.getV19Cp95()); + influxDBDataInHarmV.setV20(dataInharmV.getV20Cp95()); + influxDBDataInHarmV.setV21(dataInharmV.getV21Cp95()); + influxDBDataInHarmV.setV22(dataInharmV.getV22Cp95()); + influxDBDataInHarmV.setV23(dataInharmV.getV23Cp95()); + influxDBDataInHarmV.setV24(dataInharmV.getV24Cp95()); + influxDBDataInHarmV.setV25(dataInharmV.getV25Cp95()); + influxDBDataInHarmV.setV26(dataInharmV.getV26Cp95()); + influxDBDataInHarmV.setV27(dataInharmV.getV27Cp95()); + influxDBDataInHarmV.setV28(dataInharmV.getV28Cp95()); + influxDBDataInHarmV.setV29(dataInharmV.getV29Cp95()); + influxDBDataInHarmV.setV30(dataInharmV.getV30Cp95()); + influxDBDataInHarmV.setV31(dataInharmV.getV31Cp95()); + influxDBDataInHarmV.setV32(dataInharmV.getV32Cp95()); + influxDBDataInHarmV.setV33(dataInharmV.getV33Cp95()); + influxDBDataInHarmV.setV34(dataInharmV.getV34Cp95()); + influxDBDataInHarmV.setV35(dataInharmV.getV35Cp95()); + influxDBDataInHarmV.setV36(dataInharmV.getV36Cp95()); + influxDBDataInHarmV.setV37(dataInharmV.getV37Cp95()); + influxDBDataInHarmV.setV38(dataInharmV.getV38Cp95()); + influxDBDataInHarmV.setV39(dataInharmV.getV39Cp95()); + influxDBDataInHarmV.setV40(dataInharmV.getV40Cp95()); + influxDBDataInHarmV.setV41(dataInharmV.getV41Cp95()); + influxDBDataInHarmV.setV42(dataInharmV.getV42Cp95()); + influxDBDataInHarmV.setV43(dataInharmV.getV43Cp95()); + influxDBDataInHarmV.setV44(dataInharmV.getV44Cp95()); + influxDBDataInHarmV.setV45(dataInharmV.getV45Cp95()); + influxDBDataInHarmV.setV46(dataInharmV.getV46Cp95()); + influxDBDataInHarmV.setV47(dataInharmV.getV47Cp95()); + influxDBDataInHarmV.setV48(dataInharmV.getV48Cp95()); + influxDBDataInHarmV.setV49(dataInharmV.getV49Cp95()); + influxDBDataInHarmV.setV50(dataInharmV.getV50Cp95()); + } + + influxDBDataInHarmVList.add(influxDBDataInHarmV); + + } + + + + return influxDBDataInHarmVList; + } + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataPlt.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataPlt.java new file mode 100644 index 0000000..30ad3f1 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataPlt.java @@ -0,0 +1,61 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataPlt; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.ZoneId; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/4/12 16:01 + */ +@Data +@Measurement(name = "data_plt") +public class InfluxDBDataPlt { + + @Column(name = "time",tag =true) + @TimeColumn + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag") + private String qualityFlag; + + @Column(name = "plt") + private Float plt; + + public static InfluxDBDataPlt oralceToInfluxDB(DataPlt dataPlt) { + if (dataPlt == null) { + return null; + } + InfluxDBDataPlt influxDBDataPlt = new InfluxDBDataPlt(); + + Instant instant = dataPlt.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataPlt.setTime(instant); + influxDBDataPlt.setLineId(dataPlt.getLineid()+""); + influxDBDataPlt.setPhaseType(dataPlt.getPhasicType()); + influxDBDataPlt.setPlt(dataPlt.getPlt()); + influxDBDataPlt.setQualityFlag(dataPlt.getQualityflag()+""); + + + return influxDBDataPlt; + } + + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataV.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataV.java new file mode 100644 index 0000000..ec5ce14 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDataV.java @@ -0,0 +1,577 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DataV; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; +import org.springframework.beans.BeanUtils; + +import java.time.Instant; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/4/7 10:00 + */ +@Data +@Measurement(name = "data_v") +public class InfluxDBDataV { + + @Column(name = "time",tag =true) + @TimeColumn + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phasicType; + + @Column(name = "value_type",tag = true) + private String valueType; + + + @Column(name = "v_neg") + private Float vNeg; + + @Column(name = "v_pos") + private Float vPos; + + @Column(name = "v_thd") + private Float vThd; + + @Column(name = "v_unbalance") + private Float vUnbalance; + + @Column(name = "v_zero") + private Float vZero; + + + @Column(name = "freq") + private Float freq; + + @Column(name = "freq_dev") + private Float freqDev; + + @Column(name = "quality_flag") + private String qualityFlag; + + @Column(name = "rms") + private Float rms; + + @Column(name = "rms_lvr") + private Float rmsLvr; + + @Column(name = "vl_dev") + private Float vlDev; + + @Column(name = "vu_dev") + private Float vuDev; + + + @Column(name = "v_1") + private Float v1; + + @Column(name = "v_2") + private Float v2; + + @Column(name = "v_3") + private Float v3; + + @Column(name = "v_4") + private Float v4; + + @Column(name = "v_5") + private Float v5; + + @Column(name = "v_6") + private Float v6; + + @Column(name = "v_7") + private Float v7; + + @Column(name = "v_8") + private Float v8; + + @Column(name = "v_9") + private Float v9; + + @Column(name = "v_10") + private Float v10; + + @Column(name = "v_11") + private Float v11; + + @Column(name = "v_12") + private Float v12; + + @Column(name = "v_13") + private Float v13; + + @Column(name = "v_14") + private Float v14; + + @Column(name = "v_15") + private Float v15; + + @Column(name = "v_16") + private Float v16; + + @Column(name = "v_17") + private Float v17; + + @Column(name = "v_18") + private Float v18; + + @Column(name = "v_19") + private Float v19; + + @Column(name = "v_20") + private Float v20; + + @Column(name = "v_21") + private Float v21; + + @Column(name = "v_22") + private Float v22; + + @Column(name = "v_23") + private Float v23; + + @Column(name = "v_24") + private Float v24; + + @Column(name = "v_25") + private Float v25; + + @Column(name = "v_26") + private Float v26; + + @Column(name = "v_27") + private Float v27; + + @Column(name = "v_28") + private Float v28; + + @Column(name = "v_29") + private Float v29; + + @Column(name = "v_30") + private Float v30; + + @Column(name = "v_31") + private Float v31; + + @Column(name = "v_32") + private Float v32; + + @Column(name = "v_33") + private Float v33; + + @Column(name = "v_34") + private Float v34; + + @Column(name = "v_35") + private Float v35; + + @Column(name = "v_36") + private Float v36; + + @Column(name = "v_37") + private Float v37; + + @Column(name = "v_38") + private Float v38; + + @Column(name = "v_39") + private Float v39; + + @Column(name = "v_40") + private Float v40; + + @Column(name = "v_41") + private Float v41; + + @Column(name = "v_42") + private Float v42; + + @Column(name = "v_43") + private Float v43; + + @Column(name = "v_44") + private Float v44; + + @Column(name = "v_45") + private Float v45; + + @Column(name = "v_46") + private Float v46; + + @Column(name = "v_47") + private Float v47; + + @Column(name = "v_48") + private Float v48; + + @Column(name = "v_49") + private Float v49; + + @Column(name = "v_50") + private Float v50; + + public static List oralceToInfluxDB(DataV dataV) { + if (dataV == null) { + return null; + } + + List influxDBDataVList = new ArrayList<>(); + List valueTypeList = Stream.of("AVG", "MAX", "MIN", "CP95").collect(Collectors.toList()); + for (String valueType : valueTypeList) { + InfluxDBDataV influxDBDataV = new InfluxDBDataV(); + Instant instant = dataV.getTimeid().atZone(ZoneId.systemDefault()).toInstant(); + + influxDBDataV.setTime(instant); + influxDBDataV.setLineId(dataV.getLineid()+""); + influxDBDataV.setPhasicType(dataV.getPhasicType()); + influxDBDataV.setQualityFlag(dataV.getQualityflag()+""); + influxDBDataV.setValueType(valueType); + //T相时处理setRmsLvr + if(Objects.equals(dataV.getPhasicType(),"T")){ + + InfluxDBDataV influxDBDataVA = new InfluxDBDataV(); + BeanUtils.copyProperties(influxDBDataV,influxDBDataVA); + InfluxDBDataV influxDBDataVB = new InfluxDBDataV(); + BeanUtils.copyProperties(influxDBDataV,influxDBDataVB); + InfluxDBDataV influxDBDataVC = new InfluxDBDataV(); + BeanUtils.copyProperties(influxDBDataV,influxDBDataVC); + influxDBDataVA.setPhasicType("A"); + influxDBDataVB.setPhasicType("B"); + influxDBDataVC.setPhasicType("C"); + + + + + if (valueType.equals("AVG")) { + influxDBDataVA.setRmsLvr(dataV.getRmsab()); + + influxDBDataVB.setRmsLvr(dataV.getRmsbc()); + + influxDBDataVC.setRmsLvr(dataV.getRmsca()); + } + else if (valueType.equals("MAX")){ + influxDBDataVA.setRmsLvr(dataV.getRmsabMax()); + + influxDBDataVB.setRmsLvr(dataV.getRmsbcMax()); + + influxDBDataVC.setRmsLvr(dataV.getRmscaMax()); + + } + else if (valueType.equals("MIN")){ + influxDBDataVA.setRmsLvr(dataV.getRmsabMin()); + influxDBDataVB.setRmsLvr(dataV.getRmsbcMin()); + influxDBDataVC.setRmsLvr(dataV.getRmscaMin()); + + } + else if (valueType.equals("CP95")){ + influxDBDataVA.setRmsLvr(dataV.getRmsabCp95()); + + influxDBDataVB.setRmsLvr(dataV.getRmsbcCp95()); + + influxDBDataVC.setRmsLvr(dataV.getRmscaCp95()); + } + influxDBDataVList.add(influxDBDataVA); + influxDBDataVList.add(influxDBDataVB); + influxDBDataVList.add(influxDBDataVC); + + + }else { + if (valueType.equals("AVG")) { + + influxDBDataV.setVNeg(dataV.getVNeg()); + influxDBDataV.setVPos(dataV.getVPos()); + influxDBDataV.setVThd(dataV.getVThd()); + influxDBDataV.setVUnbalance(dataV.getVUnbalance()); + influxDBDataV.setVZero(dataV.getVZero()); + influxDBDataV.setFreq(dataV.getFreq()); + influxDBDataV.setFreqDev(dataV.getFreqDev()); + influxDBDataV.setRms(dataV.getRms()); + influxDBDataV.setRmsLvr(dataV.getRmsab()); + influxDBDataV.setVlDev(dataV.getVlDev()); + influxDBDataV.setVuDev(dataV.getVuDev()); + + + + + influxDBDataV.setV1(dataV.getV1()); + influxDBDataV.setV2(dataV.getV2()); + influxDBDataV.setV3(dataV.getV3()); + influxDBDataV.setV4(dataV.getV4()); + influxDBDataV.setV5(dataV.getV5()); + influxDBDataV.setV6(dataV.getV6()); + influxDBDataV.setV7(dataV.getV7()); + influxDBDataV.setV8(dataV.getV8()); + influxDBDataV.setV9(dataV.getV9()); + influxDBDataV.setV10(dataV.getV10()); + influxDBDataV.setV11(dataV.getV11()); + influxDBDataV.setV12(dataV.getV12()); + influxDBDataV.setV13(dataV.getV13()); + influxDBDataV.setV14(dataV.getV14()); + influxDBDataV.setV15(dataV.getV15()); + influxDBDataV.setV16(dataV.getV16()); + influxDBDataV.setV17(dataV.getV17()); + influxDBDataV.setV18(dataV.getV18()); + influxDBDataV.setV19(dataV.getV19()); + influxDBDataV.setV20(dataV.getV20()); + influxDBDataV.setV21(dataV.getV21()); + influxDBDataV.setV22(dataV.getV22()); + influxDBDataV.setV23(dataV.getV23()); + influxDBDataV.setV24(dataV.getV24()); + influxDBDataV.setV25(dataV.getV25()); + influxDBDataV.setV26(dataV.getV26()); + influxDBDataV.setV27(dataV.getV27()); + influxDBDataV.setV28(dataV.getV28()); + influxDBDataV.setV29(dataV.getV29()); + influxDBDataV.setV30(dataV.getV30()); + influxDBDataV.setV31(dataV.getV31()); + influxDBDataV.setV32(dataV.getV32()); + influxDBDataV.setV33(dataV.getV33()); + influxDBDataV.setV34(dataV.getV34()); + influxDBDataV.setV35(dataV.getV35()); + influxDBDataV.setV36(dataV.getV36()); + influxDBDataV.setV37(dataV.getV37()); + influxDBDataV.setV38(dataV.getV38()); + influxDBDataV.setV39(dataV.getV39()); + influxDBDataV.setV40(dataV.getV40()); + influxDBDataV.setV41(dataV.getV41()); + influxDBDataV.setV42(dataV.getV42()); + influxDBDataV.setV43(dataV.getV43()); + influxDBDataV.setV44(dataV.getV44()); + influxDBDataV.setV45(dataV.getV45()); + influxDBDataV.setV46(dataV.getV46()); + influxDBDataV.setV47(dataV.getV47()); + influxDBDataV.setV48(dataV.getV48()); + influxDBDataV.setV49(dataV.getV49()); + influxDBDataV.setV50(dataV.getV50()); + } + else if (valueType.equals("MAX")){ + + influxDBDataV.setVNeg(dataV.getVNegMax()); + influxDBDataV.setVPos(dataV.getVPosMax()); + influxDBDataV.setVThd(dataV.getVThdMax()); + influxDBDataV.setVUnbalance(dataV.getVUnbalanceMax()); + influxDBDataV.setVZero(dataV.getVZeroMax()); + influxDBDataV.setFreq(dataV.getFreqMax()); + influxDBDataV.setFreqDev(dataV.getFreqDevMax()); + influxDBDataV.setRms(dataV.getRmsMax()); + influxDBDataV.setVlDev(dataV.getVlDevMax()); + influxDBDataV.setVuDev(dataV.getVuDevMax()); + + influxDBDataV.setV1(dataV.getV1Max()); + influxDBDataV.setV2(dataV.getV2Max()); + influxDBDataV.setV3(dataV.getV3Max()); + influxDBDataV.setV4(dataV.getV4Max()); + influxDBDataV.setV5(dataV.getV5Max()); + influxDBDataV.setV6(dataV.getV6Max()); + influxDBDataV.setV7(dataV.getV7Max()); + influxDBDataV.setV8(dataV.getV8Max()); + influxDBDataV.setV9(dataV.getV9Max()); + influxDBDataV.setV10(dataV.getV10Max()); + influxDBDataV.setV11(dataV.getV11Max()); + influxDBDataV.setV12(dataV.getV12Max()); + influxDBDataV.setV13(dataV.getV13Max()); + influxDBDataV.setV14(dataV.getV14Max()); + influxDBDataV.setV15(dataV.getV15Max()); + influxDBDataV.setV16(dataV.getV16Max()); + influxDBDataV.setV17(dataV.getV17Max()); + influxDBDataV.setV18(dataV.getV18Max()); + influxDBDataV.setV19(dataV.getV19Max()); + influxDBDataV.setV20(dataV.getV20Max()); + influxDBDataV.setV21(dataV.getV21Max()); + influxDBDataV.setV22(dataV.getV22Max()); + influxDBDataV.setV23(dataV.getV23Max()); + influxDBDataV.setV24(dataV.getV24Max()); + influxDBDataV.setV25(dataV.getV25Max()); + influxDBDataV.setV26(dataV.getV26Max()); + influxDBDataV.setV27(dataV.getV27Max()); + influxDBDataV.setV28(dataV.getV28Max()); + influxDBDataV.setV29(dataV.getV29Max()); + influxDBDataV.setV30(dataV.getV30Max()); + influxDBDataV.setV31(dataV.getV31Max()); + influxDBDataV.setV32(dataV.getV32Max()); + influxDBDataV.setV33(dataV.getV33Max()); + influxDBDataV.setV34(dataV.getV34Max()); + influxDBDataV.setV35(dataV.getV35Max()); + influxDBDataV.setV36(dataV.getV36Max()); + influxDBDataV.setV37(dataV.getV37Max()); + influxDBDataV.setV38(dataV.getV38Max()); + influxDBDataV.setV39(dataV.getV39Max()); + influxDBDataV.setV40(dataV.getV40Max()); + influxDBDataV.setV41(dataV.getV41Max()); + influxDBDataV.setV42(dataV.getV42Max()); + influxDBDataV.setV43(dataV.getV43Max()); + influxDBDataV.setV44(dataV.getV44Max()); + influxDBDataV.setV45(dataV.getV45Max()); + influxDBDataV.setV46(dataV.getV46Max()); + influxDBDataV.setV47(dataV.getV47Max()); + influxDBDataV.setV48(dataV.getV48Max()); + influxDBDataV.setV49(dataV.getV49Max()); + influxDBDataV.setV50(dataV.getV50Max()); + } + else if (valueType.equals("MIN")){ + + influxDBDataV.setVNeg(dataV.getVNegMin()); + influxDBDataV.setVPos(dataV.getVPosMin()); + influxDBDataV.setVThd(dataV.getVThdMin()); + influxDBDataV.setVUnbalance(dataV.getVUnbalanceMin()); + influxDBDataV.setVZero(dataV.getVZeroMin()); + influxDBDataV.setFreq(dataV.getFreqMin()); + influxDBDataV.setFreqDev(dataV.getFreqDevMin()); + influxDBDataV.setRms(dataV.getRmsMin()); + influxDBDataV.setVlDev(dataV.getVlDevMin()); + influxDBDataV.setVuDev(dataV.getVuDevMin()); + + influxDBDataV.setV1(dataV.getV1Min()); + influxDBDataV.setV2(dataV.getV2Min()); + influxDBDataV.setV3(dataV.getV3Min()); + influxDBDataV.setV4(dataV.getV4Min()); + influxDBDataV.setV5(dataV.getV5Min()); + influxDBDataV.setV6(dataV.getV6Min()); + influxDBDataV.setV7(dataV.getV7Min()); + influxDBDataV.setV8(dataV.getV8Min()); + influxDBDataV.setV9(dataV.getV9Min()); + influxDBDataV.setV10(dataV.getV10Min()); + influxDBDataV.setV11(dataV.getV11Min()); + influxDBDataV.setV12(dataV.getV12Min()); + influxDBDataV.setV13(dataV.getV13Min()); + influxDBDataV.setV14(dataV.getV14Min()); + influxDBDataV.setV15(dataV.getV15Min()); + influxDBDataV.setV16(dataV.getV16Min()); + influxDBDataV.setV17(dataV.getV17Min()); + influxDBDataV.setV18(dataV.getV18Min()); + influxDBDataV.setV19(dataV.getV19Min()); + influxDBDataV.setV20(dataV.getV20Min()); + influxDBDataV.setV21(dataV.getV21Min()); + influxDBDataV.setV22(dataV.getV22Min()); + influxDBDataV.setV23(dataV.getV23Min()); + influxDBDataV.setV24(dataV.getV24Min()); + influxDBDataV.setV25(dataV.getV25Min()); + influxDBDataV.setV26(dataV.getV26Min()); + influxDBDataV.setV27(dataV.getV27Min()); + influxDBDataV.setV28(dataV.getV28Min()); + influxDBDataV.setV29(dataV.getV29Min()); + influxDBDataV.setV30(dataV.getV30Min()); + influxDBDataV.setV31(dataV.getV31Min()); + influxDBDataV.setV32(dataV.getV32Min()); + influxDBDataV.setV33(dataV.getV33Min()); + influxDBDataV.setV34(dataV.getV34Min()); + influxDBDataV.setV35(dataV.getV35Min()); + influxDBDataV.setV36(dataV.getV36Min()); + influxDBDataV.setV37(dataV.getV37Min()); + influxDBDataV.setV38(dataV.getV38Min()); + influxDBDataV.setV39(dataV.getV39Min()); + influxDBDataV.setV40(dataV.getV40Min()); + influxDBDataV.setV41(dataV.getV41Min()); + influxDBDataV.setV42(dataV.getV42Min()); + influxDBDataV.setV43(dataV.getV43Min()); + influxDBDataV.setV44(dataV.getV44Min()); + influxDBDataV.setV45(dataV.getV45Min()); + influxDBDataV.setV46(dataV.getV46Min()); + influxDBDataV.setV47(dataV.getV47Min()); + influxDBDataV.setV48(dataV.getV48Min()); + influxDBDataV.setV49(dataV.getV49Min()); + influxDBDataV.setV50(dataV.getV50Min()); + } + else if (valueType.equals("CP95")){ + + influxDBDataV.setVNeg(dataV.getVNegCp95()); + influxDBDataV.setVPos(dataV.getVPosCp95()); + influxDBDataV.setVThd(dataV.getVThdCp95()); + influxDBDataV.setVUnbalance(dataV.getVUnbalanceCp95()); + influxDBDataV.setVZero(dataV.getVZeroCp95()); + influxDBDataV.setFreq(dataV.getFreqCp95()); + influxDBDataV.setFreqDev(dataV.getFreqDevCp95()); + influxDBDataV.setRms(dataV.getRmsCp95()); + influxDBDataV.setVlDev(dataV.getVlDevCp95()); + influxDBDataV.setVuDev(dataV.getVuDevCp95()); + + influxDBDataV.setV1(dataV.getV1Cp95()); + influxDBDataV.setV2(dataV.getV2Cp95()); + influxDBDataV.setV3(dataV.getV3Cp95()); + influxDBDataV.setV4(dataV.getV4Cp95()); + influxDBDataV.setV5(dataV.getV5Cp95()); + influxDBDataV.setV6(dataV.getV6Cp95()); + influxDBDataV.setV7(dataV.getV7Cp95()); + influxDBDataV.setV8(dataV.getV8Cp95()); + influxDBDataV.setV9(dataV.getV9Cp95()); + influxDBDataV.setV10(dataV.getV10Cp95()); + influxDBDataV.setV11(dataV.getV11Cp95()); + influxDBDataV.setV12(dataV.getV12Cp95()); + influxDBDataV.setV13(dataV.getV13Cp95()); + influxDBDataV.setV14(dataV.getV14Cp95()); + influxDBDataV.setV15(dataV.getV15Cp95()); + influxDBDataV.setV16(dataV.getV16Cp95()); + influxDBDataV.setV17(dataV.getV17Cp95()); + influxDBDataV.setV18(dataV.getV18Cp95()); + influxDBDataV.setV19(dataV.getV19Cp95()); + influxDBDataV.setV20(dataV.getV20Cp95()); + influxDBDataV.setV21(dataV.getV21Cp95()); + influxDBDataV.setV22(dataV.getV22Cp95()); + influxDBDataV.setV23(dataV.getV23Cp95()); + influxDBDataV.setV24(dataV.getV24Cp95()); + influxDBDataV.setV25(dataV.getV25Cp95()); + influxDBDataV.setV26(dataV.getV26Cp95()); + influxDBDataV.setV27(dataV.getV27Cp95()); + influxDBDataV.setV28(dataV.getV28Cp95()); + influxDBDataV.setV29(dataV.getV29Cp95()); + influxDBDataV.setV30(dataV.getV30Cp95()); + influxDBDataV.setV31(dataV.getV31Cp95()); + influxDBDataV.setV32(dataV.getV32Cp95()); + influxDBDataV.setV33(dataV.getV33Cp95()); + influxDBDataV.setV34(dataV.getV34Cp95()); + influxDBDataV.setV35(dataV.getV35Cp95()); + influxDBDataV.setV36(dataV.getV36Cp95()); + influxDBDataV.setV37(dataV.getV37Cp95()); + influxDBDataV.setV38(dataV.getV38Cp95()); + influxDBDataV.setV39(dataV.getV39Cp95()); + influxDBDataV.setV40(dataV.getV40Cp95()); + influxDBDataV.setV41(dataV.getV41Cp95()); + influxDBDataV.setV42(dataV.getV42Cp95()); + influxDBDataV.setV43(dataV.getV43Cp95()); + influxDBDataV.setV44(dataV.getV44Cp95()); + influxDBDataV.setV45(dataV.getV45Cp95()); + influxDBDataV.setV46(dataV.getV46Cp95()); + influxDBDataV.setV47(dataV.getV47Cp95()); + influxDBDataV.setV48(dataV.getV48Cp95()); + influxDBDataV.setV49(dataV.getV49Cp95()); + influxDBDataV.setV50(dataV.getV50Cp95()); + } + } + + + + influxDBDataVList.add(influxDBDataV); + + } + + + + + + return influxDBDataVList; + } + + + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayFlicker.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayFlicker.java new file mode 100644 index 0000000..4f3e024 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayFlicker.java @@ -0,0 +1,54 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import com.njcn.oracle.bo.po.DayFlicker; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; +import java.time.ZoneId; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + */ +@Data +@Measurement(name = "day_flicker") +public class InfluxDBDayFlicker { + + @TimeColumn + @Column(name = "time",tag =true) + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "fluc") + private Float fluc; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "plt") + private Float plt; + + @Column(name = "pst") + private Float pst; + + @Column(name = "quality_flag",tag = true) + private String qualityFlag; + + + @Column(name = "value_type",tag = true) + private String valueType; + + + + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayFluc.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayFluc.java new file mode 100644 index 0000000..d7a3528 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayFluc.java @@ -0,0 +1,45 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + */ +@Data +@Measurement(name = "day_fluc") +public class InfluxDBDayFluc { + + @Column(name = "time",tag =true) + @TimeColumn + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "fluc") + private Float fluc; + + @Column(name = "fluccf") + private Float fluccf; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag",tag = true) + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPhasicI.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPhasicI.java new file mode 100644 index 0000000..3003654 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPhasicI.java @@ -0,0 +1,189 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + */ +@Data +@Measurement(name = "day_harmphasic_i") +public class InfluxDBDayHarmPhasicI { + + @Column(name = "time",tag =true) + @TimeColumn + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag",tag = true) + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "i_1") + private Float i1; + + @Column(name = "i_2") + private Float i2; + + @Column(name = "i_3") + private Float i3; + + @Column(name = "i_4") + private Float i4; + + @Column(name = "i_5") + private Float i5; + + @Column(name = "i_6") + private Float i6; + + @Column(name = "i_7") + private Float i7; + + @Column(name = "i_8") + private Float i8; + + @Column(name = "i_9") + private Float i9; + + @Column(name = "i_10") + private Float i10; + + @Column(name = "i_11") + private Float i11; + + @Column(name = "i_12") + private Float i12; + + @Column(name = "i_13") + private Float i13; + + @Column(name = "i_14") + private Float i14; + + @Column(name = "i_15") + private Float i15; + + @Column(name = "i_16") + private Float i16; + + @Column(name = "i_17") + private Float i17; + + @Column(name = "i_18") + private Float i18; + + @Column(name = "i_19") + private Float i19; + + @Column(name = "i_20") + private Float i20; + + @Column(name = "i_21") + private Float i21; + + @Column(name = "i_22") + private Float i22; + + @Column(name = "i_23") + private Float i23; + + @Column(name = "i_24") + private Float i24; + + @Column(name = "i_25") + private Float i25; + + @Column(name = "i_26") + private Float i26; + + @Column(name = "i_27") + private Float i27; + + @Column(name = "i_28") + private Float i28; + + @Column(name = "i_29") + private Float i29; + + @Column(name = "i_30") + private Float i30; + + @Column(name = "i_31") + private Float i31; + + @Column(name = "i_32") + private Float i32; + + @Column(name = "i_33") + private Float i33; + + @Column(name = "i_34") + private Float i34; + + @Column(name = "i_35") + private Float i35; + + @Column(name = "i_36") + private Float i36; + + @Column(name = "i_37") + private Float i37; + + @Column(name = "i_38") + private Float i38; + + @Column(name = "i_39") + private Float i39; + + @Column(name = "i_40") + private Float i40; + + @Column(name = "i_41") + private Float i41; + + @Column(name = "i_42") + private Float i42; + + @Column(name = "i_43") + private Float i43; + + @Column(name = "i_44") + private Float i44; + + @Column(name = "i_45") + private Float i45; + + @Column(name = "i_46") + private Float i46; + + @Column(name = "i_47") + private Float i47; + + @Column(name = "i_48") + private Float i48; + + @Column(name = "i_49") + private Float i49; + + @Column(name = "i_50") + private Float i50; + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPhasicV.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPhasicV.java new file mode 100644 index 0000000..50d1782 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPhasicV.java @@ -0,0 +1,190 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 9:13 + */ +@Data +@Measurement(name = "day_harmphasic_v") +public class InfluxDBDayHarmPhasicV { + + @Column(name = "time",tag =true) + @TimeColumn + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag",tag = true) + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "v_1") + private Float v1; + + @Column(name = "v_2") + private Float v2; + + @Column(name = "v_3") + private Float v3; + + @Column(name = "v_4") + private Float v4; + + @Column(name = "v_5") + private Float v5; + + @Column(name = "v_6") + private Float v6; + + @Column(name = "v_7") + private Float v7; + + @Column(name = "v_8") + private Float v8; + + @Column(name = "v_9") + private Float v9; + + @Column(name = "v_10") + private Float v10; + + @Column(name = "v_11") + private Float v11; + + @Column(name = "v_12") + private Float v12; + + @Column(name = "v_13") + private Float v13; + + @Column(name = "v_14") + private Float v14; + + @Column(name = "v_15") + private Float v15; + + @Column(name = "v_16") + private Float v16; + + @Column(name = "v_17") + private Float v17; + + @Column(name = "v_18") + private Float v18; + + @Column(name = "v_19") + private Float v19; + + @Column(name = "v_20") + private Float v20; + + @Column(name = "v_21") + private Float v21; + + @Column(name = "v_22") + private Float v22; + + @Column(name = "v_23") + private Float v23; + + @Column(name = "v_24") + private Float v24; + + @Column(name = "v_25") + private Float v25; + + @Column(name = "v_26") + private Float v26; + + @Column(name = "v_27") + private Float v27; + + @Column(name = "v_28") + private Float v28; + + @Column(name = "v_29") + private Float v29; + + @Column(name = "v_30") + private Float v30; + + @Column(name = "v_31") + private Float v31; + + @Column(name = "v_32") + private Float v32; + + @Column(name = "v_33") + private Float v33; + + @Column(name = "v_34") + private Float v34; + + @Column(name = "v_35") + private Float v35; + + @Column(name = "v_36") + private Float v36; + + @Column(name = "v_37") + private Float v37; + + @Column(name = "v_38") + private Float v38; + + @Column(name = "v_39") + private Float v39; + + @Column(name = "v_40") + private Float v40; + + @Column(name = "v_41") + private Float v41; + + @Column(name = "v_42") + private Float v42; + + @Column(name = "v_43") + private Float v43; + + @Column(name = "v_44") + private Float v44; + + @Column(name = "v_45") + private Float v45; + + @Column(name = "v_46") + private Float v46; + + @Column(name = "v_47") + private Float v47; + + @Column(name = "v_48") + private Float v48; + + @Column(name = "v_49") + private Float v49; + + @Column(name = "v_50") + private Float v50; + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPowerP.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPowerP.java new file mode 100644 index 0000000..21e5e38 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPowerP.java @@ -0,0 +1,198 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 9:13 + */ +@Data +@Measurement(name = "day_harmpower_p") +public class InfluxDBDayHarmPowerP { + + @Column(name = "time",tag =true) + @TimeColumn + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag",tag = true) + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "df") + private Float df; + + @Column(name = "pf") + private Float pf; + + @Column(name = "p") + private Float p; + + @Column(name = "p_1") + private Float p1; + + @Column(name = "p_2") + private Float p2; + + @Column(name = "p_3") + private Float p3; + + @Column(name = "p_4") + private Float p4; + + @Column(name = "p_5") + private Float p5; + + @Column(name = "p_6") + private Float p6; + + @Column(name = "p_7") + private Float p7; + + @Column(name = "p_8") + private Float p8; + + @Column(name = "p_9") + private Float p9; + + @Column(name = "p_10") + private Float p10; + + @Column(name = "p_11") + private Float p11; + + @Column(name = "p_12") + private Float p12; + + @Column(name = "p_13") + private Float p13; + + @Column(name = "p_14") + private Float p14; + + @Column(name = "p_15") + private Float p15; + + @Column(name = "p_16") + private Float p16; + + @Column(name = "p_17") + private Float p17; + + @Column(name = "p_18") + private Float p18; + + @Column(name = "p_19") + private Float p19; + + @Column(name = "p_20") + private Float p20; + + @Column(name = "p_21") + private Float p21; + + @Column(name = "p_22") + private Float p22; + + @Column(name = "p_23") + private Float p23; + + @Column(name = "p_24") + private Float p24; + + @Column(name = "p_25") + private Float p25; + + @Column(name = "p_26") + private Float p26; + + @Column(name = "p_27") + private Float p27; + + @Column(name = "p_28") + private Float p28; + + @Column(name = "p_29") + private Float p29; + + @Column(name = "p_30") + private Float p30; + + @Column(name = "p_31") + private Float p31; + + @Column(name = "p_32") + private Float p32; + + @Column(name = "p_33") + private Float p33; + + @Column(name = "p_34") + private Float p34; + + @Column(name = "p_35") + private Float p35; + + @Column(name = "p_36") + private Float p36; + + @Column(name = "p_37") + private Float p37; + + @Column(name = "p_38") + private Float p38; + + @Column(name = "p_39") + private Float p39; + + @Column(name = "p_40") + private Float p40; + + @Column(name = "p_41") + private Float p41; + + @Column(name = "p_42") + private Float p42; + + @Column(name = "p_43") + private Float p43; + + @Column(name = "p_44") + private Float p44; + + @Column(name = "p_45") + private Float p45; + + @Column(name = "p_46") + private Float p46; + + @Column(name = "p_47") + private Float p47; + + @Column(name = "p_48") + private Float p48; + + @Column(name = "p_49") + private Float p49; + + @Column(name = "p_50") + private Float p50; +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPowerQ.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPowerQ.java new file mode 100644 index 0000000..3fb9bcb --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPowerQ.java @@ -0,0 +1,193 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 9:13 + */ +@Data +@Measurement(name = "day_harmpower_q") +public class InfluxDBDayHarmPowerQ { + + @Column(name = "time",tag =true) + @TimeColumn + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag",tag = true) + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "q") + private Float q; + + @Column(name = "q_1") + private Float q1; + + @Column(name = "q_2") + private Float q2; + + @Column(name = "q_3") + private Float q3; + + @Column(name = "q_4") + private Float q4; + + @Column(name = "q_5") + private Float q5; + + @Column(name = "q_6") + private Float q6; + + @Column(name = "q_7") + private Float q7; + + @Column(name = "q_8") + private Float q8; + + @Column(name = "q_9") + private Float q9; + + @Column(name = "q_10") + private Float q10; + + @Column(name = "q_11") + private Float q11; + + @Column(name = "q_12") + private Float q12; + + @Column(name = "q_13") + private Float q13; + + @Column(name = "q_14") + private Float q14; + + @Column(name = "q_15") + private Float q15; + + @Column(name = "q_16") + private Float q16; + + @Column(name = "q_17") + private Float q17; + + @Column(name = "q_18") + private Float q18; + + @Column(name = "q_19") + private Float q19; + + @Column(name = "q_20") + private Float q20; + + @Column(name = "q_21") + private Float q21; + + @Column(name = "q_22") + private Float q22; + + @Column(name = "q_23") + private Float q23; + + @Column(name = "q_24") + private Float q24; + + @Column(name = "q_25") + private Float q25; + + @Column(name = "q_26") + private Float q26; + + @Column(name = "q_27") + private Float q27; + + @Column(name = "q_28") + private Float q28; + + @Column(name = "q_29") + private Float q29; + + @Column(name = "q_30") + private Float q30; + + @Column(name = "q_31") + private Float q31; + + @Column(name = "q_32") + private Float q32; + + @Column(name = "q_33") + private Float q33; + + @Column(name = "q_34") + private Float q34; + + @Column(name = "q_35") + private Float q35; + + @Column(name = "q_36") + private Float q36; + + @Column(name = "q_37") + private Float q37; + + @Column(name = "q_38") + private Float q38; + + @Column(name = "q_39") + private Float q39; + + @Column(name = "q_40") + private Float q40; + + @Column(name = "q_41") + private Float q41; + + @Column(name = "q_42") + private Float q42; + + @Column(name = "q_43") + private Float q43; + + @Column(name = "q_44") + private Float q44; + + @Column(name = "q_45") + private Float q45; + + @Column(name = "q_46") + private Float q46; + + @Column(name = "q_47") + private Float q47; + + @Column(name = "q_48") + private Float q48; + + @Column(name = "q_49") + private Float q49; + + @Column(name = "q_50") + private Float q50; + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPowerS.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPowerS.java new file mode 100644 index 0000000..2389e98 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmPowerS.java @@ -0,0 +1,193 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 9:13 + */ +@Data +@Measurement(name = "day_harmpower_s") +public class InfluxDBDayHarmPowerS { + + @Column(name = "time",tag =true) + @TimeColumn + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag",tag = true) + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "s") + private Float s; + + @Column(name = "s_1") + private Float s1; + + @Column(name = "s_2") + private Float s2; + + @Column(name = "s_3") + private Float s3; + + @Column(name = "s_4") + private Float s4; + + @Column(name = "s_5") + private Float s5; + + @Column(name = "s_6") + private Float s6; + + @Column(name = "s_7") + private Float s7; + + @Column(name = "s_8") + private Float s8; + + @Column(name = "s_9") + private Float s9; + + @Column(name = "s_10") + private Float s10; + + @Column(name = "s_11") + private Float s11; + + @Column(name = "s_12") + private Float s12; + + @Column(name = "s_13") + private Float s13; + + @Column(name = "s_14") + private Float s14; + + @Column(name = "s_15") + private Float s15; + + @Column(name = "s_16") + private Float s16; + + @Column(name = "s_17") + private Float s17; + + @Column(name = "s_18") + private Float s18; + + @Column(name = "s_19") + private Float s19; + + @Column(name = "s_20") + private Float s20; + + @Column(name = "s_21") + private Float s21; + + @Column(name = "s_22") + private Float s22; + + @Column(name = "s_23") + private Float s23; + + @Column(name = "s_24") + private Float s24; + + @Column(name = "s_25") + private Float s25; + + @Column(name = "s_26") + private Float s26; + + @Column(name = "s_27") + private Float s27; + + @Column(name = "s_28") + private Float s28; + + @Column(name = "s_29") + private Float s29; + + @Column(name = "s_30") + private Float s30; + + @Column(name = "s_31") + private Float s31; + + @Column(name = "s_32") + private Float s32; + + @Column(name = "s_33") + private Float s33; + + @Column(name = "s_34") + private Float s34; + + @Column(name = "s_35") + private Float s35; + + @Column(name = "s_36") + private Float s36; + + @Column(name = "s_37") + private Float s37; + + @Column(name = "s_38") + private Float s38; + + @Column(name = "s_39") + private Float s39; + + @Column(name = "s_40") + private Float s40; + + @Column(name = "s_41") + private Float s41; + + @Column(name = "s_42") + private Float s42; + + @Column(name = "s_43") + private Float s43; + + @Column(name = "s_44") + private Float s44; + + @Column(name = "s_45") + private Float s45; + + @Column(name = "s_46") + private Float s46; + + @Column(name = "s_47") + private Float s47; + + @Column(name = "s_48") + private Float s48; + + @Column(name = "s_49") + private Float s49; + + @Column(name = "s_50") + private Float s50; + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmRateI.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmRateI.java new file mode 100644 index 0000000..62d2272 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmRateI.java @@ -0,0 +1,18 @@ +package com.njcn.influx.bo.po; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.influxdb.annotation.Measurement; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 11:27 + */ +@EqualsAndHashCode(callSuper = true) +@Data +@Measurement(name = "day_harmrate_i") +public class InfluxDBDayHarmRateI extends InfluxDBDayHarmPhasicI { +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmRateV.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmRateV.java new file mode 100644 index 0000000..31bdef0 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayHarmRateV.java @@ -0,0 +1,18 @@ +package com.njcn.influx.bo.po; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.influxdb.annotation.Measurement; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 11:27 + */ +@EqualsAndHashCode(callSuper = true) +@Data +@Measurement(name = "day_harmrate_v") +public class InfluxDBDayHarmRateV extends InfluxDBDayHarmPhasicV { +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayI.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayI.java new file mode 100644 index 0000000..31b62e4 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayI.java @@ -0,0 +1,208 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/11 15:13 + */ +@Data +@Measurement(name = "day_i") +public class InfluxDBDayI { + + @Column(name = "time",tag = true) + @TimeColumn + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag",tag = true) + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "i_neg") + private Float iNeg; + + @Column(name = "i_pos") + private Float iPos; + + @Column(name = "i_thd") + private Float iThd; + + @Column(name = "i_unbalance") + private Float iUnbalance; + + @Column(name = "i_zero") + private Float iZero; + + @Column(name = "rms") + private Float rms; + + @Column(name = "i_1") + private Float i1; + + @Column(name = "i_2") + private Float i2; + + @Column(name = "i_3") + private Float i3; + + @Column(name = "i_4") + private Float i4; + + @Column(name = "i_5") + private Float i5; + + @Column(name = "i_6") + private Float i6; + + @Column(name = "i_7") + private Float i7; + + @Column(name = "i_8") + private Float i8; + + @Column(name = "i_9") + private Float i9; + + @Column(name = "i_10") + private Float i10; + + @Column(name = "i_11") + private Float i11; + + @Column(name = "i_12") + private Float i12; + + @Column(name = "i_13") + private Float i13; + + @Column(name = "i_14") + private Float i14; + + @Column(name = "i_15") + private Float i15; + + @Column(name = "i_16") + private Float i16; + + @Column(name = "i_17") + private Float i17; + + @Column(name = "i_18") + private Float i18; + + @Column(name = "i_19") + private Float i19; + + @Column(name = "i_20") + private Float i20; + + @Column(name = "i_21") + private Float i21; + + @Column(name = "i_22") + private Float i22; + + @Column(name = "i_23") + private Float i23; + + @Column(name = "i_24") + private Float i24; + + @Column(name = "i_25") + private Float i25; + + @Column(name = "i_26") + private Float i26; + + @Column(name = "i_27") + private Float i27; + + @Column(name = "i_28") + private Float i28; + + @Column(name = "i_29") + private Float i29; + + @Column(name = "i_30") + private Float i30; + + @Column(name = "i_31") + private Float i31; + + @Column(name = "i_32") + private Float i32; + + @Column(name = "i_33") + private Float i33; + + @Column(name = "i_34") + private Float i34; + + @Column(name = "i_35") + private Float i35; + + @Column(name = "i_36") + private Float i36; + + @Column(name = "i_37") + private Float i37; + + @Column(name = "i_38") + private Float i38; + + @Column(name = "i_39") + private Float i39; + + @Column(name = "i_40") + private Float i40; + + @Column(name = "i_41") + private Float i41; + + @Column(name = "i_42") + private Float i42; + + @Column(name = "i_43") + private Float i43; + + @Column(name = "i_44") + private Float i44; + + @Column(name = "i_45") + private Float i45; + + @Column(name = "i_46") + private Float i46; + + @Column(name = "i_47") + private Float i47; + + @Column(name = "i_48") + private Float i48; + + @Column(name = "i_49") + private Float i49; + + @Column(name = "i_50") + private Float i50; + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayInHarmI.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayInHarmI.java new file mode 100644 index 0000000..fda9e8a --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayInHarmI.java @@ -0,0 +1,20 @@ +package com.njcn.influx.bo.po; + +import lombok.Data; +import lombok.EqualsAndHashCode; +import org.influxdb.annotation.Measurement; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 11:27 + */ +@EqualsAndHashCode(callSuper = true) +@Data +@Measurement(name = "day_inharm_i") +public class InfluxDBDayInHarmI extends InfluxDBDayHarmPhasicI { + + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayInHarmV.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayInHarmV.java new file mode 100644 index 0000000..c1d3ba8 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayInHarmV.java @@ -0,0 +1,187 @@ +package com.njcn.influx.bo.po; + +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/5/12 11:27 + */ +@Data +@Measurement(name = "day_inharm_v") +public class InfluxDBDayInHarmV { + + @Column(name = "time",tag =true) + @TimeColumn + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "quality_flag",tag = true) + private String qualityFlag; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "v_1") + private Float v1; + + @Column(name = "v_2") + private Float v2; + + @Column(name = "v_3") + private Float v3; + + @Column(name = "v_4") + private Float v4; + + @Column(name = "v_5") + private Float v5; + + @Column(name = "v_6") + private Float v6; + + @Column(name = "v_7") + private Float v7; + + @Column(name = "v_8") + private Float v8; + + @Column(name = "v_9") + private Float v9; + + @Column(name = "v_10") + private Float v10; + + @Column(name = "v_11") + private Float v11; + + @Column(name = "v_12") + private Float v12; + + @Column(name = "v_13") + private Float v13; + + @Column(name = "v_14") + private Float v14; + + @Column(name = "v_15") + private Float v15; + + @Column(name = "v_16") + private Float v16; + + @Column(name = "v_17") + private Float v17; + + @Column(name = "v_18") + private Float v18; + + @Column(name = "v_19") + private Float v19; + + @Column(name = "v_20") + private Float v20; + + @Column(name = "v_21") + private Float v21; + + @Column(name = "v_22") + private Float v22; + + @Column(name = "v_23") + private Float v23; + + @Column(name = "v_24") + private Float v24; + + @Column(name = "v_25") + private Float v25; + + @Column(name = "v_26") + private Float v26; + + @Column(name = "v_27") + private Float v27; + + @Column(name = "v_28") + private Float v28; + + @Column(name = "v_29") + private Float v29; + + @Column(name = "v_30") + private Float v30; + + @Column(name = "v_31") + private Float v31; + + @Column(name = "v_32") + private Float v32; + + @Column(name = "v_33") + private Float v33; + + @Column(name = "v_34") + private Float v34; + + @Column(name = "v_35") + private Float v35; + + @Column(name = "v_36") + private Float v36; + + @Column(name = "v_37") + private Float v37; + + @Column(name = "v_38") + private Float v38; + + @Column(name = "v_39") + private Float v39; + + @Column(name = "v_40") + private Float v40; + + @Column(name = "v_41") + private Float v41; + + @Column(name = "v_42") + private Float v42; + + @Column(name = "v_43") + private Float v43; + + @Column(name = "v_44") + private Float v44; + + @Column(name = "v_45") + private Float v45; + + @Column(name = "v_46") + private Float v46; + + @Column(name = "v_47") + private Float v47; + + @Column(name = "v_48") + private Float v48; + + @Column(name = "v_49") + private Float v49; + + @Column(name = "v_50") + private Float v50; + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayPlt.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayPlt.java new file mode 100644 index 0000000..89df5ab --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayPlt.java @@ -0,0 +1,43 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/4/12 16:01 + */ +@Data +@Measurement(name = "day_plt") +public class InfluxDBDayPlt { + + @Column(name = "time",tag =true) + @TimeColumn + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phaseType; + + @Column(name = "value_type",tag = true) + private String valueType; + + @Column(name = "quality_flag",tag = true) + private String qualityFlag; + + @Column(name = "plt") + private Float plt; + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayV.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayV.java new file mode 100644 index 0000000..e78d509 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/InfluxDBDayV.java @@ -0,0 +1,235 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; +import org.influxdb.annotation.TimeColumn; + +import java.time.Instant; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/4/7 10:00 + */ +@Data +@Measurement(name = "day_v") +public class InfluxDBDayV { + + @Column(name = "time",tag = true) + @TimeColumn + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "freq") + private Float freq; + + @Column(name = "freq_dev") + private Float freqDev; + + @Column(name = "quality_flag",tag = true) + private String qualityFlag; + + @Column(name = "rms") + private Float rms; + + @Column(name = "rms_lvr") + private Float rmsLvr; + + @Column(name = "vl_dev") + private Float vlDev; + + @Column(name = "vu_dev") + private Float vuDev; + + @Column(name = "v_1") + private Float v1; + + @Column(name = "v_2") + private Float v2; + + @Column(name = "v_3") + private Float v3; + + @Column(name = "v_4") + private Float v4; + + @Column(name = "v_5") + private Float v5; + + @Column(name = "v_6") + private Float v6; + + @Column(name = "v_7") + private Float v7; + + @Column(name = "v_8") + private Float v8; + + @Column(name = "v_9") + private Float v9; + + @Column(name = "v_10") + private Float v10; + + @Column(name = "v_11") + private Float v11; + + @Column(name = "v_12") + private Float v12; + + @Column(name = "v_13") + private Float v13; + + @Column(name = "v_14") + private Float v14; + + @Column(name = "v_15") + private Float v15; + + @Column(name = "v_16") + private Float v16; + + @Column(name = "v_17") + private Float v17; + + @Column(name = "v_18") + private Float v18; + + @Column(name = "v_19") + private Float v19; + + @Column(name = "v_20") + private Float v20; + + @Column(name = "v_21") + private Float v21; + + @Column(name = "v_22") + private Float v22; + + @Column(name = "v_23") + private Float v23; + + @Column(name = "v_24") + private Float v24; + + @Column(name = "v_25") + private Float v25; + + @Column(name = "v_26") + private Float v26; + + @Column(name = "v_27") + private Float v27; + + @Column(name = "v_28") + private Float v28; + + @Column(name = "v_29") + private Float v29; + + @Column(name = "v_30") + private Float v30; + + @Column(name = "v_31") + private Float v31; + + @Column(name = "v_32") + private Float v32; + + @Column(name = "v_33") + private Float v33; + + @Column(name = "v_34") + private Float v34; + + @Column(name = "v_35") + private Float v35; + + @Column(name = "v_36") + private Float v36; + + @Column(name = "v_37") + private Float v37; + + @Column(name = "v_38") + private Float v38; + + @Column(name = "v_39") + private Float v39; + + @Column(name = "v_40") + private Float v40; + + @Column(name = "v_41") + private Float v41; + + @Column(name = "v_42") + private Float v42; + + @Column(name = "v_43") + private Float v43; + + @Column(name = "v_44") + private Float v44; + + @Column(name = "v_45") + private Float v45; + + @Column(name = "v_46") + private Float v46; + + @Column(name = "v_47") + private Float v47; + + @Column(name = "v_48") + private Float v48; + + @Column(name = "v_49") + private Float v49; + + @Column(name = "v_50") + private Float v50; + + @Column(name = "v_neg") + private Float vNeg; + + @Column(name = "v_pos") + private Float vPos; + + @Column(name = "v_thd") + private Float vThd; + + @Column(name = "v_unbalance") + private Float vUnbalance; + + @Column(name = "v_zero") + private Float vZero; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phasicType; + + @Column(name = "value_type",tag = true) + private String valueType; + + + //自定义字段-总计算次数 + @Column(name = "all_time") + private Integer allTime; + + //自定义字段 + @Column(name = "mean") + private Float mean; + + //自定义字段 + @Column(name = "count") + private Integer count; +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/LimitRatePO.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/LimitRatePO.java new file mode 100644 index 0000000..f89196b --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/LimitRatePO.java @@ -0,0 +1,248 @@ +package com.njcn.influx.bo.po; + + +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; + +import java.time.Instant; + +/** + * @version 1.0.0 + * @author: chenchao + * @date: 2022/04/19 17:37 + */ +@Data +@Measurement(name = "limit_rate") +public class LimitRatePO { + //时间索引 + @Column(name = "time",tag =true) + private Instant time; + //监测点索引 + @Column(name = "line_id",tag = true) + private String lineId; + //数据类型 + @Column(name = "phasic_type",tag = true) + private String phasicType; + //总次数 + @Column(name = "all_time") + private Integer allTime; + //闪变越限次数 + @Column(name = "flicker_overtime") + private Integer flickerOverTime; + //闪变总次数 + @Column(name = "flicker_all_time") + private Integer flickerAllTime; + //频率偏差越限次数 + @Column(name = "freq_dev_overtime") + private Integer freqDevOverTime; + //电压偏差越限次数 + @Column(name = "voltage_dev_overtime") + private Integer voltageDevOverTime; + //电压不平衡度越限次数 + @Column(name = "ubalance_overtime") + private Integer uBalanceOverTime; + //电压谐波畸变率越限次数 + @Column(name = "uaberrance_overtime") + private Integer uAberranceOverTime; + //负序电流限值次数 + @Column(name = "i_neg_overtime") + private Integer iNegOverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_2_overtime") + private Integer uHarm2OverTime; + //3次电压谐波含有率越限次数 + @Column(name = "uharm_3_overtime") + private Integer uHarm3OverTime; + //4次电压谐波含有率越限次数 + @Column(name = "uharm_4_overtime") + private Integer uHarm4OverTime; + //5次电压谐波含有率越限次数 + @Column(name = "uharm_5_overtime") + private Integer uHarm5OverTime; + //6次电压谐波含有率越限次数 + @Column(name = "uharm_6_overtime") + private Integer uHarm6OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_7_overtime") + private Integer uHarm7OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_8_overtime") + private Integer uHarm8OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_9_overtime") + private Integer uHarm9OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_10_overtime") + private Integer uHarm10OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_11_overtime") + private Integer uHarm11OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_12_overtime") + private Integer uHarm12OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_13_overtime") + private Integer uHarm13OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_14_overtime") + private Integer uHarm14OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_15_overtime") + private Integer uHarm15OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_16_overtime") + private Integer uHarm16OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_17_overtime") + private Integer uHarm17OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_18_overtime") + private Integer uHarm18OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_19_overtime") + private Integer uHarm19OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_20_overtime") + private Integer uHarm20OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_21_overtime") + private Integer uHarm21OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_22_overtime") + private Integer uHarm22OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_23_overtime") + private Integer uHarm23OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_24_overtime") + private Integer uHarm24OverTime; + //2次电压谐波含有率越限次数 + @Column(name = "uharm_25_overtime") + private Integer uHarm25OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_2_overtime") + private Integer iHarm2OverTime; + //3次电流谐波幅值越限次数 + @Column(name = "iharm_3_overtime") + private Integer iHarm3OverTime; + //4次电流谐波幅值越限次数 + @Column(name = "iharm_4_overtime") + private Integer iHarm4OverTime; + //5次电流谐波幅值越限次数 + @Column(name = "iharm_5_overtime") + private Integer iHarm5OverTime; + //6次电流谐波幅值越限次数 + @Column(name = "iharm_6_overtime") + private Integer iHarm6OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_7_overtime") + private Integer iHarm7OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_8_overtime") + private Integer iHarm8OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_9_overtime") + private Integer iHarm9OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_10_overtime") + private Integer iHarm10OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_11_overtime") + private Integer iHarm11OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_12_overtime") + private Integer iHarm12OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_13_overtime") + private Integer iHarm13OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_14_overtime") + private Integer iHarm14OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_15_overtime") + private Integer iHarm15OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_16_overtime") + private Integer iHarm16OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_17_overtime") + private Integer iHarm17OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_18_overtime") + private Integer iHarm18OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_19_overtime") + private Integer iHarm19OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_20_overtime") + private Integer iHarm20OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_21_overtime") + private Integer iHarm21OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_22_overtime") + private Integer iHarm22OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_23_overtime") + private Integer iHarm23OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_24_overtime") + private Integer iHarm24OverTime; + //2次电流谐波幅值越限次数 + @Column(name = "iharm_25_overtime") + private Integer iHarm25OverTime; + //0.5次间谐波电压限值次数 + @Column(name = "inuharm_1_overtime") + private Integer inUHARM1OverTime; + //1.5次间谐波电压限值次数 + @Column(name = "inuharm_2_overtime") + private Integer inUHARM2OverTime; + //2.5次间谐波电压限值次数 + @Column(name = "inuharm_3_overtime") + private Integer inUHARM3OverTime; + //3.5次间谐波电压限值次数 + @Column(name = "inuharm_4_overtime") + private Integer inUHARM4OverTime; + //4.5次间谐波电压限值次数 + @Column(name = "inuharm_5_overtime") + private Integer inUHARM5OverTime; + //5.5次间谐波电压限值次数 + @Column(name = "inuharm_6_overtime") + private Integer inUHARM6OverTime; + //6.5次间谐波电压限值次数 + @Column(name = "inuharm_7_overtime") + private Integer inUHARM7OverTime; + //7.5次间谐波电压限值次数 + @Column(name = "inuharm_8_overtime") + private Integer inUHARM8OverTime; + //8.5次间谐波电压限值次数 + @Column(name = "inuharm_9_overtime") + private Integer inUHARM9OverTime; + //9.5次间谐波电压限值次数 + @Column(name = "inuharm_10_overtime") + private Integer inUHARM10OverTime; + //10.5次间谐波电压限值次数 + @Column(name = "inuharm_11_overtime") + private Integer inUHARM11OverTime; + //11.5次间谐波电压限值次数 + @Column(name = "inuharm_12_overtime") + private Integer inUHARM12OverTime; + //12.5次间谐波电压限值次数 + @Column(name = "inuharm_13_overtime") + private Integer inUHARM13OverTime; + //13.5次间谐波电压限值次数 + @Column(name = "inuharm_14_overtime") + private Integer inUHARM14OverTime; + //14.5次间谐波电压限值次数 + @Column(name = "inuharm_15_overtime") + private Integer inUHARM15OverTime; + //15.5次间谐波电压限值次数 + @Column(name = "inuharm_16_overtime") + private Integer inUHARM16OverTime; + + + + + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/LimitTarget.java b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/LimitTarget.java new file mode 100644 index 0000000..fe83636 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/bo/po/LimitTarget.java @@ -0,0 +1,279 @@ +package com.njcn.influx.bo.po; + +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.njcn.common.utils.serializer.InstantDateSerializer; +import lombok.Data; +import org.influxdb.annotation.Column; +import org.influxdb.annotation.Measurement; + +import java.time.Instant; + +/** + * 类的介绍： + * + * @author xuyang + * @version 1.0.0 + * @createTime 2022/4/21 20:20 + */ +@Data +@Measurement(name = "limit_target") +public class LimitTarget { + + @Column(name = "time",tag =true) + @JsonSerialize(using = InstantDateSerializer.class) + private Instant time; + + @Column(name = "line_id",tag = true) + private String lineId; + + @Column(name = "phasic_type",tag = true) + private String phasicType; + + @Column(name = "all_time") + private Integer allTime; + + @Column(name = "flicker_overtime") + private Integer flickerOverTime; + + @Column(name = "flicker_all_time") + private Integer flickerAllTime; + + @Column(name = "freq_dev_overtime") + private Integer freqDevOverTime; + + @Column(name = "voltage_dev_overtime") + private Integer voltageDevOverTime; + + @Column(name = "ubalance_overtime") + private Integer uBalanceOverTime; + + @Column(name = "uaberrance_overtime") + private Integer uAberranceOverTime; + + @Column(name = "i_neg_overtime") + private Integer iNegOverTime; + + @Column(name = "uharm_2_overtime") + private Integer uHarm2OverTime; + + @Column(name = "uharm_3_overtime") + private Integer uHarm3OverTime; + + @Column(name = "uharm_4_overtime") + private Integer uHarm4OverTime; + + @Column(name = "uharm_5_overtime") + private Integer uHarm5OverTime; + + @Column(name = "uharm_6_overtime") + private Integer uHarm6OverTime; + + @Column(name = "uharm_7_overtime") + private Integer uHarm7OverTime; + + @Column(name = "uharm_8_overtime") + private Integer uHarm8OverTime; + + @Column(name = "uharm_9_overtime") + private Integer uHarm9OverTime; + + @Column(name = "uharm_10_overtime") + private Integer uHarm10OverTime; + + @Column(name = "uharm_11_overtime") + private Integer uHarm11OverTime; + + @Column(name = "uharm_12_overtime") + private Integer uHarm12OverTime; + + @Column(name = "uharm_13_overtime") + private Integer uHarm13OverTime; + + @Column(name = "uharm_14_overtime") + private Integer uHarm14OverTime; + + @Column(name = "uharm_15_overtime") + private Integer uHarm15OverTime; + + @Column(name = "uharm_16_overtime") + private Integer uHarm16OverTime; + + @Column(name = "uharm_17_overtime") + private Integer uHarm17OverTime; + + @Column(name = "uharm_18_overtime") + private Integer uHarm18OverTime; + + @Column(name = "uharm_19_overtime") + private Integer uHarm19OverTime; + + @Column(name = "uharm_20_overtime") + private Integer uHarm20OverTime; + + @Column(name = "uharm_21_overtime") + private Integer uHarm21OverTime; + + @Column(name = "uharm_22_overtime") + private Integer uHarm22OverTime; + + @Column(name = "uharm_23_overtime") + private Integer uHarm23OverTime; + + @Column(name = "uharm_24_overtime") + private Integer uHarm24OverTime; + + @Column(name = "uharm_25_overtime") + private Integer uHarm25OverTime; + + @Column(name = "iharm_2_overtime") + private Integer iHarm2OverTime; + + @Column(name = "iharm_3_overtime") + private Integer iHarm3OverTime; + + @Column(name = "iharm_4_overtime") + private Integer iHarm4OverTime; + + @Column(name = "iharm_5_overtime") + private Integer iHarm5OverTime; + + @Column(name = "iharm_6_overtime") + private Integer iHarm6OverTime; + + @Column(name = "iharm_7_overtime") + private Integer iHarm7OverTime; + + @Column(name = "iharm_8_overtime") + private Integer iHarm8OverTime; + + @Column(name = "iharm_9_overtime") + private Integer iHarm9OverTime; + + @Column(name = "iharm_10_overtime") + private Integer iHarm10OverTime; + + @Column(name = "iharm_11_overtime") + private Integer iHarm11OverTime; + + @Column(name = "iharm_12_overtime") + private Integer iHarm12OverTime; + + @Column(name = "iharm_13_overtime") + private Integer iHarm13OverTime; + + @Column(name = "iharm_14_overtime") + private Integer iHarm14OverTime; + + @Column(name = "iharm_15_overtime") + private Integer iHarm15OverTime; + + @Column(name = "iharm_16_overtime") + private Integer iHarm16OverTime; + + @Column(name = "iharm_17_overtime") + private Integer iHarm17OverTime; + + @Column(name = "iharm_18_overtime") + private Integer iHarm18OverTime; + + @Column(name = "iharm_19_overtime") + private Integer iHarm19OverTime; + + @Column(name = "iharm_20_overtime") + private Integer iHarm20OverTime; + + @Column(name = "iharm_21_overtime") + private Integer iHarm21OverTime; + + @Column(name = "iharm_22_overtime") + private Integer iHarm22OverTime; + + @Column(name = "iharm_23_overtime") + private Integer iHarm23OverTime; + + @Column(name = "iharm_24_overtime") + private Integer iHarm24OverTime; + + @Column(name = "iharm_25_overtime") + private Integer iHarm25OverTime; + + @Column(name = "inuharm_1_overtime") + private Integer inuHarm1OverTime; + + @Column(name = "inuharm_2_overtime") + private Integer inuHarm2OverTime; + + @Column(name = "inuharm_3_overtime") + private Integer inuHarm3OverTime; + + @Column(name = "inuharm_4_overtime") + private Integer inuHarm4OverTime; + + @Column(name = "inuharm_5_overtime") + private Integer inuHarm5OverTime; + + @Column(name = "inuharm_6_overtime") + private Integer inuHarm6OverTime; + + @Column(name = "inuharm_7_overtime") + private Integer inuHarm7OverTime; + + @Column(name = "inuharm_8_overtime") + private Integer inuHarm8OverTime; + + @Column(name = "inuharm_9_overtime") + private Integer inuHarm9OverTime; + + @Column(name = "inuharm_10_overtime") + private Integer inuHarm10OverTime; + + @Column(name = "inuharm_11_overtime") + private Integer inuHarm11OverTime; + + @Column(name = "inuharm_12_overtime") + private Integer inuHarm12OverTime; + + @Column(name = "inuharm_13_overtime") + private Integer inuHarm13OverTime; + + @Column(name = "inuharm_14_overtime") + private Integer inuHarm14OverTime; + + @Column(name = "inuharm_15_overtime") + private Integer inuHarm15OverTime; + + @Column(name = "inuharm_16_overtime") + private Integer inuHarm16OverTime; + + /** + * 别名字段 + * 谐波电压含有率其他次 + */ + @Column(name = "u_other_times") + private Integer uOtherTimes; + + /** + * 别名字段 + * 谐波电流含量其他词 + */ + @Column(name = "i_other_times") + private Integer iOtherTimes; + + /** + * 别名字段 + */ + @Column(name = "uharm_all_overtime") + private Integer uHarmAllOverTime; + + /** + * 别名字段 + */ + @Column(name = "iharm_all_overtime") + private Integer iHarmAllOverTime; + + /** + * 别名字段 + */ + @Column(name = "inuharm_all_overtime") + private Integer inuharmAllOverTime; +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/service/InfluxDBBaseService.java b/influx-data/influx-source/src/main/java/com/njcn/influx/service/InfluxDBBaseService.java new file mode 100644 index 0000000..d508a35 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/service/InfluxDBBaseService.java @@ -0,0 +1,24 @@ +package com.njcn.influx.service; + +import java.util.List; + +/** + * Description: + * Date: 2024/1/15 11:38【需求编号】 + * + * @author clam + * @version V1.0.0 + */ +public interface InfluxDBBaseService { + + + /*** + * 当批量插入数据量过大时，可以指定尺寸交给mybatis,每次插入多少条记录 + * @author hongawen + * @date 2023/6/6 9:33 + * @param data 数据集合 + * @param size 分片的尺寸 + */ + void insertBatchBySlice(List data, int size); + +} diff --git a/influx-data/influx-source/src/main/java/com/njcn/influx/service/impl/InfluxDBBaseServiceImpl.java b/influx-data/influx-source/src/main/java/com/njcn/influx/service/impl/InfluxDBBaseServiceImpl.java new file mode 100644 index 0000000..ff2fb97 --- /dev/null +++ b/influx-data/influx-source/src/main/java/com/njcn/influx/service/impl/InfluxDBBaseServiceImpl.java @@ -0,0 +1,61 @@ +package com.njcn.influx.service.impl; + +import cn.hutool.core.collection.ListUtil; +import com.njcn.influx.service.InfluxDBBaseService; +import lombok.RequiredArgsConstructor; +import org.influxdb.InfluxDB; +import org.influxdb.annotation.Measurement; +import org.influxdb.dto.BatchPoints; +import org.influxdb.dto.Point; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.List; + +/** + * Description: + * Date: 2024/1/15 11:44【需求编号】 + * + * @author clam + * @version V1.0.0 + */ +@Service +@RequiredArgsConstructor +public class InfluxDBBaseServiceImpl implements InfluxDBBaseService { + + private final InfluxDB influxDb; + + private final String database="pqsbase_zl"; + @Override + public void insertBatchBySlice(List data, int size) { + int totalCount = data.size(); + int idxLimit = Math.min(size, totalCount); + List> partition = ListUtil.partition(data, idxLimit); + partition.forEach(temp->{ + if (data.size() > 0) { + + Object firstObj = data.get(0); + Class domainClass = firstObj.getClass(); + List pointList = new ArrayList<>(); + for (Object o : data) { + Point point = Point + .measurementByPOJO(domainClass) + .addFieldsFromPOJO(o) + .build(); + pointList.add(point); + } + //获取数据库名和rp + Measurement measurement = firstObj.getClass().getAnnotation(Measurement.class); + String retentionPolicy = measurement.retentionPolicy(); + BatchPoints batchPoints = BatchPoints + .builder() + .points(pointList) + .retentionPolicy(retentionPolicy).build(); + influxDb.setDatabase(database); + influxDb.write(batchPoints); + } + }); + + + } +} diff --git a/influx-data/influx-target/.gitignore b/influx-data/influx-target/.gitignore new file mode 100644 index 0000000..5ff6309 --- /dev/null +++ b/influx-data/influx-target/.gitignore @@ -0,0 +1,38 @@ +target/ +!.mvn/wrapper/maven-wrapper.jar +!**/src/main/**/target/ +!**/src/test/**/target/ + +### IntelliJ IDEA ### +.idea/modules.xml +.idea/jarRepositories.xml +.idea/compiler.xml +.idea/libraries/ +*.iws +*.iml +*.ipr + +### Eclipse ### +.apt_generated +.classpath +.factorypath +.project +.settings +.springBeans +.sts4-cache + +### NetBeans ### +/nbproject/private/ +/nbbuild/ +/dist/ +/nbdist/ +/.nb-gradle/ +build/ +!**/src/main/**/build/ +!**/src/test/**/build/ + +### VS Code ### +.vscode/ + +### Mac OS ### +.DS_Store \ No newline at end of file diff --git a/influx-data/influx-target/pom.xml b/influx-data/influx-target/pom.xml new file mode 100644 index 0000000..919470e --- /dev/null +++ b/influx-data/influx-target/pom.xml @@ -0,0 +1,35 @@ + + + 4.0.0 + + com.njcn + influx-data + 1.0.0 + + + influx-target + + + 8 + 8 + UTF-8 + + + + + + com.njcn + influx-source + 1.0.0 + + + + + org.springframework.boot + spring-boot-starter-web + + + + \ No newline at end of file diff --git a/influx-data/influx-target/src/main/java/com/njcn/InfluxDataApplication.java b/influx-data/influx-target/src/main/java/com/njcn/InfluxDataApplication.java new file mode 100644 index 0000000..89c24c5 --- /dev/null +++ b/influx-data/influx-target/src/main/java/com/njcn/InfluxDataApplication.java @@ -0,0 +1,26 @@ +package com.njcn; + +import lombok.extern.slf4j.Slf4j; +import org.mybatis.spring.annotation.MapperScan; +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration; +import org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration; +import org.springframework.scheduling.annotation.EnableAsync; + +/** + * pqs + * + * @author cdf + * @date 2022/11/10 + */ +@Slf4j +@MapperScan("com.njcn.**.mapper") +@SpringBootApplication(scanBasePackages = "com.njcn",exclude = {SecurityAutoConfiguration.class, SecurityFilterAutoConfiguration.class}) +public class InfluxDataApplication { + + public static void main(String[] args) { + SpringApplication.run(InfluxDataApplication.class, args); + } + +} diff --git a/influx-data/influx-target/src/main/java/com/njcn/influx/controller/OracleToInfluxDBController.java b/influx-data/influx-target/src/main/java/com/njcn/influx/controller/OracleToInfluxDBController.java new file mode 100644 index 0000000..03c8c64 --- /dev/null +++ b/influx-data/influx-target/src/main/java/com/njcn/influx/controller/OracleToInfluxDBController.java @@ -0,0 +1,116 @@ +package com.njcn.influx.controller; + +import cn.hutool.core.collection.CollectionUtil; +import cn.hutool.core.date.LocalDateTimeUtil; +import cn.hutool.extra.spring.SpringUtil; +import com.njcn.influx.service.InfluxDBBaseService; +import com.njcn.oracle.bo.param.DataAsynParam; +import com.njcn.oracle.bo.param.MigrationParam; +import com.njcn.oracle.mybatis.service.IReplenishMybatisService; +import com.njcn.oracle.service.DataSyncService; +import com.njcn.oracle.util.LocalDateUtil; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiImplicitParam; +import io.swagger.annotations.ApiOperation; +import lombok.AllArgsConstructor; +import lombok.SneakyThrows; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.BeanUtils; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.lang.reflect.Method; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +/** + * Description: + * Date: 2024/1/15 18:47【需求编号】 + * + * @author clam + * @version V1.0.0 + */ +@Validated +@Slf4j +@RestController +@RequestMapping("/data") +@Api(tags = "OracleToInfluxDB数据同步") +@AllArgsConstructor +public class OracleToInfluxDBController { + + private final InfluxDBBaseService influxDBBaseService; + private final DataSyncService dataSyncService; + @PostMapping("/dataSync") + @ApiOperation("数据同步") + @ApiImplicitParam(name = "dataAsynParam", value = "数据同步参数", required = true) + @SneakyThrows + public Boolean dataSync(@RequestBody DataAsynParam dataAsynParam){ + dataAsynParam.getTableNames().stream().forEach(temp->{ + IReplenishMybatisService executor = null; + try { + executor = (IReplenishMybatisService) SpringUtil.getBean(Class.forName("com.njcn.oracle.service.impl." + temp + "ServiceImpl")); + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } + + IReplenishMybatisService finalExecutor = executor; + MigrationParam migration = new MigrationParam(); + + LocalDateTime localDateTime = dataAsynParam.getStartTime().atStartOfDay(); + LocalDateTime tempStartTime = LocalDateTimeUtil.beginOfDay(localDateTime); + LocalDateTime tempEndTime = LocalDateTimeUtil.endOfDay(localDateTime); + + migration.setStartTime(tempStartTime); + migration.setEndTime(tempEndTime); + migration.setStartTime(tempStartTime); + migration.setEndTime(tempEndTime); + List list = finalExecutor.queryData(migration); + if (CollectionUtil.isEmpty(list)) { + return; + } + Class clazz = null; + Class clazz2 = null; + + try { + clazz = Class.forName("com.njcn.influx.bo.po.InfluxDB" + temp); + clazz2 = Class.forName("com.njcn.oracle.bo.po." + temp); + } catch (ClassNotFoundException e) { + throw new RuntimeException(e); + } + Method method = null; + try { + method = clazz.getDeclaredMethod("oralceToInfluxDB",clazz2); + } catch (NoSuchMethodException e) { + throw new RuntimeException(e); + } + method.setAccessible(true); + Method finalMethod = method; + List list1 =(List) list.stream().flatMap(po -> { + try { + + Object invoke = finalMethod.invoke(null,po); + Object invoke1 = invoke; + //返回可能是集合 + return invoke1 instanceof List ? ((List) invoke1).stream() : Stream.of(invoke1); + } catch (Exception e) { + throw new RuntimeException(e); + } + + }).map(item-> (Object) item).collect(Collectors.toList()); + + influxDBBaseService.insertBatchBySlice(list1,5000); + + + }); + + return true;// HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, true, "数据同步"); + } + + +} diff --git a/influx-data/influx-target/src/main/resources/application.yml b/influx-data/influx-target/src/main/resources/application.yml new file mode 100644 index 0000000..1fae368 --- /dev/null +++ b/influx-data/influx-target/src/main/resources/application.yml @@ -0,0 +1,111 @@ +#文件位置配置 +business: + #处理波形数据位置 + # wavePath: C://comtrade + wavePath: /usr/local/comtrade + #处理临时数据 + #tempPath: C://file + tempPath: /usr/local/file + #文件存储的方式 + file: + storage: 3 +microservice: + ename: @artifactId@ + name: oracle-data +#线程池配置信息 +threadPool: + corePoolSize: 10 + maxPoolSize: 20 + queueCapacity: 500 + keepAliveSeconds: 60 +server: + port: 8090 +spring: + #influxDB内容配置 + influx: + url: http://192.168.1.102:8086 + user: admin + password: 123456 + database: pqsbase_zl + mapper-location: com.njcn.influx.imapper + application: + name: oracle-data + autoconfigure: + exclude: com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure + datasource: + dynamic: + druid: + initial-size: 10 + # 初始化大小，最小，最大 + min-idle: 20 + maxActive: 500 + # 配置获取连接等待超时的时间 + maxWait: 60000 + # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 + timeBetweenEvictionRunsMillis: 60000 + # 配置一个连接在池中最小生存的时间，单位是毫秒 + minEvictableIdleTimeMillis: 300000 + testWhileIdle: true + testOnBorrow: true + validation-query: SELECT 1 from dual + testOnReturn: false + # 打开PSCache，并且指定每个连接上PSCache的大小 + poolPreparedStatements: true + maxPoolPreparedStatementPerConnectionSize: 20 + filters: stat,wall + filter: + wall: + config: + multi-statement-allow: true + none-base-statement-allow: true + enabled: true + # 配置DruidStatFilter + web-stat-filter: + enabled: true + url-pattern: "/*" + exclusions: "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*" + # 配置DruidStatViewServlet + stat-view-servlet: + enabled: true + url-pattern: "/druid/*" + # IP白名单(没有配置或者为空，则允许所有访问) + allow: #127.0.0.1,192.168.163.1 + # IP黑名单 (存在共同时，deny优先于allow) + deny: #192.168.1.73 + # 禁用HTML页面上的“Reset All”功能 + reset-enable: false + # 登录名 + login-username: admin + # 登录密码 + login-password: njcnpqs + query-timeout: 36000 + primary: master + strict: false + datasource: + master: + url: jdbc:oracle:thin:@192.168.1.51:1521:pqsbase + username: pqsadmin + password: Pqsadmin123 + driver-class-name: oracle.jdbc.driver.OracleDriver + target: + url: jdbc:oracle:thin:@192.168.1.51:1521:pqsbase + username: pqsadmin_hn + password: pqsadmin + driver-class-name: oracle.jdbc.driver.OracleDriver +#mybatis配置信息 +mybatis-plus: + #别名扫描 + type-aliases-package: com.njcn.oracle.bo + mapper-locations: classpath*:com/njcn/**/mapping/*.xml + configuration: + #驼峰命名 + map-underscore-to-camel-case: true + #配置sql日志输出 +# log-impl: org.apache.ibatis.logging.stdout.StdOutImpl + #关闭日志输出 + log-impl: org.apache.ibatis.logging.nologging.NoLoggingImpl + global-config: + db-config: + #指定主键生成策略 + id-type: assign_uuid + diff --git a/influx-data/influx-target/src/test/java/njcn/BaseJunitTest.java b/influx-data/influx-target/src/test/java/njcn/BaseJunitTest.java new file mode 100644 index 0000000..5e5bc0d --- /dev/null +++ b/influx-data/influx-target/src/test/java/njcn/BaseJunitTest.java @@ -0,0 +1,18 @@ +package njcn; + +import com.njcn.InfluxDataApplication; +import org.junit.runner.RunWith; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.test.context.web.WebAppConfiguration; + +/** + * @author hongawen + * @version 1.0.0 + * @date 2021年12月10日 15:05 + */ +@RunWith(SpringRunner.class) +@WebAppConfiguration +@SpringBootTest(classes = InfluxDataApplication.class) +public class BaseJunitTest { +} diff --git a/influx-data/influx-target/src/test/java/njcn/DataTest.java b/influx-data/influx-target/src/test/java/njcn/DataTest.java new file mode 100644 index 0000000..cfed52d --- /dev/null +++ b/influx-data/influx-target/src/test/java/njcn/DataTest.java @@ -0,0 +1,64 @@ +package njcn; + + +import cn.hutool.core.date.DatePattern; +import cn.hutool.core.date.LocalDateTimeUtil; +import cn.hutool.extra.spring.SpringUtil; +import com.njcn.influx.bo.po.InfluxDBDataFlicker; +import com.njcn.influx.core.InfluxExecutor; +import com.njcn.oracle.bo.param.MigrationParam; +import com.njcn.oracle.bo.po.DataFlicker; +import com.njcn.oracle.mybatis.service.IReplenishMybatisService; +import lombok.SneakyThrows; +import org.junit.Test; +import org.springframework.beans.factory.annotation.Autowired; + +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.time.ZoneOffset; +import java.time.temporal.ChronoUnit; +import java.util.List; +import java.util.stream.Collectors; + +/** + * @author hongawen + * @version 1.0.0 + * @date 2021年12月14日 12:55 + */ +public class DataTest extends BaseJunitTest { + private @Autowired InfluxExecutor interpreter; + + + + @SneakyThrows + @Test + public void testBean() { + LocalDateTime endTime = LocalDateTimeUtil.parse("2023-12-29 15:00:10", DatePattern.NORM_DATETIME_PATTERN); + LocalDateTime startTime = LocalDateTimeUtil.offset(endTime, -24, ChronoUnit.HOURS); + +// LocalDateTime endTime = LocalDateTimeUtil.parse("1970-01-02 00:00:10", DatePattern.NORM_DATETIME_PATTERN); +// LocalDateTime startTime = LocalDateTimeUtil.offset(endTime, -2, ChronoUnit.HOURS); + + MigrationParam migrationParam = new MigrationParam(); + migrationParam.setStartTime(startTime); + migrationParam.setEndTime(endTime); + IReplenishMybatisService executor = (IReplenishMybatisService) SpringUtil.getBean(Class.forName("com.njcn.oracle.service.impl.DataFlickerServiceImpl")); + //查询数据 + List temp1 = executor.queryData(migrationParam); + List collect = temp1.stream().map(temp -> { + InfluxDBDataFlicker dataFlicker = new InfluxDBDataFlicker(); + dataFlicker = InfluxDBDataFlicker.oralceToInfluxDB(temp); + + return dataFlicker; + }).collect(Collectors.toList()); + + Object args[] ={collect}; + interpreter.insert(args); + System.out.println(1111111); + + } + + + +} diff --git a/influx-data/pom.xml b/influx-data/pom.xml index 343c281..a0628fa 100644 --- a/influx-data/pom.xml +++ b/influx-data/pom.xml @@ -8,8 +8,13 @@ data-migration 1.0.0 + pom - 灿能数据迁移mysql目标库 + 灿能数据迁移influx目标库 + + influx-source + influx-target + influx-data