1.配网趋势代码提交

pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/HarmonicHistoryParam.java

@@ -17,6 +17,6 @@ public class HarmonicHistoryParam {
 
     private String valueTypeName;
 
-    private String lineId="16461";
+    private String lineId;
 
 }

pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/zt/HarmonicHistoryC.java

@@ -0,0 +1,212 @@
+package com.njcn.harmonic.pojo.po.zt;
+
+import lombok.Data;
+
+/**
+ * @author wr
+ * @description 华云远程访问返回功率因数实体
+ * @date 2024/1/22 14:59
+ */
+@Data
+public class HarmonicHistoryC {
+    //台区编号
+    private String tg_id;
+    //数据id
+    private String id;
+    //相位标识
+    private Integer phase_flag;
+    //时间
+    private String ds;
+    //功率因数第1个点
+    private Float c1;
+    //功率因数第2个点
+    private Float c2;
+    //功率因数第3个点
+    private Float c3;
+    //功率因数第4个点
+    private Float c4;
+    //功率因数第5个点
+    private Float c5;
+    //功率因数第6个点
+    private Float c6;
+    //功率因数第7个点
+    private Float c7;
+    //功率因数第8个点
+    private Float c8;
+    //功率因数第9个点
+    private Float c9;
+    //功率因数第10个点
+    private Float c10;
+    //功率因数第11个点
+    private Float c11;
+    //功率因数第12个点
+    private Float c12;
+    //功率因数第13个点
+    private Float c13;
+    //功率因数第14个点
+    private Float c14;
+    //功率因数第15个点
+    private Float c15;
+    //功率因数第16个点
+    private Float c16;
+    //功率因数第17个点
+    private Float c17;
+    //功率因数第18个点
+    private Float c18;
+    //功率因数第19个点
+    private Float c19;
+    //功率因数第20个点
+    private Float c20;
+    //功率因数第21个点
+    private Float c21;
+    //功率因数第22个点
+    private Float c22;
+    //功率因数第23个点
+    private Float c23;
+    //功率因数第24个点
+    private Float c24;
+    //功率因数第25个点
+    private Float c25;
+    //功率因数第26个点
+    private Float c26;
+    //功率因数第27个点
+    private Float c27;
+    //功率因数第28个点
+    private Float c28;
+    //功率因数第29个点
+    private Float c29;
+    //功率因数第30个点
+    private Float c30;
+    //功率因数第31个点
+    private Float c31;
+    //功率因数第32个点
+    private Float c32;
+    //功率因数第33个点
+    private Float c33;
+    //功率因数第34个点
+    private Float c34;
+    //功率因数第35个点
+    private Float c35;
+    //功率因数第36个点
+    private Float c36;
+    //功率因数第37个点
+    private Float c37;
+    //功率因数第38个点
+    private Float c38;
+    //功率因数第39个点
+    private Float c39;
+    //功率因数第40个点
+    private Float c40;
+    //功率因数第41个点
+    private Float c41;
+    //功率因数第42个点
+    private Float c42;
+    //功率因数第43个点
+    private Float c43;
+    //功率因数第44个点
+    private Float c44;
+    //功率因数第45个点
+    private Float c45;
+    //功率因数第46个点
+    private Float c46;
+    //功率因数第47个点
+    private Float c47;
+    //功率因数第48个点
+    private Float c48;
+    //功率因数第49个点
+    private Float c49;
+    //功率因数第50个点
+    private Float c50;
+    //功率因数第51个点
+    private Float c51;
+    //功率因数第52个点
+    private Float c52;
+    //功率因数第53个点
+    private Float c53;
+    //功率因数第54个点
+    private Float c54;
+    //功率因数第55个点
+    private Float c55;
+    //功率因数第56个点
+    private Float c56;
+    //功率因数第57个点
+    private Float c57;
+    //功率因数第58个点
+    private Float c58;
+    //功率因数第59个点
+    private Float c59;
+    //功率因数第60个点
+    private Float c60;
+    //功率因数第61个点
+    private Float c61;
+    //功率因数第62个点
+    private Float c62;
+    //功率因数第63个点
+    private Float c63;
+    //功率因数第64个点
+    private Float c64;
+    //功率因数第65个点
+    private Float c65;
+    //功率因数第66个点
+    private Float c66;
+    //功率因数第67个点
+    private Float c67;
+    //功率因数第68个点
+    private Float c68;
+    //功率因数第69个点
+    private Float c69;
+    //功率因数第70个点
+    private Float c70;
+    //功率因数第71个点
+    private Float c71;
+    //功率因数第72个点
+    private Float c72;
+    //功率因数第73个点
+    private Float c73;
+    //功率因数第74个点
+    private Float c74;
+    //功率因数第75个点
+    private Float c75;
+    //功率因数第76个点
+    private Float c76;
+    //功率因数第77个点
+    private Float c77;
+    //功率因数第78个点
+    private Float c78;
+    //功率因数第79个点
+    private Float c79;
+    //功率因数第80个点
+    private Float c80;
+    //功率因数第81个点
+    private Float c81;
+    //功率因数第82个点
+    private Float c82;
+    //功率因数第83个点
+    private Float c83;
+    //功率因数第84个点
+    private Float c84;
+    //功率因数第85个点
+    private Float c85;
+    //功率因数第86个点
+    private Float c86;
+    //功率因数第87个点
+    private Float c87;
+    //功率因数第88个点
+    private Float c88;
+    //功率因数第89个点
+    private Float c89;
+    //功率因数第90个点
+    private Float c90;
+    //功率因数第91个点
+    private Float c91;
+    //功率因数第92个点
+    private Float c92;
+    //功率因数第93个点
+    private Float c93;
+    //功率因数第94个点
+    private Float c94;
+    //功率因数第95个点
+    private Float c95;
+    //功率因数第96个点
+    private Float c96;
+}

pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/zt/HarmonicHistoryP.java

