Microservice/pqs
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

有功功率趋势定时任务算法完善

Browse Source
This commit is contained in:
guofeihu
2024-09-05 14:17:11 +08:00
parent 9fca0e5714
commit 8e6f07330e
18 changed files with 772 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/event/RActivePowerRangeController.java
View File

@@ -6,6 +6,8 @@ import com.njcn.common.pojo.enums.common.LogEnum;
import com.njcn.common.pojo.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.harmonic.pojo.vo.PowerStatisticsTargetVO;
import com.njcn.prepare.harmonic.pojo.param.RActivePowerRangeParam;
import com.njcn.prepare.harmonic.pojo.po.RActivePowerRangePO;
import com.njcn.prepare.harmonic.service.mysql.event.RActivePowerRangeService;
import com.njcn.web.controller.BaseController;
@@ -15,6 +17,7 @@ import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 有功功率趋势 前端控制器
@@ -34,10 +37,10 @@ public class RActivePowerRangeController extends BaseController {
@OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
@PostMapping("/record")
@ApiOperation("有功功率趋势记录(用于定时任务)")
public HttpResult<Boolean> record() {
public HttpResult<List<PowerStatisticsTargetVO>> record(@RequestBody(required = false) RActivePowerRangeParam rActivePowerRangeParam) {
String methodDescribe = getMethodDescribe("record");
rActivePowerRangeService.record();
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
List<PowerStatisticsTargetVO> powerStatisticsTargetVOS = rActivePowerRangeService.record(rActivePowerRangeParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, powerStatisticsTargetVOS, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.QUERY)

382
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/event/RActivePowerRangeServiceImpl.java
View File

@@ -11,17 +11,20 @@ import com.njcn.device.pq.api.NewStationClient;
import com.njcn.device.pq.api.OverLimitClient;
import com.njcn.device.pq.pojo.po.NewStation;
import com.njcn.event.pojo.constant.Param;
import com.njcn.influx.pojo.po.DataHarmPowerP;
import com.njcn.influx.pojo.po.DataV;
import com.njcn.influx.service.CommonService;
import com.njcn.influx.service.DataHarmPowerPService;
import com.njcn.influx.service.IDataVService;
import com.njcn.harmonic.pojo.vo.PowerStatisticsTargetVO;
import com.njcn.influx.pojo.bo.CommonQueryParam;
import com.njcn.influx.pojo.constant.InfluxDBTableConstant;
import com.njcn.influx.pojo.dto.StatisticalDataDTO;
import com.njcn.influx.service.*;
import com.njcn.prepare.harmonic.mapper.mysql.event.RActivePowerRangeMapper;
import com.njcn.prepare.harmonic.pojo.param.RActivePowerRangeParam;
import com.njcn.prepare.harmonic.pojo.po.RActivePowerRangePO;
import com.njcn.prepare.harmonic.service.mysql.event.RActivePowerRangeService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.lang.reflect.Field;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;
@@ -35,7 +38,7 @@ import java.util.stream.Collectors;
@RequiredArgsConstructor
public class RActivePowerRangeServiceImpl extends MppServiceImpl<RActivePowerRangeMapper, RActivePowerRangePO> implements RActivePowerRangeService {
private final DataHarmPowerPService dataHarmPowerPService;
private final CommonService commonService;
private final CommLineClient commLineClient;
@@ -43,79 +46,343 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl<RActivePowerRan
private final OverLimitClient overLimitClient;
private final IDataVService iDataVService;
CommonService commonService;
private DateTimeFormatter formatter = DateTimeFormatter.ofPattern(Param.DATE_FORMAT);
@Override
public void record() {
public List<PowerStatisticsTargetVO> record(RActivePowerRangeParam rActivePowerRangeParam) {
if(rActivePowerRangeParam == null){
rActivePowerRangeParam = new RActivePowerRangeParam();
}
//根据事件间隔查询 SELECT * FROM "data_harmpower_p" limit 1 得到P
// 便利 用p / 风电场额定有功功率 * 100% 看落在那个占比
List<RActivePowerRangePO> rActivePowerRangePOS = new ArrayList<>();
List<PowerStatisticsTargetVO> powerStatisticsTargetVOS = new ArrayList<>();
//定义开始和结束时间
String startTime = getTime(1,0);
String endTime = getTime(1,1);
String startTime = getTime(rActivePowerRangeParam.getInterval(),0);
String endTime = getTime(rActivePowerRangeParam.getInterval(),1);
//获取时间段内的有功功率集合
List<DataHarmPowerP> dataHarmPowerPS = dataHarmPowerPService.getHarmonicPowerP("",startTime,endTime);
List<CommonQueryParam> commonQueryParams = new ArrayList<>();
CommonQueryParam commonQueryParam = new CommonQueryParam();
if(rActivePowerRangeParam.isSearch()){
startTime = rActivePowerRangeParam.getSearchBeginTime()+Param.BEGIN;
endTime = rActivePowerRangeParam.getSearchEndTime()+Param.END;
commonQueryParam.setLineId(rActivePowerRangeParam.getLineId());
}
//时间段
commonQueryParam.setStartTime(startTime);
commonQueryParam.setEndTime(endTime);
//不传统计方式及相别
//功率表data_harmpower_p及字段p
commonQueryParam.setTableName(InfluxDBTableConstant.DATA_HARM_POWER_P);
commonQueryParam.setColumnName("p");
commonQueryParams.add(commonQueryParam);
List<StatisticalDataDTO> dataHarmPowerPS = commonService.getNewDeviceRtDataByTime(commonQueryParams);
//有功功率趋势表是按照监测点来划分的 所以这边需要根据监测点来分组
Map<String,List<DataHarmPowerP>> map = dataHarmPowerPS.stream().collect(Collectors.groupingBy(DataHarmPowerP::getLineId));
map.forEach((key,value) ->{
RActivePowerRangePO rActivePowerRangePO = new RActivePowerRangePO();
rActivePowerRangePO.setId(IdUtil.simpleUUID());
rActivePowerRangePO.setLineId(key);
rActivePowerRangePO.setTimeId(LocalDate.now());
Map<String,List<StatisticalDataDTO>> map = dataHarmPowerPS.stream().collect(Collectors.groupingBy(StatisticalDataDTO::getLineId));
RActivePowerRangeParam finalRActivePowerRangeParam = rActivePowerRangeParam;
map.forEach((key, value) ->{
//获取监测点的国标限值
List<Overlimit> overlimits = overLimitClient.getOverLimitByLineIds(Arrays.asList(key)).getData();
//获取监测点
LineDTO lineDTO = commLineClient.getLineDetail(key).getData();
if(lineDTO != null && lineDTO.getNewStationId() != null){
NewStation newStation = newStationClient.selectById(lineDTO.getNewStationId()).getData();
//风电场
if(newStation != null && com.njcn.device.pq.constant.Param.WINDFARM.equals(newStation.getStationType())){
//计算各个区间个数
for(DataHarmPowerP dataHarmPowerP : value){
double temp = dataHarmPowerP.getP() / Double.parseDouble(newStation.getRatedPower());
if(temp <= 0.1){
rActivePowerRangePO.setMinsNum0(rActivePowerRangePO.getMinsNum0() + 1);
}else if(0.1 < temp && temp <= 0.2){
rActivePowerRangePO.setMinsNum1(rActivePowerRangePO.getMinsNum1() + 1);
}else if(0.2 < temp && temp <= 0.3){
rActivePowerRangePO.setMinsNum2(rActivePowerRangePO.getMinsNum2() + 1);
}else if(0.3 < temp && temp <= 0.4){
rActivePowerRangePO.setMinsNum3(rActivePowerRangePO.getMinsNum3() + 1);
}else if(0.4 < temp && temp <= 0.5){
rActivePowerRangePO.setMinsNum4(rActivePowerRangePO.getMinsNum4() + 1);
}else if(0.5 < temp && temp <= 0.6){
rActivePowerRangePO.setMinsNum5(rActivePowerRangePO.getMinsNum5() + 1);
}else if(0.6 < temp && temp <= 0.7){
rActivePowerRangePO.setMinsNum6(rActivePowerRangePO.getMinsNum6() + 1);
}else if(0.7 < temp && temp <= 0.8){
rActivePowerRangePO.setMinsNum7(rActivePowerRangePO.getMinsNum7() + 1);
}else if(0.8 < temp && temp <= 0.9){
rActivePowerRangePO.setMinsNum8(rActivePowerRangePO.getMinsNum8() + 1);
}else if(temp > 0.9){
rActivePowerRangePO.setMinsNum9(rActivePowerRangePO.getMinsNum9() + 1);
if(overlimits != null && !overlimits.isEmpty()){
Overlimit overlimit = overlimits.get(0);
//获取监测点
LineDTO lineDTO = commLineClient.getLineDetail(key).getData();
if(lineDTO != null && lineDTO.getNewStationId() != null){
NewStation newStation = newStationClient.selectById(lineDTO.getNewStationId()).getData();
//风电场
if(newStation != null && com.njcn.device.pq.constant.Param.WINDFARM.equals(newStation.getStationType())){
RActivePowerRangePO rActivePowerRangePO = new RActivePowerRangePO();
rActivePowerRangePO.setLineId(key);
rActivePowerRangePO.setTimeId(LocalDate.now());
rActivePowerRangePO.setId(IdUtil.simpleUUID());
LambdaQueryWrapper<RActivePowerRangePO> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.eq(RActivePowerRangePO::getLineId,key).eq(RActivePowerRangePO::getTimeId,LocalDate.now());
//强制刷新
if(finalRActivePowerRangeParam.isRefresh()){
this.baseMapper.delete(lambdaQueryWrapper);
}
}
//计算各个区间是否越限
//电压偏差
List<DataV> dataVS = iDataVService.getHarmonicDataV(key,startTime,endTime);
for(DataV dataV : dataVS){
if(dataV.getVuDev() > 0 && dataV.getVuDev() > overlimits.get(0).getVoltageDev()){
//计算各个区间个数
for(StatisticalDataDTO statisticalDataDTO : value){
PowerStatisticsTargetVO powerStatisticsTargetVO = new PowerStatisticsTargetVO();
powerStatisticsTargetVO.setTime(statisticalDataDTO.getTime().atZone(ZoneId.systemDefault()).format(formatter));
double temp = statisticalDataDTO.getValue() / Double.parseDouble(newStation.getRatedPower());
if(temp <= 0.1){
//占有率区间个数+1
rActivePowerRangePO.setMinsNum0(rActivePowerRangePO.getMinsNum0() + 1);
//指标越限列表区间区分字段
powerStatisticsTargetVO.setField("0");
//判断每个指标是否越限(根据type来区分设置到哪个区间对应的是否越限字段)
installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,0,powerStatisticsTargetVO);
}else if(0.1 < temp && temp <= 0.2){
rActivePowerRangePO.setMinsNum1(rActivePowerRangePO.getMinsNum1() + 1);
powerStatisticsTargetVO.setField("1");
installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,1,powerStatisticsTargetVO);
}else if(0.2 < temp && temp <= 0.3){
rActivePowerRangePO.setMinsNum2(rActivePowerRangePO.getMinsNum2() + 1);
powerStatisticsTargetVO.setField("2");
installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,2,powerStatisticsTargetVO);
}else if(0.3 < temp && temp <= 0.4){
rActivePowerRangePO.setMinsNum3(rActivePowerRangePO.getMinsNum3() + 1);
powerStatisticsTargetVO.setField("3");
installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,3,powerStatisticsTargetVO);
}else if(0.4 < temp && temp <= 0.5){
rActivePowerRangePO.setMinsNum4(rActivePowerRangePO.getMinsNum4() + 1);
powerStatisticsTargetVO.setField("4");
installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,4,powerStatisticsTargetVO);
}else if(0.5 < temp && temp <= 0.6){
rActivePowerRangePO.setMinsNum5(rActivePowerRangePO.getMinsNum5() + 1);
powerStatisticsTargetVO.setField("5");
installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,5,powerStatisticsTargetVO);
}else if(0.6 < temp && temp <= 0.7){
rActivePowerRangePO.setMinsNum6(rActivePowerRangePO.getMinsNum6() + 1);
powerStatisticsTargetVO.setField("6");
installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,6,powerStatisticsTargetVO);
}else if(0.7 < temp && temp <= 0.8){
rActivePowerRangePO.setMinsNum7(rActivePowerRangePO.getMinsNum7() + 1);
powerStatisticsTargetVO.setField("7");
installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,7,powerStatisticsTargetVO);
}else if(0.8 < temp && temp <= 0.9){
rActivePowerRangePO.setMinsNum8(rActivePowerRangePO.getMinsNum8() + 1);
powerStatisticsTargetVO.setField("8");
installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,8,powerStatisticsTargetVO);
}else if(temp > 0.9){
rActivePowerRangePO.setMinsNum9(rActivePowerRangePO.getMinsNum9() + 1);
powerStatisticsTargetVO.setField("9");
installLimit(rActivePowerRangePO,statisticalDataDTO,overlimit,9,powerStatisticsTargetVO);
}
//重点说明:powerStatisticsTargetVO结构(维度)为:time可能多组相同,取决于功率表data_harmpower_p中的相别及统计方式,标识每个指标是否越限,总之一句话:当前时间中八个指标是否越限及他们的相别和统计方式是什么
powerStatisticsTargetVOS.add(powerStatisticsTargetVO);
}
//根据日期及lineId当天不能重复执行
if(this.baseMapper.selectList(lambdaQueryWrapper).isEmpty() && (finalRActivePowerRangeParam.isSearch() && finalRActivePowerRangeParam.isSearchForAdd() || !finalRActivePowerRangeParam.isSearch())){
this.baseMapper.insert(rActivePowerRangePO);
}
}
}
}
});
//区间过滤下
if(rActivePowerRangeParam.isSearch()){
return powerStatisticsTargetVOS.stream().filter(param->param.getField().equals(finalRActivePowerRangeParam.getField())).collect(Collectors.toList());
}
return null;
}
private void installLimit(RActivePowerRangePO rActivePowerRangePO,StatisticalDataDTO statisticalDataDTO,Overlimit overlimit,int type,PowerStatisticsTargetVO powerStatisticsTargetVO){
//以下的结果集按道理最多只有一条(因为确定的相别统计方式及开始和结束时间都一致)
//电压偏差
List<StatisticalDataDTO> vu_dev = commonQuery(InfluxDBTableConstant.DATA_V,"vu_dev",statisticalDataDTO,null,null);
//谐波电压
List<StatisticalDataDTO> v_thd = commonQuery(InfluxDBTableConstant.DATA_V,"v_thd",statisticalDataDTO,null,null);
List<StatisticalDataDTO> v = commonQuery(InfluxDBTableConstant.DATA_HARM_RATE_V,"v",statisticalDataDTO,2,25);
//谐波电流
List<StatisticalDataDTO> i = commonQuery(InfluxDBTableConstant.DATA_I,"i",statisticalDataDTO,2,25);
//三相电压不平衡度
List<StatisticalDataDTO> v_unbalance = commonQuery(InfluxDBTableConstant.DATA_V,"v_unbalance",statisticalDataDTO,null,null);
//电压波动
List<StatisticalDataDTO> fluc = commonQuery(InfluxDBTableConstant.DATA_FLUC,"fluc",statisticalDataDTO,null,null);
//长时闪变
List<StatisticalDataDTO> plt = commonQuery(InfluxDBTableConstant.DATA_PLT,"plt",statisticalDataDTO,null,null);
//间谐波电压含有率
List<StatisticalDataDTO> v1 = commonQuery(InfluxDBTableConstant.DATA_IN_HARM_V,"v",statisticalDataDTO,1,16);
//电流不平衡度
List<StatisticalDataDTO> i_unbalance = commonQuery(InfluxDBTableConstant.DATA_I,"i_unbalance",statisticalDataDTO,null,null);
//此标识用来记录当前区间下指标是否越限(0%~10%是否越限,10%~20%是否越限.....)
boolean isLimit = false;
//电压偏差是否越限比较
//电压偏差国标限制
powerStatisticsTargetVO.setVoltageOffsetLimit(overlimit.getVoltageDev());
for(StatisticalDataDTO dto : vu_dev){
//如果vu_dev>0,使用上偏差限值对比；如果vu_dev<0,使用下偏差限值对比
if((dto.getValue()>0 && Double.compare(dto.getValue(),overlimit.getVoltageDev())>0)
|| (dto.getValue()<0 && Double.compare(dto.getValue(),overlimit.getUvoltageDev())>0)){
isLimit = true;
//标志电压偏差越限
powerStatisticsTargetVO.setVoltageOffset(1);
//记录电压偏差越限的相别
powerStatisticsTargetVO.setPhasicType(dto.getPhaseType());
//记录电压偏差越限的统计方式
powerStatisticsTargetVO.setValueType(dto.getValueType());
}
//电压偏差国标限制有判断
if(dto.getValue()>0){
powerStatisticsTargetVO.setVoltageOffsetLimit(overlimit.getVoltageDev());
}else{
powerStatisticsTargetVO.setVoltageOffsetLimit(overlimit.getUvoltageDev());
}
}
//谐波电压是否越限比较
//谐波电压国标限制
powerStatisticsTargetVO.setVTimesLimit(overlimit.getUaberrance());
for(StatisticalDataDTO dto : v_thd){
if(Double.compare(dto.getValue(),overlimit.getUaberrance())>0){
isLimit = true;
powerStatisticsTargetVO.setVTimes(1);
powerStatisticsTargetVO.setPhasicType(dto.getPhaseType());
powerStatisticsTargetVO.setValueType(dto.getValueType());
}
}
for(StatisticalDataDTO dto : v){
if(frequencyCompare(overlimit,2,50,dto.getValue(),"uharm")){
isLimit = true;
powerStatisticsTargetVO.setVTimes(1);
powerStatisticsTargetVO.setPhasicType(dto.getPhaseType());
powerStatisticsTargetVO.setValueType(dto.getValueType());
}
}
//谐波电流是否越限比较
//谐波电流国标限制(由于有谐波次数所以这边直接默认取第一个)
powerStatisticsTargetVO.setVTimesLimit(overlimit.getIharm2());
for(StatisticalDataDTO dto : i){
if(frequencyCompare(overlimit,2,25,dto.getValue(),"iharm")){
isLimit = true;
powerStatisticsTargetVO.setITimes(1);
powerStatisticsTargetVO.setPhasicType(dto.getPhaseType());
powerStatisticsTargetVO.setValueType(dto.getValueType());
}
}
//三相电压不平衡度是否越限比较
//三相电压不平衡度国标限制
powerStatisticsTargetVO.setUbalanceLimit(overlimit.getUbalance());
for(StatisticalDataDTO dto : v_unbalance){
if(Double.compare(dto.getValue(),overlimit.getUbalance())>0){
isLimit = true;
powerStatisticsTargetVO.setUbalance(1);
powerStatisticsTargetVO.setPhasicType(dto.getPhaseType());
powerStatisticsTargetVO.setValueType(dto.getValueType());
}
}
//电压波动是否越限比较
//电压波动国标限制
powerStatisticsTargetVO.setVoltageFluctuationLimit(overlimit.getVoltageFluctuation());
for(StatisticalDataDTO dto : fluc){
if(Double.compare(dto.getValue(),overlimit.getVoltageFluctuation())>0){
isLimit = true;
powerStatisticsTargetVO.setVoltageFluctuation(1);
powerStatisticsTargetVO.setPhasicType(dto.getPhaseType());
powerStatisticsTargetVO.setValueType(dto.getValueType());
}
}
//长时闪变是否越限比较
//长时闪变国标限制
powerStatisticsTargetVO.setFlickerLimit(overlimit.getFlicker());
for(StatisticalDataDTO dto : plt){
if(Double.compare(dto.getValue(),overlimit.getFlicker())>0){
isLimit = true;
powerStatisticsTargetVO.setFlicker(1);
powerStatisticsTargetVO.setPhasicType(dto.getPhaseType());
powerStatisticsTargetVO.setValueType(dto.getValueType());
}
}
//间谐波电压含有率是否越限比较
//间谐波电压含有率国标限制(由于有谐波次数所以这边直接默认取第一个)
powerStatisticsTargetVO.setInterHarmonicLimit(overlimit.getInuharm1());
for(StatisticalDataDTO dto : v1){
if(frequencyCompare(overlimit,1,16,dto.getValue(),"inuharm")){
isLimit = true;
powerStatisticsTargetVO.setInterHarmonic(1);
powerStatisticsTargetVO.setPhasicType(dto.getPhaseType());
powerStatisticsTargetVO.setValueType(dto.getValueType());
}
}
//电流不平衡度是否越限比较
//间谐波电压含有率国标限制
powerStatisticsTargetVO.setSequenceCurrentUnbalanceLimit(overlimit.getINeg());
for(StatisticalDataDTO dto : i_unbalance){
if(Double.compare(dto.getValue(),overlimit.getINeg())>0){
isLimit = true;
powerStatisticsTargetVO.setSequenceCurrentUnbalance(1);
powerStatisticsTargetVO.setPhasicType(dto.getPhaseType());
powerStatisticsTargetVO.setValueType(dto.getValueType());
}
}
switch (type){
case 0:
if(isLimit) rActivePowerRangePO.setIsOrNot0(1);
break;
case 1:
if(isLimit) rActivePowerRangePO.setIsOrNot1(1);
break;
case 2:
if(isLimit) rActivePowerRangePO.setIsOrNot2(1);
break;
case 3:
if(isLimit) rActivePowerRangePO.setIsOrNot3(1);
break;
case 4:
if(isLimit) rActivePowerRangePO.setIsOrNot4(1);
break;
case 5:
if(isLimit) rActivePowerRangePO.setIsOrNot5(1);
break;
case 6:
if(isLimit) rActivePowerRangePO.setIsOrNot6(1);
break;
case 7:
if(isLimit) rActivePowerRangePO.setIsOrNot7(1);
break;
case 8:
if(isLimit) rActivePowerRangePO.setIsOrNot8(1);
break;
case 9:
if(isLimit) rActivePowerRangePO.setIsOrNot9(1);
break;
}
}
//组装公共查询
private List<StatisticalDataDTO> commonQuery(String tableName,String columnName,StatisticalDataDTO statisticalDataDTO,Integer start,Integer end){
List<CommonQueryParam> commonQueryParams = new ArrayList<>();
String time = statisticalDataDTO.getTime().atZone(ZoneId.systemDefault()).format(formatter);
CommonQueryParam commonQueryParam = new CommonQueryParam();
if(start == null){
commonQueryParam.setStartTime(time);
commonQueryParam.setEndTime(time);
commonQueryParam.setLineId(statisticalDataDTO.getLineId());
commonQueryParam.setPhasic(statisticalDataDTO.getPhaseType());
commonQueryParam.setDataType(statisticalDataDTO.getValueType());
commonQueryParam.setTableName(tableName);
commonQueryParam.setColumnName(columnName);
commonQueryParams.add(commonQueryParam);
}else{
for (int i = start; i <= end; i++) {
commonQueryParam = new CommonQueryParam();
commonQueryParam.setStartTime(time);
commonQueryParam.setEndTime(time);
commonQueryParam.setLineId(statisticalDataDTO.getLineId());
commonQueryParam.setPhasic(statisticalDataDTO.getPhaseType());
commonQueryParam.setDataType(statisticalDataDTO.getValueType());
commonQueryParam.setTableName(tableName);
commonQueryParam.setColumnName(columnName+"_"+i);
commonQueryParams.add(commonQueryParam);
}
}
return commonService.getNewDeviceRtDataByTime(commonQueryParams);
}
private boolean frequencyCompare(Overlimit overlimit,int start,int end,Double value,String flag){
Class clazz = overlimit.getClass();
try {
for (int i = start; i <= end; i++) {
Field field = clazz.getDeclaredField(flag+i);
field.setAccessible(true);
if(Double.compare(value,Float.parseFloat(field.get(overlimit).toString()))>0){
return true;
}
}
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
private String getTime(long interval,int type){
DateTimeFormatter sdf = DateTimeFormatter.ofPattern(DateUtils.DATE_FORMAT_10);
LocalDate yesterday = LocalDate.now().minusDays(interval);
LocalDate yesterday;
if(type == 0){
yesterday = LocalDate.now().minusDays(interval);
return yesterday.format(sdf)+Param.BEGIN;
}else{
yesterday = LocalDate.now().minusDays(1);
return yesterday.format(sdf)+Param.END;
}
}
@@ -128,6 +395,7 @@ public class RActivePowerRangeServiceImpl extends MppServiceImpl<RActivePowerRan
List<RActivePowerRangePO> rActivePowerRangePOS = this.baseMapper.selectList(lambdaQueryWrapper);
if(!rActivePowerRangePOS.isEmpty()){
RActivePowerRangePO rActivePowerRangePO = new RActivePowerRangePO();
rActivePowerRangePO.setLineId(lineId);
for(RActivePowerRangePO rangePO : rActivePowerRangePOS){
rActivePowerRangePO.setMinsNum0(rangePO.getMinsNum0()+rActivePowerRangePO.getMinsNum0());
rActivePowerRangePO.setMinsNum1(rangePO.getMinsNum1()+rActivePowerRangePO.getMinsNum1());

4
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/event/SpThroughServiceImpl.java
View File

@@ -101,7 +101,7 @@ public class SpThroughServiceImpl extends MppServiceImpl<SpThroughMapper, SpThro
.eq(SpThroughPO::getState,1)
.eq(SpThroughPO::getEventType,Param.UPPEREVENT);
Integer upperCount = this.baseMapper.selectCount(upperLambdaQueryWrapper);
spThroughVO.setHighPressure(upperCount == 0?null:upperCount.toString());
spThroughVO.setHighPressure(upperCount == 0?"0":upperCount.toString());
LambdaQueryWrapper<SpThroughPO> lowLambdaQueryWrapper = new LambdaQueryWrapper();
lowLambdaQueryWrapper.in(SpThroughPO::getEventId,spThroughParam.getEventIds())
@@ -110,7 +110,7 @@ public class SpThroughServiceImpl extends MppServiceImpl<SpThroughMapper, SpThro
.eq(SpThroughPO::getState,1)
.eq(SpThroughPO::getEventType,Param.LOWEREVENT);
Integer lowCount = this.baseMapper.selectCount(lowLambdaQueryWrapper);
spThroughVO.setLowPressure(lowCount == 0?null:lowCount.toString());
spThroughVO.setLowPressure(lowCount == 0?"0":lowCount.toString());
return spThroughVO;
}

5
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/event/RActivePowerRangeService.java
View File

@@ -1,7 +1,10 @@
package com.njcn.prepare.harmonic.service.mysql.event;
import com.github.jeffreyning.mybatisplus.service.IMppService;
import com.njcn.harmonic.pojo.vo.PowerStatisticsTargetVO;
import com.njcn.prepare.harmonic.pojo.param.RActivePowerRangeParam;
import com.njcn.prepare.harmonic.pojo.po.RActivePowerRangePO;
import java.util.List;
/**
* 有功功率趋势 服务类
@@ -13,7 +16,7 @@ public interface RActivePowerRangeService extends IMppService<RActivePowerRangeP
/**
* 有功功率趋势记录(用于定时任务)
*/
void record();
List<PowerStatisticsTargetVO> record(RActivePowerRangeParam rActivePowerRangeParam);
/**
* 根据监测点ID及时间获取有功功率趋势