diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/HarmonicHistoryParam.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/HarmonicHistoryParam.java index 9e5dd99c7..b023c3a54 100644 --- a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/HarmonicHistoryParam.java +++ b/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; } diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/zt/HarmonicHistoryC.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/zt/HarmonicHistoryC.java new file mode 100644 index 000000000..01e22a505 --- /dev/null +++ b/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; +} diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/zt/HarmonicHistoryP.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/zt/HarmonicHistoryP.java new file mode 100644 index 000000000..5b04f117f --- /dev/null +++ b/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; + +} diff --git a/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/zt/HarmonicHistoryV.java b/pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/zt/HarmonicHistoryV.java new file mode 100644 index 000000000..8dc4b1483 --- /dev/null +++ b/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; +} diff --git a/pqs-harmonic/harmonic-boot/pom.xml b/pqs-harmonic/harmonic-boot/pom.xml index 4bcdbb30b..4ee3ec7f1 100644 --- a/pqs-harmonic/harmonic-boot/pom.xml +++ b/pqs-harmonic/harmonic-boot/pom.xml @@ -65,6 +65,35 @@ dynamic-datasource-spring-boot-starter 3.5.1 + + + + com.baomidou + dynamic-datasource-spring-boot-starter + ${dynamic-datasource.version} + + + com.oracle.database.jdbc + ojdbc8 + ${oracle.version} + + + com.oracle.database.nls + orai18n + ${orai18n.version} + + + + + com.huawei.apigateway + java-sdk-core + 3.0.10 + + + org.joda.time + joda-time + 2.9.9 + diff --git a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/controller/HistoryResultController.java b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/controller/HistoryResultController.java index 3f0822e3a..fc15ccc93 100644 --- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/controller/HistoryResultController.java +++ b/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; @@ -34,21 +36,25 @@ import org.springframework.web.bind.annotation.RestController; import java.util.List; /** - * @author denghuajun + * @author denghuajun * @date 2022/3/14 - * 趋势图 + * 趋势图 */ @Validated @Slf4j @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> getHistoryResult(@RequestBody @Validated HistoryParam historyParam) { String methodDescribe = getMethodDescribe("getHistoryResult"); - List list = historyResultService.getHistoryResult(historyParam); + List list; + if (HistoryDataSource == 1) { + list = oracleResultService.getHistoryResult(historyParam); + } else { + list = historyResultService.getHistoryResult(historyParam); + } return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe); } @@ -110,8 +121,8 @@ public class HistoryResultController extends BaseController { List list = limitRateDService.list(new LambdaQueryWrapper() .in(RStatLimitRateDPO::getLineId, param.getIds()) .eq(RStatLimitRateDPO::getPhasicType, "T") - .ge(StrUtil.isNotBlank(param.getStartTime()),RStatLimitRateDPO::getTime, param.getStartTime()) - .le(StrUtil.isNotBlank(param.getEndTime()),RStatLimitRateDPO::getTime, param.getEndTime()) + .ge(StrUtil.isNotBlank(param.getStartTime()), RStatLimitRateDPO::getTime, param.getStartTime()) + .le(StrUtil.isNotBlank(param.getEndTime()), RStatLimitRateDPO::getTime, param.getEndTime()) ); return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, list, methodDescribe); diff --git a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/mapper/HistoryDataMapper.java b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/mapper/HistoryDataMapper.java index 34e955c34..0a2484ba0 100644 --- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/mapper/HistoryDataMapper.java +++ b/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 getDataV(@Param("param") HarmonicHistoryParam param); diff --git a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/OracleResultService.java b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/OracleResultService.java index fb624c0de..320809c6f 100644 --- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/OracleResultService.java +++ b/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 getHistoryResult(HistoryParam historyParam); - List getHistoryResult2(HistoryParam historyParam); } diff --git a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/OracleResultServiceImpl.java b/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/OracleResultServiceImpl.java index faf3e9cd8..a4d994139 100644 --- a/pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/impl/OracleResultServiceImpl.java +++ b/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.baomidou.mybatisplus.core.conditions.query.QueryWrapper; +import com.alibaba.fastjson.JSON; +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 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 data_v = HistoryDataMapper.getDataFluc(param); - param.setValueTypeName("MAX"); - List data_v2 = HistoryDataMapper.getDataFluc(param); - param.setValueTypeName("MIN"); - List data_v3 = HistoryDataMapper.getDataFluc(param); - param.setValueTypeName("CP95"); - List 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(); - historyParam.setStartTime(startTime+InfluxDBTableConstant.START_TIME); - historyParam.setEndTime(endTime+InfluxDBTableConstant.END_TIME); - historyParam.setValueTypeName(valueTypeName); - historyParam.setLineId(lineId); - queryResultLimitVO.setHarmonicHistoryDataList(setHistoryDataList(historyParam,contion,number,type)); + 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,lineDetailDataVO.getType())); queryResultLimitVO.setTopLimit(topLimit); queryResultLimitVO.setLowerLimit(lowerLimit); queryResultLimitVO.setPhaiscType(phasicType); @@ -645,7 +660,12 @@ public class OracleResultServiceImpl implements OracleResultService { List 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: //谐波有功功率 - harmonicHistoryData=HistoryDataMapper.getDataHarmpowerP_p(historyParam,number); + if(type==0) { + harmonicHistoryData = HistoryDataMapper.getDataHarmpowerP_p(historyParam, number); + }else{ + harmonicHistoryData =ztHarmonicHistoryP(historyParam,1); + } break; case 51: //谐波无功功率 - harmonicHistoryData=HistoryDataMapper.getDataHarmpowerQ_q(historyParam,number); + 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: //视在功率因数 - harmonicHistoryData=HistoryDataMapper.getDataHarmpowerP_pf(historyParam); + 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 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 harmonicHistory = adsDiList(HarmonicHistoryV.class, id, starTime, endTime, key, secret, url, apiId, apiName); + return ztDataV(harmonicHistory); + } + //1:有功 0:无功 + private List 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 harmonicHistory = adsDiList(HarmonicHistoryP.class, id, starTime, endTime, key, secret, url, apiId, apiName); + return ztDataP(harmonicHistory,type); + } + //功率因数 + private List 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 harmonicHistory = adsDiList(HarmonicHistoryC.class, id, starTime, endTime, key, secret, url, apiId, apiName); + return ztDataC(harmonicHistory); + } + + /** + * @Description: 河北华云中台远程访问信息 + * @return: java.util.List + * @Author: wr + * @Date: 2024/1/15 10:20 + */ + private List adsDiList(Class t,String id, String starTime, String endTime,String key,String secret, String url,String apiId,String apiName) { + List 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 + * @Author: wr + * @Date: 2024/1/22 15:25 + */ + private List ztDataV(List value) { + List info=new ArrayList<>(); + HarmonicHistoryData d; + //a + List a = value.stream().filter(x -> x.getPhase_flag() == 1).distinct().collect(Collectors.toList()); + //b + List b = value.stream().filter(x -> x.getPhase_flag() == 2).distinct().collect(Collectors.toList()); + //c + List 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 ztDataP(List value,Integer type) { + List info=new ArrayList<>(); + HarmonicHistoryData d; + //a + List a; + //b + List b; + //c + List 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 ztDataC(List value) { + List info=new ArrayList<>(); + HarmonicHistoryData d; + //a + List a= value.stream().filter(x -> x.getPhase_flag() == 1).collect(Collectors.toList()); + //b + List b= value.stream().filter(x -> x.getPhase_flag() == 2).distinct().collect(Collectors.toList()); + //c + List 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; + } } diff --git a/pqs-harmonic/harmonic-boot/src/main/resources/bootstrap.yml b/pqs-harmonic/harmonic-boot/src/main/resources/bootstrap.yml index 1f3027913..13099624e 100644 --- a/pqs-harmonic/harmonic-boot/src/main/resources/bootstrap.yml +++ b/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 diff --git a/pqs-influx/src/main/java/com/njcn/influx/pojo/bo/HarmonicHistoryData.java b/pqs-influx/src/main/java/com/njcn/influx/pojo/bo/HarmonicHistoryData.java index 3cb8c6a3e..e966233f1 100644 --- a/pqs-influx/src/main/java/com/njcn/influx/pojo/bo/HarmonicHistoryData.java +++ b/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; - this.time = timeId; + if(ObjUtil.isNotNull(timeId)){ + Instant instant = timeId.plusMillis(TimeUnit.HOURS.toMillis(8)); + this.time = instant; + } + } }