@@ -0,0 +1,213 @@
+package com.njcn.harmonic.pojo.po.zt;
+
+import lombok.Data;
+
+/**
+ * @author wr
+ * @description 华云远程访问返回功率实体
+ * @date 2024/1/22 14:59
+ */
+@Data
+public class HarmonicHistoryP {
+    //台区编号
+    private String tg_id;
+    //数据id
+    private String id;
+    //相位标识 功率类型 1-有功  2-A相有功  3-B相有功  4-C相有功  5-无功  6-A相无功  7-B相无功  8-C相无功
+    private Integer data_type;
+    //时间
+    private String ds;
+    //功率第1个点
+    private Float p1;
+    //功率第2个点
+    private Float p2;
+    //功率第3个点
+    private Float p3;
+    //功率第4个点
+    private Float p4;
+    //功率第5个点
+    private Float p5;
+    //功率第6个点
+    private Float p6;
+    //功率第7个点
+    private Float p7;
+    //功率第8个点
+    private Float p8;
+    //功率第9个点
+    private Float p9;
+    //功率第10个点
+    private Float p10;
+    //功率第11个点
+    private Float p11;
+    //功率第12个点
+    private Float p12;
+    //功率第13个点
+    private Float p13;
+    //功率第14个点
+    private Float p14;
+    //功率第15个点
+    private Float p15;
+    //功率第16个点
+    private Float p16;
+    //功率第17个点
+    private Float p17;
+    //功率第18个点
+    private Float p18;
+    //功率第19个点
+    private Float p19;
+    //功率第20个点
+    private Float p20;
+    //功率第21个点
+    private Float p21;
+    //功率第22个点
+    private Float p22;
+    //功率第23个点
+    private Float p23;
+    //功率第24个点
+    private Float p24;
+    //功率第25个点
+    private Float p25;
+    //功率第26个点
+    private Float p26;
+    //功率第27个点
+    private Float p27;
+    //功率第28个点
+    private Float p28;
+    //功率第29个点
+    private Float p29;
+    //功率第30个点
+    private Float p30;
+    //功率第31个点
+    private Float p31;
+    //功率第32个点
+    private Float p32;
+    //功率第33个点
+    private Float p33;
+    //功率第34个点
+    private Float p34;
+    //功率第35个点
+    private Float p35;
+    //功率第36个点
+    private Float p36;
+    //功率第37个点
+    private Float p37;
+    //功率第38个点
+    private Float p38;
+    //功率第39个点
+    private Float p39;
+    //功率第40个点
+    private Float p40;
+    //功率第41个点
+    private Float p41;
+    //功率第42个点
+    private Float p42;
+    //功率第43个点
+    private Float p43;
+    //功率第44个点
+    private Float p44;
+    //功率第45个点
+    private Float p45;
+    //功率第46个点
+    private Float p46;
+    //功率第47个点
+    private Float p47;
+    //功率第48个点
+    private Float p48;
+    //功率第49个点
+    private Float p49;
+    //功率第50个点
+    private Float p50;
+    //功率第51个点
+    private Float p51;
+    //功率第52个点
+    private Float p52;
+    //功率第53个点
+    private Float p53;
+    //功率第54个点
+    private Float p54;
+    //功率第55个点
+    private Float p55;
+    //功率第56个点
+    private Float p56;
+    //功率第57个点
+    private Float p57;
+    //功率第58个点
+    private Float p58;
+    //功率第59个点
+    private Float p59;
+    //功率第60个点
+    private Float p60;
+    //功率第61个点
+    private Float p61;
+    //功率第62个点
+    private Float p62;
+    //功率第63个点
+    private Float p63;
+    //功率第64个点
+    private Float p64;
+    //功率第65个点
+    private Float p65;
+    //功率第66个点
+    private Float p66;
+    //功率第67个点
+    private Float p67;
+    //功率第68个点
+    private Float p68;
+    //功率第69个点
+    private Float p69;
+    //功率第70个点
+    private Float p70;
+    //功率第71个点
+    private Float p71;
+    //功率第72个点
+    private Float p72;
+    //功率第73个点
+    private Float p73;
+    //功率第74个点
+    private Float p74;
+    //功率第75个点
+    private Float p75;
+    //功率第76个点
+    private Float p76;
+    //功率第77个点
+    private Float p77;
+    //功率第78个点
+    private Float p78;
+    //功率第79个点
+    private Float p79;
+    //功率第80个点
+    private Float p80;
+    //功率第81个点
+    private Float p81;
+    //功率第82个点
+    private Float p82;
+    //功率第83个点
+    private Float p83;
+    //功率第84个点
+    private Float p84;
+    //功率第85个点
+    private Float p85;
+    //功率第86个点
+    private Float p86;
+    //功率第87个点
+    private Float p87;
+    //功率第88个点
+    private Float p88;
+    //功率第89个点
+    private Float p89;
+    //功率第90个点
+    private Float p90;
+    //功率第91个点
+    private Float p91;
+    //功率第92个点
+    private Float p92;
+    //功率第93个点
+    private Float p93;
+    //功率第94个点
+    private Float p94;
+    //功率第95个点
+    private Float p95;
+    //功率第96个点
+    private Float p96;
+
+}

pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/zt/HarmonicHistoryV.java

@@ -0,0 +1,214 @@
+package com.njcn.harmonic.pojo.po.zt;
+
+import lombok.Data;
+
+/**
+ * @author wr
+ * @description 华云远程访问返回电压实体
+ * @date 2024/1/15 10:18
+ */
+@Data
+public class HarmonicHistoryV {
+    //台区编号
+    private String tg_id;
+    //数据id
+    private String id;
+    //相位标识
+    private Integer phase_flag;
+    //时间
+    private String ds;
+    //变比
+    private Float pt;
+    //电压第1个点
+    private Float u1;
+    //电压第2个点
+    private Float u2;
+    //电压第3个点
+    private Float u3;
+    //电压第4个点
+    private Float u4;
+    //电压第5个点
+    private Float u5;
+    //电压第6个点
+    private Float u6;
+    //电压第7个点
+    private Float u7;
+    //电压第8个点
+    private Float u8;
+    //电压第9个点
+    private Float u9;
+    //电压第10个点
+    private Float u10;
+    //电压第11个点
+    private Float u11;
+    //电压第12个点
+    private Float u12;
+    //电压第13个点
+    private Float u13;
+    //电压第14个点
+    private Float u14;
+    //电压第15个点
+    private Float u15;
+    //电压第16个点
+    private Float u16;
+    //电压第17个点
+    private Float u17;
+    //电压第18个点
+    private Float u18;
+    //电压第19个点
+    private Float u19;
+    //电压第20个点
+    private Float u20;
+    //电压第21个点
+    private Float u21;
+    //电压第22个点
+    private Float u22;
+    //电压第23个点
+    private Float u23;
+    //电压第24个点
+    private Float u24;
+    //电压第25个点
+    private Float u25;
+    //电压第26个点
+    private Float u26;
+    //电压第27个点
+    private Float u27;
+    //电压第28个点
+    private Float u28;
+    //电压第29个点
+    private Float u29;
+    //电压第30个点
+    private Float u30;
+    //电压第31个点
+    private Float u31;
+    //电压第32个点
+    private Float u32;
+    //电压第33个点
+    private Float u33;
+    //电压第34个点
+    private Float u34;
+    //电压第35个点
+    private Float u35;
+    //电压第36个点
+    private Float u36;
+    //电压第37个点
+    private Float u37;
+    //电压第38个点
+    private Float u38;
+    //电压第39个点
+    private Float u39;
+    //电压第40个点
+    private Float u40;
+    //电压第41个点
+    private Float u41;
+    //电压第42个点
+    private Float u42;
+    //电压第43个点
+    private Float u43;
+    //电压第44个点
+    private Float u44;
+    //电压第45个点
+    private Float u45;
+    //电压第46个点
+    private Float u46;
+    //电压第47个点
+    private Float u47;
+    //电压第48个点
+    private Float u48;
+    //电压第49个点
+    private Float u49;
+    //电压第50个点
+    private Float u50;
+    //电压第51个点
+    private Float u51;
+    //电压第52个点
+    private Float u52;
+    //电压第53个点
+    private Float u53;
+    //电压第54个点
+    private Float u54;
+    //电压第55个点
+    private Float u55;
+    //电压第56个点
+    private Float u56;
+    //电压第57个点
+    private Float u57;
+    //电压第58个点
+    private Float u58;
+    //电压第59个点
+    private Float u59;
+    //电压第60个点
+    private Float u60;
+    //电压第61个点
+    private Float u61;
+    //电压第62个点
+    private Float u62;
+    //电压第63个点
+    private Float u63;
+    //电压第64个点
+    private Float u64;
+    //电压第65个点
+    private Float u65;
+    //电压第66个点
+    private Float u66;
+    //电压第67个点
+    private Float u67;
+    //电压第68个点
+    private Float u68;
+    //电压第69个点
+    private Float u69;
+    //电压第70个点
+    private Float u70;
+    //电压第71个点
+    private Float u71;
+    //电压第72个点
+    private Float u72;
+    //电压第73个点
+    private Float u73;
+    //电压第74个点
+    private Float u74;
+    //电压第75个点
+    private Float u75;
+    //电压第76个点
+    private Float u76;
+    //电压第77个点
+    private Float u77;
+    //电压第78个点
+    private Float u78;
+    //电压第79个点
+    private Float u79;
+    //电压第80个点
+    private Float u80;
+    //电压第81个点
+    private Float u81;
+    //电压第82个点
+    private Float u82;
+    //电压第83个点
+    private Float u83;
+    //电压第84个点
+    private Float u84;
+    //电压第85个点
+    private Float u85;
+    //电压第86个点
+    private Float u86;
+    //电压第87个点
+    private Float u87;
+    //电压第88个点
+    private Float u88;
+    //电压第89个点
+    private Float u89;
+    //电压第90个点
+    private Float u90;
+    //电压第91个点
+    private Float u91;
+    //电压第92个点
+    private Float u92;
+    //电压第93个点
+    private Float u93;
+    //电压第94个点
+    private Float u94;
+    //电压第95个点
+    private Float u95;
+    //电压第96个点
+    private Float u96;
+}

pqs-harmonic/harmonic-boot/pom.xml

@@ -65,6 +65,35 @@
             <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
             <version>3.5.1</version>
         </dependency>
+
+        <!-- 多数据源切换，当数据源为oracle时需要使用 -->
+        <dependency>
+            <groupId>com.baomidou</groupId>
+            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
+            <version>${dynamic-datasource.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.oracle.database.jdbc</groupId>
+            <artifactId>ojdbc8</artifactId>
+            <version>${oracle.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.oracle.database.nls</groupId>
+            <artifactId>orai18n</artifactId>
+            <version>${orai18n.version}</version>
+        </dependency>
+
+        <!-- 华云数据中台调用sdk -->
+        <dependency>
+            <groupId>com.huawei.apigateway</groupId>
+            <artifactId>java-sdk-core</artifactId>
+            <version>3.0.10</version>
+        </dependency>
+        <dependency>
+            <groupId>org.joda.time</groupId>
+            <artifactId>joda-time</artifactId>
+            <version>2.9.9</version>
+        </dependency>
     </dependencies>
 
     <build>

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/controller/HistoryResultController.java

@@ -18,13 +18,15 @@ import com.njcn.harmonic.pojo.vo.StatHarmonicOrgVO;
 import com.njcn.harmonic.service.HistoryResultService;
 import com.njcn.harmonic.service.IRStatLimitRateDService;
 import com.njcn.harmonic.service.IRStatLimitTargetDService;
+import com.njcn.harmonic.service.OracleResultService;
 import com.njcn.influx.pojo.dto.HarmHistoryDataDTO;
 import com.njcn.web.controller.BaseController;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiImplicitParam;
 import io.swagger.annotations.ApiOperation;
-import lombok.AllArgsConstructor;
+import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -43,12 +45,16 @@ import java.util.List;
 @RestController
 @RequestMapping("/harmonic")
 @Api(tags = "稳态数据分析")
-@AllArgsConstructor
+@RequiredArgsConstructor
 public class HistoryResultController extends BaseController {
 
     private final HistoryResultService historyResultService;
     private final IRStatLimitTargetDService limitTargetDService;
     private final IRStatLimitRateDService limitRateDService;
+    private final OracleResultService oracleResultService;
+
+    @Value("${History.DataSource}")
+    private Integer HistoryDataSource;
 
     @OperateInfo(info = LogEnum.BUSINESS_COMMON)
     @PostMapping("/getHistoryResult")
@@ -56,7 +62,12 @@ public class HistoryResultController extends BaseController {
     @ApiImplicitParam(name = "historyParam", value = "稳态数据分析参数", required = true)
     public HttpResult<List<HistoryDataResultVO>> getHistoryResult(@RequestBody @Validated HistoryParam historyParam) {
         String methodDescribe = getMethodDescribe("getHistoryResult");
-        List<HistoryDataResultVO> list = historyResultService.getHistoryResult(historyParam);
+        List<HistoryDataResultVO> list;
+        if (HistoryDataSource == 1) {
+            list = oracleResultService.getHistoryResult(historyParam);
+        } else {
+            list = historyResultService.getHistoryResult(historyParam);
+        }
         return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe);
     }
 

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/mapper/HistoryDataMapper.java

@@ -1,13 +1,13 @@
 package com.njcn.harmonic.mapper;
 
-//import com.baomidou.dynamic.datasource.annotation.DS;
+import com.baomidou.dynamic.datasource.annotation.DS;
 import com.njcn.harmonic.pojo.param.HarmonicHistoryParam;
 import com.njcn.influx.pojo.bo.HarmonicHistoryData;
 import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 
-//@DS("oracle")
+@DS("oracle")
 public interface HistoryDataMapper{
 	//相电压有效值
 	List<HarmonicHistoryData> getDataV(@Param("param") HarmonicHistoryParam param);

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/OracleResultService.java

@@ -11,9 +11,11 @@ import java.util.List;
  * @date 2024/1/11 16:14
  */
 public interface OracleResultService {
-
+    /**
-
+     * 河北主配网趋势图
+     * @param historyParam
+     * @return
+     */
     List<HistoryDataResultVO> getHistoryResult(HistoryParam historyParam);
 
-    List<HistoryDataResultVO> getHistoryResult2(HistoryParam historyParam);
 }

pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/OracleResultServiceImpl.java

@@ -1,10 +1,17 @@
 package com.njcn.harmonic.service.impl;
 
 import cn.hutool.core.bean.BeanUtil;
+import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.date.DatePattern;
+import cn.hutool.core.date.LocalDateTimeUtil;
+import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.alibaba.fastjson.JSON;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.cloud.apigateway.sdk.utils.Client;
+import com.cloud.apigateway.sdk.utils.Request;
 import com.njcn.common.utils.PubUtils;
 import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
 import com.njcn.device.biz.pojo.dto.LineDevGetDTO;
@@ -17,6 +24,9 @@ import com.njcn.harmonic.mapper.HistoryDataMapper;
 import com.njcn.harmonic.pojo.QueryResultLimitVO;
 import com.njcn.harmonic.pojo.param.HarmonicHistoryParam;
 import com.njcn.harmonic.pojo.param.HistoryParam;
+import com.njcn.harmonic.pojo.po.zt.HarmonicHistoryC;
+import com.njcn.harmonic.pojo.po.zt.HarmonicHistoryP;
+import com.njcn.harmonic.pojo.po.zt.HarmonicHistoryV;
 import com.njcn.harmonic.pojo.vo.EventDetailVO;
 import com.njcn.harmonic.pojo.vo.HistoryDataResultVO;
 import com.njcn.harmonic.service.OracleResultService;
@@ -24,13 +34,26 @@ import com.njcn.influx.pojo.bo.HarmonicHistoryData;
 import com.njcn.influx.pojo.constant.InfluxDBTableConstant;
 import com.njcn.system.api.DicDataFeignClient;
 import com.njcn.system.pojo.po.DictData;
-import lombok.AllArgsConstructor;
+import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.http.Header;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpResponse;
+import org.apache.http.client.methods.HttpRequestBase;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.util.EntityUtils;
 import org.springframework.stereotype.Service;
 
+import java.io.IOException;
+import java.lang.reflect.Field;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
+import java.time.Duration;
 import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
 import java.time.format.DateTimeFormatter;
 import java.util.*;
 import java.util.stream.Collectors;
@@ -41,7 +64,8 @@ import java.util.stream.Collectors;
  * @date 2024/1/11 16:15
  */
 @Service
-@AllArgsConstructor
+@Slf4j
+@RequiredArgsConstructor
 public class OracleResultServiceImpl implements OracleResultService {
     private final EventDetailFeignClient eventDetailFeignClient;
     private final CommTerminalGeneralClient commTerminalGeneralClient;
@@ -86,22 +110,6 @@ public class OracleResultServiceImpl implements OracleResultService {
         return historyDataResultVOList;
     }
 
-    @Override
-    public List<HistoryDataResultVO> getHistoryResult2(HistoryParam historyParam) {
-       HarmonicHistoryParam param=new HarmonicHistoryParam();
-        param.setStartTime("2023-12-01 00:00:00");
-        param.setEndTime("2023-12-01 23:59:59");
-        param.setValueTypeName("");
-        List<HarmonicHistoryData> data_v = HistoryDataMapper.getDataFluc(param);
-        param.setValueTypeName("MAX");
-        List<HarmonicHistoryData> data_v2 = HistoryDataMapper.getDataFluc(param);
-        param.setValueTypeName("MIN");
-        List<HarmonicHistoryData> data_v3 = HistoryDataMapper.getDataFluc(param);
-        param.setValueTypeName("CP95");
-        List<HarmonicHistoryData> data_v4 = HistoryDataMapper.getDataFluc(param);
-
-        return null;
-    }
 
     @SneakyThrows
     private HistoryDataResultVO getCondition(String startTime, String endTime, String lineId, String contion, Integer number, Integer valueType, Integer ptType) {
@@ -214,7 +222,6 @@ public class OracleResultServiceImpl implements OracleResultService {
         if (!lineId.isEmpty()) {
             Float topLimit = 0f;
             Float lowerLimit = 0f;
-            Integer type=0;
             //获取监测点信息
             LineDevGetDTO lineDetailDataVO = commTerminalGeneralClient.getMonitorDetail(lineId).getData();
             //获取限值
@@ -222,7 +229,6 @@ public class OracleResultServiceImpl implements OracleResultService {
             if(Objects.isNull(overlimit)){
                 //对配网没有限值的统一处理
                 DictData dictData = dicDataFeignClient.getDicDataById(lineDetailDataVO.getVoltageLevel()).getData();
-                type=1;
                 float voltageLevel = Float.parseFloat(dictData.getValue());
                 float shortVal = COverlimitUtil.getDlCapByVoltageLevel(voltageLevel);
                 overlimit = COverlimitUtil.globalAssemble(voltageLevel,10f,10f,shortVal,1,1);
@@ -615,11 +621,20 @@ public class OracleResultServiceImpl implements OracleResultService {
             //2、一次查询返回一条记录，以T相为条件，返回某3个指标值
             //3、一次查询返回一条记录，以T相为条件，返回某1个指标值
             HarmonicHistoryParam historyParam=new HarmonicHistoryParam();
+            if(lineDetailDataVO.getOracleLineId()!=null){
+                //当oracle监测点不为空说明是主网监测点
                 historyParam.setStartTime(startTime+InfluxDBTableConstant.START_TIME);
                 historyParam.setEndTime(endTime+InfluxDBTableConstant.END_TIME);
                 historyParam.setValueTypeName(valueTypeName);
+                historyParam.setLineId(lineDetailDataVO.getOracleLineId().toString());
+            }else{
+                //就是配网监测点
+                historyParam.setStartTime(startTime.replace("-",""));
+                historyParam.setEndTime(endTime.replace("-",""));
+                historyParam.setValueTypeName(valueTypeName);
                 historyParam.setLineId(lineId);
-            queryResultLimitVO.setHarmonicHistoryDataList(setHistoryDataList(historyParam,contion,number,type));
+            }
+            queryResultLimitVO.setHarmonicHistoryDataList(setHistoryDataList(historyParam, contion, number,lineDetailDataVO.getType()));
             queryResultLimitVO.setTopLimit(topLimit);
             queryResultLimitVO.setLowerLimit(lowerLimit);
             queryResultLimitVO.setPhaiscType(phasicType);
@@ -645,7 +660,12 @@ public class OracleResultServiceImpl implements OracleResultService {
         List<HarmonicHistoryData> harmonicHistoryData = new ArrayList<>();
         switch (Integer.parseInt(contion)) {
             case 10:
-                harmonicHistoryData=HistoryDataMapper.getDataFluc(historyParam);
+                //相电压有效值
+                if(type==0){
+                    harmonicHistoryData=HistoryDataMapper.getDataV(historyParam);
+                }else{
+                    harmonicHistoryData=ztHarmonicHistoryV(historyParam);
+                }
                 break;
             case 11:
                 //线电压有效值
@@ -708,12 +728,12 @@ public class OracleResultServiceImpl implements OracleResultService {
                 harmonicHistoryData=HistoryDataMapper.getDataHarmphasic_i(historyParam,number);
                 break;
             case 46:
-                //间谐波电压含有率
+                //todo 间谐波电压含有率
-
+                harmonicHistoryData=HistoryDataMapper.getDataInharmrateV_v(historyParam,number);
                 break;
             case 47:
-                //间谐波电流含有率
+                //todo 间谐波电流含有率
-
+                harmonicHistoryData=HistoryDataMapper.getDataInharmrateI_i(historyParam,number);
                 break;
             case 48:
                 //间谐波电压幅值
@@ -725,11 +745,19 @@ public class OracleResultServiceImpl implements OracleResultService {
                 break;
             case 50:
                 //谐波有功功率
+                if(type==0) {
                     harmonicHistoryData = HistoryDataMapper.getDataHarmpowerP_p(historyParam, number);
+                }else{
+                    harmonicHistoryData =ztHarmonicHistoryP(historyParam,1);
+                }
                 break;
             case 51:
                 //谐波无功功率
+                if(type==0) {
                     harmonicHistoryData=HistoryDataMapper.getDataHarmpowerQ_q(historyParam,number);
+                }else{
+                    harmonicHistoryData =ztHarmonicHistoryP(historyParam,0);
+                }
                 break;
             case 52:
                 //谐波视在功率
@@ -761,7 +789,11 @@ public class OracleResultServiceImpl implements OracleResultService {
                 break;
             case 59:
                 //视在功率因数
+                if(type==0) {
                     harmonicHistoryData=HistoryDataMapper.getDataHarmpowerP_pf(historyParam);
+                }else{
+                    harmonicHistoryData =ztHarmonicHistoryC(historyParam);
+                }
                 break;
             case 591:
                 //位移功率因数
@@ -812,4 +844,407 @@ public class OracleResultServiceImpl implements OracleResultService {
         }
         return  ding;
     }
+    //电压
+    private List<HarmonicHistoryData> ztHarmonicHistoryV(HarmonicHistoryParam historyParam) {
+        String id = historyParam.getLineId();
+        String starTime = historyParam.getStartTime();
+        String endTime = historyParam.getEndTime();
+        String key = "0e3bac160fd246f181ad4fd47da6929a";
+        String secret = "383b4b2536234d84ac909cd605762061";
+        String url = "http://8d051549520e423ab8dccf8b3d457c74.apigw.he-region-2.sgic.sgcc.com.cn/ast/ydxxcjxt/dws/get_e_mp_TGvol_zl_ds";
+        String apiId = "46e61646481c0146e26ba79bb5c8fa05";
+        String apiName = "电能质量谐波监测系统_分布式光伏台区电压日数据_e_mp_TGvol_zl_时间";
+        List<HarmonicHistoryV> harmonicHistory = adsDiList(HarmonicHistoryV.class, id, starTime, endTime, key, secret, url, apiId, apiName);
+        return ztDataV(harmonicHistory);
+    }
+    //1:有功 0:无功
+    private List<HarmonicHistoryData> ztHarmonicHistoryP(HarmonicHistoryParam historyParam,Integer type) {
+        String id = historyParam.getLineId();
+        String starTime = historyParam.getStartTime();
+        String endTime = historyParam.getEndTime();
+        String key = "0e3bac160fd246f181ad4fd47da6929a";
+        String secret = "383b4b2536234d84ac909cd605762061";
+        String url = "http://8d051549520e423ab8dccf8b3d457c74.apigw.he-region-2.sgic.sgcc.com.cn/ast/ydxxcjxt/dws/get_e_mp_TGpower_zl_ds";
+        String apiId = "9db49fdc30dbc3bf6fa4f5cce141416c";
+        String apiName = "get_电能质量谐波监测系统_分布式光伏台区功率日数据_e_mp_TGpower_zl_时间";
+        List<HarmonicHistoryP> harmonicHistory = adsDiList(HarmonicHistoryP.class, id, starTime, endTime, key, secret, url, apiId, apiName);
+        return ztDataP(harmonicHistory,type);
+    }
+    //功率因数
+    private List<HarmonicHistoryData> ztHarmonicHistoryC(HarmonicHistoryParam historyParam) {
+        String id = historyParam.getLineId();
+        String starTime = historyParam.getStartTime();
+        String endTime = historyParam.getEndTime();
+        String key = "0e3bac160fd246f181ad4fd47da6929a";
+        String secret = "383b4b2536234d84ac909cd605762061";
+        String url = "http://8d051549520e423ab8dccf8b3d457c74.apigw.he-region-2.sgic.sgcc.com.cn/ast/ydxxcjxt/dws/get_e_mp_TGfactor_zl_ds";
+        String apiId = "9c3ebd9c19dc0eb8e24385e40bd50a53";
+        String apiName = "get_电能质量谐波监测系统_分布式光伏台区功率因数日数据_e_mp_TGfactor_zl_时间";
+        List<HarmonicHistoryC> harmonicHistory = adsDiList(HarmonicHistoryC.class, id, starTime, endTime, key, secret, url, apiId, apiName);
+        return ztDataC(harmonicHistory);
+    }
+
+    /**
+     * @Description: 河北华云中台远程访问信息
+     * @return: java.util.List<com.njcn.harmonic.pojo.po.HarmonicHistory>
+     * @Author: wr
+     * @Date: 2024/1/15 10:20
+     */
+    private  <T> List<T>  adsDiList(Class<T> t,String id, String starTime, String endTime,String key,String secret, String url,String apiId,String apiName) {
+        List<T> aas = new ArrayList<>();
+        Request request = new Request();
+        CloseableHttpClient client = null;
+        try {
+            request.setKey(key);
+            request.setSecret(secret);
+            //接口访问类型
+            request.setMethod("GET");
+            //接口访问url
+            request.setUrl(url);
+            //API中 header头传输的参数
+            request.addHeader("x-api-id", apiId);
+            //API中 Query传输的参数
+            request.addQueryStringParam("tg_id", id);
+            request.addQueryStringParam("startTime", starTime);
+            request.addQueryStringParam("endTime",starTime);
+            //API中 Body体参数
+            //request.setBody("demo");
+        } catch (Exception e) {
+            log.error(Thread.currentThread().getName() + "链接" + apiName + "失败");
+            e.printStackTrace();
+        }
+        try {
+            HttpRequestBase signedRequest = Client.sign(request);
+            Header[] authorization = signedRequest.getHeaders("Authorization");
+            signedRequest.addHeader("x-Authorization", authorization[0].getValue());
+
+            //Send the request.
+            client = HttpClients.custom().build();
+            HttpResponse response = client.execute(signedRequest);
+
+            //Print the status line of the response.
+            log.info(response.getStatusLine().toString());
+
+            //Print the header fields of the response.
+            Header[] resHeaders = response.getAllHeaders();
+            for (Header h : resHeaders) {
+                log.info(h.getName() + ":" + h.getValue());
+            }
+
+            //Print the body of the response.
+            HttpEntity resEntity = response.getEntity();
+            if (resEntity != null) {
+                String s = EntityUtils.toString(resEntity, "UTF-8");
+                log.info(System.getProperty("line.separator") + s);
+                JSONObject jsonObject = JSON.parseObject(s);
+                String errCode = jsonObject.getString("errCode");
+                if(StrUtil.isBlank(errCode)){
+                    Map data = jsonObject.getObject("data", Map.class);
+                    aas = JSONArray.parseArray(data.get("data").toString(), t);
+                    log.info(Thread.currentThread().getName() + "获取日报表数据多少条 adsDiList：" + aas.size() + "结束----！");
+                }else if("DLM.4094".equals(errCode)){
+                    log.info(Thread.currentThread().getName() + "数据链接超时" + s + "结束----！");
+                }
+
+            }
+        } catch (Exception e) {
+            log.error(Thread.currentThread().getName() + "链接" + apiName + "失败");
+            e.printStackTrace();
+        } finally {
+            try {
+                if (client != null) {
+                    client.close();
+                }
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+        return aas;
+    }
+
+    /**
+     * @Description: 中台电压信息格式转换
+     * @param value
+     * @return: java.util.List<com.njcn.influx.pojo.bo.HarmonicHistoryData>
+     * @Author: wr
+     * @Date: 2024/1/22 15:25
+     */
+    private  List<HarmonicHistoryData> ztDataV(List<HarmonicHistoryV> value) {
+        List<HarmonicHistoryData> info=new ArrayList<>();
+        HarmonicHistoryData d;
+        //a
+        List<HarmonicHistoryV> a = value.stream().filter(x -> x.getPhase_flag() == 1).distinct().collect(Collectors.toList());
+        //b
+        List<HarmonicHistoryV> b = value.stream().filter(x -> x.getPhase_flag() == 2).distinct().collect(Collectors.toList());
+        //c
+        List<HarmonicHistoryV> c = value.stream().filter(x -> x.getPhase_flag() == 3).distinct().collect(Collectors.toList());
+        Integer num=97;
+        //15分钟增加信息
+        Duration duration = Duration.ofMinutes(15);
+        //初始化是从0点开始，23:45结束
+        //A相
+        if(CollUtil.isNotEmpty(a)){
+            for (HarmonicHistoryV harmonicHistoryV : a) {
+                String ds = harmonicHistoryV.getDs();
+                LocalDateTime parse = LocalDateTimeUtil.parse(ds, DatePattern.PURE_DATE_PATTERN);
+                for (Integer i = 1; i < num; i++) {
+                    //A相
+                    d=new HarmonicHistoryData();
+                    if(i>1){
+                        parse = parse.plus(duration);
+                    }
+                    d.setTimeId(parse.toInstant(ZoneOffset.UTC));
+                    d.setPhasicType("A");
+                    d.setAValue(reflectDataV(harmonicHistoryV,"u"+i));
+                    info.add(d);
+                }
+            }
+        }
+        //B相
+        if(CollUtil.isNotEmpty(b)){
+            for (HarmonicHistoryV harmonicHistoryV : b) {
+                String ds = harmonicHistoryV.getDs();
+                LocalDateTime parse = LocalDateTimeUtil.parse(ds, DatePattern.PURE_DATE_PATTERN);
+                for (Integer i = 1; i < num; i++) {
+                    d=new HarmonicHistoryData();
+                    if(i>1){
+                        parse = parse.plus(duration);
+                    }
+                    d.setTimeId(parse.toInstant(ZoneOffset.UTC));
+                    d.setPhasicType("B");
+                    d.setAValue(reflectDataV(harmonicHistoryV,"u"+i));
+                    info.add(d);
+                }
+
+            }
+        }
+        //C相
+        if(CollUtil.isNotEmpty(c)){
+            for (HarmonicHistoryV harmonicHistoryV : c) {
+                String ds = harmonicHistoryV.getDs();
+                LocalDateTime parse = LocalDateTimeUtil.parse(ds, DatePattern.PURE_DATE_PATTERN);
+                for (Integer i = 1; i < num; i++) {
+                    d=new HarmonicHistoryData();
+                    if(i>1){
+                        parse = parse.plus(duration);
+                    }
+                    d.setTimeId(parse.toInstant(ZoneOffset.UTC));
+                    d.setPhasicType("C");
+                    d.setAValue(reflectDataV(harmonicHistoryV,"u"+i));
+                    info.add(d);
+                }
+
+            }
+        }
+        return info;
+    }
+
+    private static Float reflectDataV(HarmonicHistoryV dateV, String attribute){
+        Field field;
+        try {
+            field = dateV.getClass().getDeclaredField(attribute);
+            field.setAccessible(true);
+            Float aFloat = (Float) field.get(dateV);
+            if(ObjectUtil.isNotNull(aFloat)){
+                return aFloat;
+            }
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+        return 0.0F;
+    }
+
+    /**
+     * 中台功率信息格式转换
+     * @param value
+     * @param type
+     * @return
+     */
+    private  List<HarmonicHistoryData> ztDataP(List<HarmonicHistoryP> value,Integer type) {
+        List<HarmonicHistoryData> info=new ArrayList<>();
+        HarmonicHistoryData d;
+        //a
+        List<HarmonicHistoryP> a;
+        //b
+        List<HarmonicHistoryP> b;
+        //c
+        List<HarmonicHistoryP> c;
+        //1:有功 0:无功
+        if(type==1){
+            a = value.stream().filter(x -> x.getData_type() == 2).distinct().collect(Collectors.toList());
+            b = value.stream().filter(x -> x.getData_type() == 3).distinct().collect(Collectors.toList());
+            c = value.stream().filter(x -> x.getData_type() == 4).distinct().collect(Collectors.toList());
+        }else{
+            a = value.stream().filter(x -> x.getData_type() == 6).distinct().collect(Collectors.toList());
+            b = value.stream().filter(x -> x.getData_type() == 7).distinct().collect(Collectors.toList());
+            c = value.stream().filter(x -> x.getData_type() == 8).distinct().collect(Collectors.toList());
+        }
+        Integer num=97;
+        //15分钟增加信息
+        Duration duration = Duration.ofMinutes(15);
+        //初始化是从0点开始，23:45结束
+        //A相
+        if(CollUtil.isNotEmpty(a)){
+            for (HarmonicHistoryP harmonicHistoryP : a) {
+                String ds = harmonicHistoryP.getDs();
+                LocalDateTime parse = LocalDateTimeUtil.parse(ds, DatePattern.PURE_DATE_PATTERN);
+                for (Integer i = 1; i < num; i++) {
+                    //A相
+                    d=new HarmonicHistoryData();
+                    if(i>1){
+                        parse = parse.plus(duration);
+                    }
+                    d.setTimeId(parse.toInstant(ZoneOffset.UTC));
+                    d.setPhasicType("A");
+                    d.setAValue(reflectDataP(harmonicHistoryP,"u"+i));
+                    info.add(d);
+                }
+            }
+        }
+        //B相
+        if(CollUtil.isNotEmpty(b)){
+            for (HarmonicHistoryP harmonicHistoryP : b) {
+                String ds = harmonicHistoryP.getDs();
+                LocalDateTime parse = LocalDateTimeUtil.parse(ds, DatePattern.PURE_DATE_PATTERN);
+                for (Integer i = 1; i < num; i++) {
+                    d=new HarmonicHistoryData();
+                    if(i>1){
+                        parse = parse.plus(duration);
+                    }
+                    d.setTimeId(parse.toInstant(ZoneOffset.UTC));
+                    d.setPhasicType("B");
+                    d.setAValue(reflectDataP(harmonicHistoryP,"u"+i));
+                    info.add(d);
+                }
+
+            }
+        }
+        //C相
+        if(CollUtil.isNotEmpty(c)){
+            for (HarmonicHistoryP harmonicHistoryP : c) {
+                String ds = harmonicHistoryP.getDs();
+                LocalDateTime parse = LocalDateTimeUtil.parse(ds, DatePattern.PURE_DATE_PATTERN);
+                for (Integer i = 1; i < num; i++) {
+                    d=new HarmonicHistoryData();
+                    if(i>1){
+                        parse = parse.plus(duration);
+                    }
+                    d.setTimeId(parse.toInstant(ZoneOffset.UTC));
+                    d.setPhasicType("C");
+                    d.setAValue(reflectDataP(harmonicHistoryP,"u"+i));
+                    info.add(d);
+                }
+
+            }
+        }
+        return info;
+    }
+
+    private static Float reflectDataP(HarmonicHistoryP dateP, String attribute) {
+        Field field;
+        try {
+            field = dateP.getClass().getDeclaredField(attribute);
+            field.setAccessible(true);
+            Float aFloat = (Float) field.get(dateP);
+            if(ObjectUtil.isNotNull(aFloat)){
+                return aFloat;
+            }
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+
+        return 0.0F;
+    }
+
+    /**
+     * 中台功率因数信息格式转换
+     * @param value
+     * @return
+     */
+    private  List<HarmonicHistoryData> ztDataC(List<HarmonicHistoryC> value) {
+        List<HarmonicHistoryData> info=new ArrayList<>();
+        HarmonicHistoryData d;
+        //a
+        List<HarmonicHistoryC> a= value.stream().filter(x -> x.getPhase_flag() == 1).collect(Collectors.toList());
+        //b
+        List<HarmonicHistoryC> b= value.stream().filter(x -> x.getPhase_flag() == 2).distinct().collect(Collectors.toList());
+        //c
+        List<HarmonicHistoryC> c= value.stream().filter(x -> x.getPhase_flag() == 3).distinct().collect(Collectors.toList());
+
+        Integer num=97;
+        //15分钟增加信息
+        Duration duration = Duration.ofMinutes(15);
+        //初始化是从0点开始，23:45结束
+        //A相
+        if(CollUtil.isNotEmpty(a)){
+            for (HarmonicHistoryC harmonicHistoryC : a) {
+                String ds = harmonicHistoryC.getDs();
+                LocalDateTime parse = LocalDateTimeUtil.parse(ds, DatePattern.PURE_DATE_PATTERN);
+                for (Integer i = 1; i < num; i++) {
+                    //A相
+                    d=new HarmonicHistoryData();
+                    if(i>1){
+                        parse = parse.plus(duration);
+                    }
+                    d.setTimeId(parse.toInstant(ZoneOffset.UTC));
+                    d.setPhasicType("A");
+                    d.setAValue(reflectDataC(harmonicHistoryC,"u"+i));
+                    info.add(d);
+                }
+            }
+        }
+        //B相
+        if(CollUtil.isNotEmpty(b)){
+            for (HarmonicHistoryC harmonicHistoryC : b) {
+                String ds = harmonicHistoryC.getDs();
+                LocalDateTime parse = LocalDateTimeUtil.parse(ds, DatePattern.PURE_DATE_PATTERN);
+                for (Integer i = 1; i < num; i++) {
+                    d=new HarmonicHistoryData();
+                    if(i>1){
+                        parse = parse.plus(duration);
+                    }
+                    d.setTimeId(parse.toInstant(ZoneOffset.UTC));
+                    d.setPhasicType("B");
+                    d.setAValue(reflectDataC(harmonicHistoryC,"u"+i));
+                    info.add(d);
+                }
+
+            }
+        }
+        //C相
+        if(CollUtil.isNotEmpty(c)){
+            for (HarmonicHistoryC harmonicHistoryC : c) {
+                String ds = harmonicHistoryC.getDs();
+                LocalDateTime parse = LocalDateTimeUtil.parse(ds, DatePattern.PURE_DATE_PATTERN);
+                for (Integer i = 1; i < num; i++) {
+                    d=new HarmonicHistoryData();
+                    if(i>1){
+                        parse = parse.plus(duration);
+                    }
+                    d.setTimeId(parse.toInstant(ZoneOffset.UTC));
+                    d.setPhasicType("C");
+                    d.setAValue(reflectDataC(harmonicHistoryC,"u"+i));
+                    info.add(d);
+                }
+
+            }
+        }
+        return info;
+    }
+
+    private static Float reflectDataC(HarmonicHistoryC dateC, String attribute) {
+        Field field;
+        try {
+            field = dateC.getClass().getDeclaredField(attribute);
+            field.setAccessible(true);
+            Float aFloat = (Float) field.get(dateC);
+            if(ObjectUtil.isNotNull(aFloat)){
+                return aFloat;
+            }
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+
+        return 0.0F;
+    }
 }

pqs-harmonic/harmonic-boot/src/main/resources/bootstrap.yml

@@ -30,7 +30,8 @@ spring:
         shared-configs:
           - data-id: share-config.yaml
             refresh: true
-          - data-Id: share-config-datasource-db.yaml
+#          - data-Id: share-config-datasource-db.yaml
+          - data-Id: share-config-harmonic-db2.yaml
             refresh: true
   main:
     allow-bean-definition-overriding: true

pqs-influx/src/main/java/com/njcn/influx/pojo/bo/HarmonicHistoryData.java

@@ -1,5 +1,6 @@
 package com.njcn.influx.pojo.bo;
 
+import cn.hutool.core.util.ObjUtil;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import com.njcn.influx.utils.InstantDateSerializer;
 import lombok.Data;
@@ -7,6 +8,7 @@ import org.influxdb.annotation.Column;
 
 import java.io.Serializable;
 import java.time.Instant;
+import java.util.concurrent.TimeUnit;
 
 /**
  * @author hongawen
@@ -32,7 +34,10 @@ public class HarmonicHistoryData implements Serializable {
     private Instant timeId;
 
     public void setTimeId(Instant timeId) {
-        this.timeId = timeId;
+        if(ObjUtil.isNotNull(timeId)){
-        this.time = timeId;
+            Instant instant = timeId.plusMillis(TimeUnit.HOURS.toMillis(8));
+            this.time = instant;
+        }
+
     }
 }