Middleware/cn-data-platform
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

新能源专项分析算法迁移

Browse Source
This commit is contained in:
wr
2025-04-03 16:10:00 +08:00
parent 3b62feefd6
commit af59a427f1
28 changed files with 1542 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
algorithm/algorithm-api/src/main/java/com/njcn/algorithm/pojo/liteflow/LiteFlowAlgorithmFeignClient.java
View File

@@ -39,5 +39,7 @@ public interface LiteFlowAlgorithmFeignClient {
@PostMapping("/substationExecutor") @PostMapping("/substationExecutor")
void substationExecutor(@RequestBody BaseParam baseParam); void substationExecutor(@RequestBody BaseParam baseParam);
@ApiOperation("新能源专项分析算法执行链")
@PostMapping("/specialAnalysis")
void specialAnalysisExecutor(@RequestBody BaseParam baseParam);
} }

6
algorithm/algorithm-api/src/main/java/com/njcn/algorithm/pojo/liteflow/fallback/LiteFlowAlgorithmFeignClientFallbackFactory.java
View File

@@ -46,6 +46,12 @@ public class LiteFlowAlgorithmFeignClientFallbackFactory implements FallbackFact
throw new BusinessException(finalExceptionEnum); throw new BusinessException(finalExceptionEnum);
} }
@Override
public void specialAnalysisExecutor(BaseParam baseParam) {
log.error("{}异常，降级处理，异常为：{}", "新能源专项分析算法执行链: ", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override @Override
public void deviceExecutor(BaseParam baseParam) { public void deviceExecutor(BaseParam baseParam) {
log.error("{}异常，降级处理，异常为：{}", "装置算法执行链: ", throwable.toString()); log.error("{}异常，降级处理，异常为：{}", "装置算法执行链: ", throwable.toString());

42
algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/ExecutionCenter.java
View File

@@ -18,6 +18,7 @@ import com.njcn.common.pojo.exception.BusinessException;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient; import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.*; import com.njcn.device.biz.pojo.dto.*;
import com.njcn.device.biz.pojo.param.DeptGetLineParam; import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.device.pq.api.DeptLineFeignClient;
import com.njcn.user.api.DeptFeignClient; import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept; import com.njcn.user.pojo.po.Dept;
import com.njcn.web.controller.BaseController; import com.njcn.web.controller.BaseController;
@@ -26,7 +27,6 @@ import com.yomahub.liteflow.flow.LiteflowResponse;
import com.yomahub.liteflow.flow.entity.CmpStep; import com.yomahub.liteflow.flow.entity.CmpStep;
import io.swagger.annotations.Api; import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
import lombok.Data;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils; import org.apache.commons.collections.CollectionUtils;
@@ -62,7 +62,8 @@ public class ExecutionCenter extends BaseController {
private DeptFeignClient deptFeignClient; private DeptFeignClient deptFeignClient;
@Resource @Resource
private FlowExecutor flowExecutor; private FlowExecutor flowExecutor;
@Resource
private DeptLineFeignClient deptLineFeignClient;
/*** /***
* 1、校验非全链执行时，tagNames节点标签集合必须为非空，否则提示---无可执行节点 * 1、校验非全链执行时，tagNames节点标签集合必须为非空，否则提示---无可执行节点
@@ -125,8 +126,6 @@ public class ExecutionCenter extends BaseController {
CalculatedParam calculatedParam = judgeExecuteParam(baseParam); CalculatedParam calculatedParam = judgeExecuteParam(baseParam);
// 测点索引 // 测点索引
if (CollectionUtils.isEmpty(calculatedParam.getIdList())) { if (CollectionUtils.isEmpty(calculatedParam.getIdList())) {
// calculatedParam.setIdList(Arrays.asList("c5f4925dbe333230810fe1a6afc51dfb","293178e56cd207e6e33586090f5034be","2df0cb6a87ef523b726c0a9ff6cfd288","43a1391b503bcd7f1b9a2f8f90e53e0f"
// ));
calculatedParam.setIdList(commTerminalGeneralClient.getRunMonitorIds().getData()); calculatedParam.setIdList(commTerminalGeneralClient.getRunMonitorIds().getData());
} }
LiteflowResponse liteflowResponse; LiteflowResponse liteflowResponse;
@@ -151,6 +150,40 @@ public class ExecutionCenter extends BaseController {
} }
} }
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@ApiOperation("新能源专项分析算法执行链")
@PostMapping("/specialAnalysis")
@Async("asyncExecutor")
public void specialAnalysisExecutor(@RequestBody BaseParam baseParam) {
String methodDescribe = getMethodDescribe("specialAnalysisExecutor");
//手动判断参数是否合法,
CalculatedParam calculatedParam = judgeExecuteParam(baseParam);
// 测点索引
if (CollectionUtils.isEmpty(calculatedParam.getIdList())) {
calculatedParam.setIdList(deptLineFeignClient.getLineByDeptIdAndNewStation(null).getData());
}
LiteflowResponse liteflowResponse;
if (baseParam.isRepair()) {
//补招时，起始日期、截止日期必填
DateTime startDate = DateUtil.parse(baseParam.getBeginTime(), DatePattern.NORM_DATE_FORMAT);
DateTime endDate = DateUtil.parse(baseParam.getEndTime(), DatePattern.NORM_DATE_FORMAT);
long betweenDay = DateUtil.betweenDay(startDate, endDate, true);
//递增日期执行算法链
for (int i = 0; i < betweenDay; i++) {
if (i != 0) {
startDate = DateUtil.offsetDay(startDate, 1);
}
calculatedParam.setDataDate(DateUtil.format(startDate, DatePattern.NORM_DATE_PATTERN));
liteflowResponse = flowExecutor.execute2Resp("special_analysis", calculatedParam);
dealResponse(calculatedParam, liteflowResponse, methodDescribe);
}
} else {
//非补招
liteflowResponse = flowExecutor.execute2Resp("special_analysis", calculatedParam);
dealResponse(calculatedParam, liteflowResponse, methodDescribe);
}
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON) @OperateInfo(info = LogEnum.BUSINESS_COMMON)
@ApiOperation("监测点算法执行链(按小时执行的算法)") @ApiOperation("监测点算法执行链(按小时执行的算法)")
@PostMapping("/measurementPointExecutorByHour") @PostMapping("/measurementPointExecutorByHour")
@@ -272,6 +305,7 @@ public class ExecutionCenter extends BaseController {
} }
} }
// //
// @OperateInfo(info = LogEnum.BUSINESS_COMMON) // @OperateInfo(info = LogEnum.BUSINESS_COMMON)
// @ApiOperation("pms国网上送单位层级算法执行链") // @ApiOperation("pms国网上送单位层级算法执行链")

2
algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/executor/DeviceExecutor.java
View File

@@ -34,6 +34,7 @@ public class DeviceExecutor extends BaseExecutor {
public boolean deviceOnlineRateAccess(NodeComponent bindCmp) { public boolean deviceOnlineRateAccess(NodeComponent bindCmp) {
return isAccess(bindCmp); return isAccess(bindCmp);
} }
@LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "deviceOnlineRate", nodeType = NodeTypeEnum.COMMON) @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "deviceOnlineRate", nodeType = NodeTypeEnum.COMMON)
public void deviceOnlineRateProcess(NodeComponent bindCmp) { public void deviceOnlineRateProcess(NodeComponent bindCmp) {
onlineRateService.dataOnlineRate(bindCmp.getRequestData()); onlineRateService.dataOnlineRate(bindCmp.getRequestData());
@@ -43,6 +44,7 @@ public class DeviceExecutor extends BaseExecutor {
public boolean dataOnlineRateMonthAccess(NodeComponent bindCmp) { public boolean dataOnlineRateMonthAccess(NodeComponent bindCmp) {
return isAccess(bindCmp); return isAccess(bindCmp);
} }
@LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "deviceOnlineRateMonth", nodeType = NodeTypeEnum.COMMON) @LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "deviceOnlineRateMonth", nodeType = NodeTypeEnum.COMMON)
public void deviceOnlineRateMonthProcess(NodeComponent bindCmp) { public void deviceOnlineRateMonthProcess(NodeComponent bindCmp) {
onlineRateService.dataOnlineRateMonth(bindCmp.getRequestData()); onlineRateService.dataOnlineRateMonth(bindCmp.getRequestData());

58
algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/executor/SpecialAnalysisExecutor.java Normal file
View File

@@ -0,0 +1,58 @@
package com.njcn.algorithm.executor;
import com.njcn.algorithm.service.line.ISpecialAnalysisService;
import com.yomahub.liteflow.annotation.LiteflowComponent;
import com.yomahub.liteflow.annotation.LiteflowMethod;
import com.yomahub.liteflow.core.NodeComponent;
import com.yomahub.liteflow.enums.LiteFlowMethodEnum;
import com.yomahub.liteflow.enums.NodeTypeEnum;
import lombok.RequiredArgsConstructor;
import javax.annotation.Resource;
/**
* @author hongawen
* @version 1.0.0
* @date 2023年11月06日 15:59
*/
@LiteflowComponent
@RequiredArgsConstructor
public class SpecialAnalysisExecutor extends BaseExecutor {
@Resource
private ISpecialAnalysisService specialAnalysisService;
/**
* 算法名: 高低压穿越算法(sp_through)
*
* @param bindCmp
* @return
*/
@LiteflowMethod(value = LiteFlowMethodEnum.IS_ACCESS, nodeId = "spThrough", nodeType = NodeTypeEnum.COMMON)
public boolean spThroughAccess(NodeComponent bindCmp) {
return isAccess(bindCmp);
}
@LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "spThrough", nodeType = NodeTypeEnum.COMMON)
public void spThroughProcess(NodeComponent bindCmp) {
specialAnalysisService.dataDaySpThroughHandle(bindCmp.getRequestData());
}
/**
* 算法名: 有功功率趋势算法(r_active_power_range)
*
* @param bindCmp
* @return
*/
@LiteflowMethod(value = LiteFlowMethodEnum.IS_ACCESS, nodeId = "activePower", nodeType = NodeTypeEnum.COMMON)
public boolean activePowerAccess(NodeComponent bindCmp) {
return isAccess(bindCmp);
}
@LiteflowMethod(value = LiteFlowMethodEnum.PROCESS, nodeId = "activePower", nodeType = NodeTypeEnum.COMMON)
public void activePowerProcess(NodeComponent bindCmp) {
specialAnalysisService.dataDayActivePowerHandle(bindCmp.getRequestData());
}
}

31
algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/service/line/ISpecialAnalysisService.java Normal file
View File

@@ -0,0 +1,31 @@
package com.njcn.algorithm.service.line;
import com.njcn.algorithm.pojo.bo.CalculatedParam;
/**
*@Author: wr
* @Description: 高低电压穿越记录
* @Author: wr
* @Date: 2025/4/1 15:22
*/
public interface ISpecialAnalysisService {
/**
* 高低电压穿越记录
* @param calculatedParam
* @Author: wr
* @Date: 2025/4/1 15:21
*/
void dataDaySpThroughHandle(CalculatedParam<String> calculatedParam);
/**
* 有功功率趋势
* @param calculatedParam
* @Author: wr
* @Date: 2025/4/1 18:44
*/
void dataDayActivePowerHandle(CalculatedParam<String> calculatedParam);
}

477
algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/serviceimpl/line/SpecialAnalysisServiceImpl.java Normal file
View File

@@ -0,0 +1,477 @@
package com.njcn.algorithm.serviceimpl.line;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.LocalDateTimeUtil;
import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.njcn.algorithm.pojo.bo.CalculatedParam;
import com.njcn.algorithm.service.line.ISpecialAnalysisService;
import com.njcn.dataProcess.api.DataHarmpowerPFeignClient;
import com.njcn.dataProcess.api.DataLimitRateDetailFeignClient;
import com.njcn.dataProcess.api.SpThroughFeignClient;
import com.njcn.dataProcess.param.LineCountEvaluateParam;
import com.njcn.dataProcess.pojo.dto.*;
import com.njcn.dataProcess.util.TimeUtils;
import com.njcn.device.biz.commApi.CommLineClient;
import com.njcn.device.biz.pojo.dto.LineDTO;
import com.njcn.device.pms.pojo.param.MonitorTerminalParam;
import com.njcn.device.pq.api.LineFeignClient;
import com.njcn.device.pq.pojo.vo.LineDetailDataVO;
import com.njcn.event.api.EventDetailFeignClient;
import com.njcn.event.api.TransientFeignClient;
import com.njcn.event.file.pojo.dto.WaveDataDTO;
import com.njcn.event.pojo.param.EventCountParam;
import com.njcn.event.pojo.po.RmpEventDetailPO;
import com.njcn.supervision.api.UserLedgerFeignClient;
import com.njcn.supervision.pojo.vo.user.NewUserReportVO;
import com.njcn.system.api.DicDataFeignClient;
import com.njcn.system.api.DictTreeFeignClient;
import com.njcn.system.enums.DicDataEnum;
import com.njcn.system.enums.DicTreeEnum;
import com.njcn.system.pojo.po.DictData;
import com.njcn.system.pojo.vo.DictTreeVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.ListUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.io.ByteArrayInputStream;
import java.io.ObjectInputStream;
import java.lang.reflect.Field;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 高低电压穿越 服务类
*
* @author guofeihu
* @since 2024-08-22
*/
@Service
@Slf4j
@RequiredArgsConstructor
public class SpecialAnalysisServiceImpl implements ISpecialAnalysisService {
@Value("${line.num}")
private Integer NUM = 100;
@Resource
private EventDetailFeignClient eventDetailFeignClient;
@Resource
private TransientFeignClient transientFeignClient;
@Resource
private LineFeignClient lineFeignClient;
@Resource
private DictTreeFeignClient dictTreeFeignClient;
@Resource
private DicDataFeignClient dicDataFeignClient;
@Resource
private SpThroughFeignClient spThroughFeignClient;
@Resource
private DataHarmpowerPFeignClient dataHarmpowerPFeignClient;
@Resource
private CommLineClient commLineClient;
@Resource
private UserLedgerFeignClient userLedgerFeignClient;
@Resource
private DataLimitRateDetailFeignClient dataLimitRateDetailFeignClient;
@Override
public void dataDaySpThroughHandle(CalculatedParam<String> calculatedParam) {
List<SpThroughDto> info = new ArrayList<>();
List<String> lineList = calculatedParam.getIdList();
if (CollUtil.isNotEmpty(lineList)) {
DictData dip = dicDataFeignClient.getDicDataByCode(DicDataEnum.VOLTAGE_DIP.getCode()).getData();
DictData rise = dicDataFeignClient.getDicDataByCode(DicDataEnum.VOLTAGE_RISE.getCode()).getData();
DictTreeVO windFarms = dictTreeFeignClient.queryByCode(DicTreeEnum.Wind_Farms.getCode()).getData();
DictTreeVO powerStation = dictTreeFeignClient.queryByCode(DicTreeEnum.Power_Station.getCode()).getData();
LocalDateTime currentTime = LocalDateTime.now();
List<List<String>> pendingIds = ListUtils.partition(lineList, NUM);
MonitorTerminalParam monitorTerminalParam = new MonitorTerminalParam();
monitorTerminalParam.setSystemType(0);
monitorTerminalParam.setType(0);
for (List<String> pendingId : pendingIds) {
List<LineDetailDataVO> lineDetailDataVOS = lineFeignClient.getLineDetailList(pendingId).getData();
if (CollUtil.isNotEmpty(lineDetailDataVOS)) {
Map<String, LineDetailDataVO> lineDetailDataMap = lineDetailDataVOS.stream().collect(Collectors.toMap(LineDetailDataVO::getLineId, Function.identity()));
EventCountParam param = new EventCountParam();
param.setIds(new ArrayList<>(lineDetailDataMap.keySet()));
param.setStartTime(TimeUtils.getBeginOfDay(calculatedParam.getDataDate()));
param.setEndTime(currentTime.format(DateTimeFormatter.ofPattern(DatePattern.NORM_DATETIME_PATTERN)));
List<RmpEventDetailPO> evenStDetailPOS = eventDetailFeignClient.getNewEventDetailByTime(param).getData();
for (RmpEventDetailPO rmpEventDetailPO : evenStDetailPOS) {
if (lineDetailDataMap.containsKey(rmpEventDetailPO.getMeasurementPointId())) {
LineDetailDataVO line = lineDetailDataMap.get(rmpEventDetailPO.getMeasurementPointId());
//准备高低电压穿越实体bean
SpThroughDto spThroughPO = new SpThroughDto();
spThroughPO.setEventId(rmpEventDetailPO.getEventId());
spThroughPO.setEventType(rmpEventDetailPO.getEventType());
spThroughPO.setStationType(line.getBigObjType());
//默认该事件没有穿越
spThroughPO.setIsOrNot(0);
//设置波形查询的条件:事件ID
monitorTerminalParam.setId(rmpEventDetailPO.getEventId());
//获取RMS波形数据(由于WaveDataDTO为复杂对象所以转成byte数组在进行反序列化)
byte[] bytes = transientFeignClient.getTransientAnalyseWaveToByteArray(monitorTerminalParam).getData();
WaveDataDTO waveDataDTO = null;
try {
ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bis);
//强转成WaveDataDTO
waveDataDTO = (WaveDataDTO) ois.readObject();
} catch (Exception e) {
e.printStackTrace();
}
//标称电压
if (line.getScale() != null) {
BigDecimal voltageLevel = BigDecimal.valueOf(Float.parseFloat(line.getScale()))
.divide(BigDecimal.valueOf(1.732), 2, RoundingMode.HALF_UP);
//格式化数据源
List<List<String>> newListRmsData = listRmsTimeDataFormat(waveDataDTO);
//暂升事件
if (rmpEventDetailPO.getEventType().equals(rise.getId())) {
if (BooleanUtil.or(isRiseThrough(125, 130, 500, voltageLevel, newListRmsData),
isRiseThrough(120, 125, 1000, voltageLevel, newListRmsData),
isRiseThrough(110, 120, 10000, voltageLevel, newListRmsData))) {
spThroughPO.setIsOrNot(1);
}
}
//暂降事件
if (rmpEventDetailPO.getEventType().equals(dip.getId())) {
//风电场
if (line.getBigObjType().equals(windFarms.getId())) {
if (BooleanUtil.or(isDipThrough(20, 625, 1, voltageLevel, newListRmsData),
isDipThrough(20, 2000, 2, voltageLevel, newListRmsData))
) {
spThroughPO.setIsOrNot(1);
}
}
//光伏电站
if (line.getBigObjType().equals(powerStation.getId())) {
if (BooleanUtil.or(isDipThrough(0, 150, 1, voltageLevel, newListRmsData),
isDipThrough(20, 625, 1, voltageLevel, newListRmsData),
isDipThrough(20, 90, null, voltageLevel, newListRmsData))) {
spThroughPO.setIsOrNot(1);
}
}
}
info.add(spThroughPO);
}
}
}
}
}
}
if (CollUtil.isNotEmpty(info)) {
spThroughFeignClient.batchInsertionThrough(info);
}
}
@Override
public void dataDayActivePowerHandle(CalculatedParam<String> calculatedParam) {
List<RActivePowerRangeDto> info = new ArrayList<>();
DictTreeVO windFarms = dictTreeFeignClient.queryByCode(DicTreeEnum.Wind_Farms.getCode()).getData();
List<String> lineList = calculatedParam.getIdList();
if (CollUtil.isNotEmpty(lineList)) {
List<LineDTO> data = commLineClient.getLineDetailBatch(lineList).getData();
List<LineDTO> windLine = data.stream()
.filter(x -> StrUtil.isNotBlank(x.getBigObjType()))
.filter(x -> x.getBigObjType().equals(windFarms.getId())).collect(Collectors.toList());
LineCountEvaluateParam lineParam = new LineCountEvaluateParam();
lineParam.setStartTime(TimeUtils.getBeginOfDay(calculatedParam.getDataDate()));
lineParam.setEndTime(TimeUtils.getEndOfDay(calculatedParam.getDataDate()));
LocalDate localDate = LocalDateTimeUtil.parseDate(calculatedParam.getDataDate(), DatePattern.NORM_DATE_PATTERN);
if (CollUtil.isNotEmpty(windLine)) {
List<List<LineDTO>> pendingIds = ListUtils.partition(windLine, NUM);
for (List<LineDTO> pendingId : pendingIds) {
//获取分钟有功功率数据
Map<String, String> objIdMap = pendingId.stream().collect(Collectors.toMap(LineDTO::getLineId, LineDTO::getObjId));
lineParam.setLineId(new ArrayList<>(objIdMap.keySet()));
List<DataPowerPDto> dataPowerPList = dataHarmpowerPFeignClient.getRawData(lineParam).getData();
Map<String, List<DataPowerPDto>> lineP = dataPowerPList.stream().collect(Collectors.groupingBy(DataPowerPDto::getLineId));
//获取用户信息
List<NewUserReportVO> userPower = userLedgerFeignClient.getUserReportByIds(new ArrayList<>(objIdMap.values())).getData();
Map<String, Double> userPowerMap = userPower.stream().collect(Collectors.toMap(NewUserReportVO::getId, NewUserReportVO::getRatePower));
lineP.forEach((lineId, dtoList) -> {
if (objIdMap.containsKey(lineId)) {
//根据监测点找到用户，再根据用户找到额定有功功率
String s = objIdMap.get(lineId);
if (userPowerMap.containsKey(s)) {
RActivePowerRangeDto dto = new RActivePowerRangeDto();
dto.setLineId(lineId);
dto.setTimeId(localDate);
Double ratePower = userPowerMap.get(s);
//默认初始10个空集合
List<String>[] min = new List[10];
for (int i = 0; i < 10; i++) {
min[i] = new ArrayList<>();
}
for (DataPowerPDto dataPowerPDto : dtoList) {
String minTime = dataPowerPDto.getMinTime().substring(11, dataPowerPDto.getMinTime().length());
double temp = BigDecimal.valueOf(ratePower)
.divide(BigDecimal.valueOf(dataPowerPDto.getP()), 4, RoundingMode.HALF_UP).doubleValue();
Integer i = getInteger(temp);
if (ObjectUtil.isNotNull(i)) {
min[i].add(minTime);
}
}
for (int i = 0; i < 10; i++) {
try {
Field minTime = RActivePowerRangeDto.class.getDeclaredField("minsTime" + i);
Field minNum = RActivePowerRangeDto.class.getDeclaredField("minsNum" + i);
Field isOrNot = RActivePowerRangeDto.class.getDeclaredField("isOrNot" + i);
minTime.setAccessible(true);
minNum.setAccessible(true);
isOrNot.setAccessible(true);
if (CollUtil.isEmpty(min[i])) {
minTime.set(dto, "[]");
} else {
List<String> mins = min[i].stream().distinct().collect(Collectors.toList());
minTime.set(dto, JSON.toJSONString(mins));
List<String> limitTime = dataLimitRateDetailFeignClient.getLimitRateDetailTime(lineId, calculatedParam.getDataDate()).getData();
if (CollUtil.isNotEmpty(limitTime)) {
List<String> collect = mins.stream().filter(x -> limitTime.contains(x)).collect(Collectors.toList());
if (CollUtil.isNotEmpty(collect)) {
isOrNot.set(dto, 1);
}
}
}
minNum.set(dto, min[i].size());
} catch (Exception e) {
e.printStackTrace();
}
}
info.add(dto);
}
}
});
}
}
}
if (CollUtil.isNotEmpty(info)) {
spThroughFeignClient.batchInsertionPower(info);
}
}
/**
* @param waveDataDTO
* @Description: 格式化RMS数据:将listRmsData中的电压数据取出在根据pt变比组成新的RMS数据
* @return: java.util.List<java.util.List < java.lang.Float>>
* @Author: wr
* @Date: 2025/3/26 19:49
*/
private List<List<String>> listRmsTimeDataFormat(WaveDataDTO waveDataDTO) {
//重新便利数据信息
List<List<String>> info = new ArrayList<>();
List<String> a = new ArrayList<>();
List<String> b = new ArrayList<>();
List<String> c = new ArrayList<>();
List<Integer> indexs = new ArrayList<>();
//根据channelNames取出电压对应listRmsData数据中的数据索引
for (int i = 0; i < waveDataDTO.getChannelNames().size(); i++) {
if (waveDataDTO.getChannelNames().get(i).indexOf("U") != -1) {
indexs.add(i);
}
}
//前端展示的波形图数据来源就是这个所以这边也跟前端保持一致
for (int i = 0; i < waveDataDTO.getListRmsData().size(); i++) {
List<Float> cur = waveDataDTO.getListRmsData().get(i);
//数组第一个为时间
Float time = cur.get(0);
if (time >= 0) {
//便利电压数据的索引
for (Integer index : indexs) {
//根据PT变比算出新的数据(前端取的一次值,也是根据pt变比算出的,所以这边和前端保持一致)新增到新的数组中
if (1 == index) {
a.add(time + "_" + cur.get(index));
}
if (2 == index) {
b.add(time + "_" + cur.get(index));
}
if (3 == index) {
c.add(time + "_" + cur.get(index));
}
}
}
}
info.add(a);
info.add(b);
info.add(c);
return info;
}
/**
* 暂降
* 风电场
* a）风电场并网点电压跌至标称电压的20%时,风电场内的风电机组应保证不脱网连续运行625 ms。
* b）风电场并网点电压在发生跌落后2s内能够恢复到标称电压的90%时,风电场内的风电机组应保证不脱网连续运行。
* 光伏电站
* a）光伏发电站并网点电压跌至0时,光伏发电站内的光伏逆变器和无功补偿装置应能够不脱网连续运行150 ms;
* b）光伏发电站并网点电压跌至标称电压的20%时,光伏发电站内的光伏逆变器和无功补偿装置n)应能够不脱网连续运行625ms;
* c）光伏发电站并网点电压跌至标称电压的20%以上至90%时,光伏发电站内的光伏逆变器和无功补偿装置应能在阴影区域内不脱网连续运行
*
* @return
*/
private boolean isDipThrough(int start, int ms, Integer option, BigDecimal voltageLevel, List<List<String>> newListRmsData) {
if (ObjectUtil.isNotNull(option)) {
for (List<String> newListRmsDatum : newListRmsData) {
List<String> temp = new ArrayList<>();
Double anchorPoint = -1.0;
for (String num : newListRmsDatum) {
String[] split = num.split("_");
Double time = Double.valueOf(split[0]);
Double v = Double.valueOf(split[1]);
//获得数据占比 (56.62/(220/1.732))*100
BigDecimal curValue = BigDecimal.valueOf(v).multiply(BigDecimal.valueOf(100))
.divide(voltageLevel, 2, RoundingMode.HALF_UP);
if (1 == option) {
//方案一：判断是否有跌落到20%的情况
if (start == curValue.doubleValue()) {
temp.add(num);
} else {
if (CollUtil.isNotEmpty(temp)) {
Integer startRms = Integer.valueOf(temp.get(0).split("_")[0]);
Integer endRms = Integer.valueOf(temp.get(temp.size()).split("_")[0]);
if (endRms - startRms > ms) {
return true;
}
temp = new ArrayList<>();
}
}
}
if (2 == option) {
//方案二：判断是否有跌落到90%的情况
if (voltageLevel.doubleValue() > v && anchorPoint != -1.0) {
anchorPoint = time + ms;
} else if (anchorPoint.equals(time)) {
if (v < voltageLevel.doubleValue() * 0.9) {
return true;
}
anchorPoint = -1.0;
}
}
if (3 == option) {
//方案三：20%以上至90%时，需要判断上升信息
// if (voltageLevel > v && anchorPoint != -1.0) {
// anchorPoint = time + ms;
// } else if (anchorPoint.equals(time)) {
// if (v < voltageLevel*0.9) {
// return true;
// }
// anchorPoint = -1.0;
// }
}
}
}
}
return false;
}
/**
* 暂升
* 风电场
* a）风电场并网点电压升高至标称电压的 125%~130%之间时,风电场内的风电机组应保证不脱网连续运行 500 ms;
* b）风电场并网点电压升高至标称电压的 120%~125%之间时,风电场内的风电机组应保证不脱网连续运行1s;
* c）风电场并网点电压升高至标称电压的 110%~120%之间时,风电场内的风电机组应保证不脱网连续运行 10 s。
* 光伏电站
* a）光伏发电站并网点电压升高至标称电压的125%以上至130%时,光伏发电站内的光伏逆变器和无功补偿装置应能够不脱网连续运行500ms;
* b）光伏发电站并网点电压升高至标称电压的120%以上至125%时,光伏发电站内的光伏逆变器和无功补偿装置应能够不脱网连续运行1s;
* c）光伏发电站并网点电压升高至标称电压的110%以上至120%时,光伏发电站内的光伏逆变器和其他无功补偿装置应能够不脱网连续运行10s。
*
* @Author: wr
* @Date: 2025/4/3 11:10
*/
private boolean isRiseThrough(int start, int end, int ms, BigDecimal voltageLevel, List<List<String>> newListRmsData) {
//分别有abc三相电压值 [0]是毫秒 [1]A相值 [2]B相值 [3]C相值
for (List<String> newListRmsDatum : newListRmsData) {
List<String> temp = new ArrayList<>();
for (String num : newListRmsDatum) {
String[] split = num.split("_");
Double v = Double.valueOf(split[1]);
//获得数据占比 (56.62/(220/1.732))*100
BigDecimal curValue = BigDecimal.valueOf(v).multiply(BigDecimal.valueOf(100))
.divide(voltageLevel
.divide(BigDecimal.valueOf(1.732), 2, RoundingMode.HALF_UP), 2, RoundingMode.HALF_UP);
if (NumberUtil.isIn(curValue, BigDecimal.valueOf(start), BigDecimal.valueOf(end))) {
temp.add(num);
} else {
if (CollUtil.isNotEmpty(temp)) {
int maxIndex = getMaxIndex(temp);
Integer startRms = Integer.valueOf(temp.get(maxIndex).split("_")[0]);
Integer endRms = Integer.valueOf(temp.get(temp.size()).split("_")[0]);
if (endRms - startRms > ms) {
return true;
}
temp = new ArrayList<>();
}
}
}
}
return false;
}
private int getMaxIndex(List<String> temp) {
double maxValue = Double.MIN_VALUE;
int maxIndex = -1;
for (int i = 0; i < temp.size(); i++) {
String[] parts = temp.get(i).split("_");
if (parts.length != 2) {
continue; // 跳过格式错误的元素
}
double value = Double.parseDouble(parts[1]);
if (value > maxValue) {
maxValue = value;
maxIndex = i;
}
}
return maxIndex;
}
private Integer getInteger(double temp) {
Integer i = null;
if (temp <= 0.1) {
i = 0;
} else if (0.1 < temp && temp <= 0.2) {
i = 1;
} else if (0.2 < temp && temp <= 0.3) {
i = 2;
} else if (0.3 < temp && temp <= 0.4) {
i = 3;
} else if (0.4 < temp && temp <= 0.5) {
i = 4;
} else if (0.5 < temp && temp <= 0.6) {
i = 5;
} else if (0.6 < temp && temp <= 0.7) {
i = 6;
} else if (0.7 < temp && temp <= 0.8) {
i = 7;
} else if (0.8 < temp && temp <= 0.9) {
i = 8;
} else if (temp > 0.9) {
i = 9;
}
return i;
}
}

6
data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/api/DataLimitRateDetailFeignClient.java
View File

@@ -1,14 +1,18 @@
package com.njcn.dataProcess.api; package com.njcn.dataProcess.api;
import com.njcn.common.pojo.annotation.OperateInfo;
import com.njcn.common.pojo.constant.ServerInfo; import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.enums.common.LogEnum;
import com.njcn.common.pojo.response.HttpResult; import com.njcn.common.pojo.response.HttpResult;
import com.njcn.dataProcess.api.fallback.DataLimitRateDetailFeignClientFallbackFactory; import com.njcn.dataProcess.api.fallback.DataLimitRateDetailFeignClientFallbackFactory;
import com.njcn.dataProcess.param.LineCountEvaluateParam; import com.njcn.dataProcess.param.LineCountEvaluateParam;
import com.njcn.dataProcess.pojo.dto.DataLimitRateDetailDto; import com.njcn.dataProcess.pojo.dto.DataLimitRateDetailDto;
import com.njcn.dataProcess.pojo.dto.DataLimitRateDto; import com.njcn.dataProcess.pojo.dto.DataLimitRateDto;
import io.swagger.annotations.ApiOperation;
import org.springframework.cloud.openfeign.FeignClient; import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List; import java.util.List;
@@ -26,4 +30,6 @@ public interface DataLimitRateDetailFeignClient {
@PostMapping("/getRawData") @PostMapping("/getRawData")
HttpResult<List<DataLimitRateDetailDto>> getRawData(@RequestBody LineCountEvaluateParam lineParam); HttpResult<List<DataLimitRateDetailDto>> getRawData(@RequestBody LineCountEvaluateParam lineParam);
@PostMapping("/getLimitRateDetailTime")
HttpResult<List<String>> getLimitRateDetailTime(@RequestParam("id") String id, @RequestParam("time") String time);
} }

30
data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/api/SpThroughFeignClient.java Normal file
View File

@@ -0,0 +1,30 @@
package com.njcn.dataProcess.api;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.dataProcess.api.fallback.RmpEventFeignClientFallbackFactory;
import com.njcn.dataProcess.api.fallback.SpThroughFeignClientFallbackFactory;
import com.njcn.dataProcess.dto.RmpEventDetailDTO;
import com.njcn.dataProcess.param.LineCountEvaluateParam;
import com.njcn.dataProcess.pojo.dto.RActivePowerRangeDto;
import com.njcn.dataProcess.pojo.dto.SpThroughDto;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import java.util.List;
/**
* @author denghuajun
* @version 1.0.0
* @date 2022年01月05日 15:11
*/
@FeignClient(value = ServerInfo.PLATFORM_DATA_PROCESSING_BOOT, path = "/specialAnalysis", fallbackFactory = SpThroughFeignClientFallbackFactory.class, contextId = "specialAnalysis")
public interface SpThroughFeignClient {
@PostMapping("/batchInsertionThrough")
HttpResult<String> batchInsertionThrough(@RequestBody List<SpThroughDto> dtoList);
@PostMapping("/batchInsertionPower")
HttpResult<String> batchInsertionPower(@RequestBody List<RActivePowerRangeDto> dtoList);
}

6
data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/api/fallback/DataLimitRateDetailFeignClientFallbackFactory.java
View File

@@ -50,6 +50,12 @@ public class DataLimitRateDetailFeignClientFallbackFactory implements FallbackFa
log.error("{}异常，降级处理，异常为：{}","获取基础数据",cause.toString()); log.error("{}异常，降级处理，异常为：{}","获取基础数据",cause.toString());
throw new BusinessException(finalExceptionEnum); throw new BusinessException(finalExceptionEnum);
} }
@Override
public HttpResult<List<String>> getLimitRateDetailTime(String id, String time) {
log.error("{}异常，降级处理，异常为：{}","根据监测点id获取所有超标时间",cause.toString());
throw new BusinessException(finalExceptionEnum);
}
}; };
} }
} }

60
data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/api/fallback/SpThroughFeignClientFallbackFactory.java Normal file
View File

@@ -0,0 +1,60 @@
package com.njcn.dataProcess.api.fallback;
import com.njcn.common.pojo.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.exception.BusinessException;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.dataProcess.api.RmpEventDetailFeignClient;
import com.njcn.dataProcess.api.SpThroughFeignClient;
import com.njcn.dataProcess.dto.RmpEventDetailDTO;
import com.njcn.dataProcess.param.LineCountEvaluateParam;
import com.njcn.dataProcess.pojo.dto.RActivePowerRangeDto;
import com.njcn.dataProcess.pojo.dto.SpThroughDto;
import com.njcn.dataProcess.util.DataProcessingEnumUtil;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* @author denghuajun
* @version 1.0.0
* @date 2022年01月05日 15:08
*/
@Slf4j
@Component
public class SpThroughFeignClientFallbackFactory implements FallbackFactory<SpThroughFeignClient> {
/**
* 输出远程请求接口异常日志
* @param cause RPC请求异常
*/
@Override
public SpThroughFeignClient create(Throwable cause) {
//判断抛出异常是否为解码器抛出的业务异常
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if(cause.getCause() instanceof BusinessException){
BusinessException businessException = (BusinessException) cause.getCause();
exceptionEnum = DataProcessingEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new SpThroughFeignClient() {
@Override
public HttpResult<String> batchInsertionThrough(List<SpThroughDto> dtoList) {
log.error("{}异常，降级处理，异常为：{}","高低电压穿越批量插入",cause.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<String> batchInsertionPower(List<RActivePowerRangeDto> dtoList) {
log.error("{}异常，降级处理，异常为：{}","有功功率批量插入",cause.toString());
throw new BusinessException(finalExceptionEnum);
}
};
}
}

1
data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/pojo/dto/DataQualifiedDetail.java
View File

@@ -16,7 +16,6 @@ public class DataQualifiedDetail {
*/ */
private String lineId; private String lineId;
/** /**
* 合格率时间 * 合格率时间
*/ */

180
data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/pojo/dto/RActivePowerRangeDto.java Normal file
View File

@@ -0,0 +1,180 @@
package com.njcn.dataProcess.pojo.dto;
import lombok.Data;
import java.time.LocalDate;
/**
* 有功功率趋势
* @Author: wr
* @Date: 2025/4/1 19:33
*/
@Data
public class RActivePowerRangeDto {
/**
* 监测点ID
*/
private String lineId;
/**
* 日期（天）
*/
private LocalDate timeId;
/**
* 0%~10%区间时间Json
*/
private String minsTime0;
/**
* 0%~10%区间个数
*/
private Integer minsNum0 = 0;
/**
* 0%~10%区间是否越限
*/
private Integer isOrNot0 = 0;
/**
* 10%~20%区间时间Json
*/
private String minsTime1;
/**
* 10%~20%区间个数
*/
private Integer minsNum1 = 0;
/**
* 10%~20%区间是否越限
*/
private Integer isOrNot1 = 0;
/**
* 20%~30%区间时间Json
*/
private String minsTime2;
/**
* 20%~30%区间个数
*/
private Integer minsNum2 = 0;
/**
* 20%~30%区间是否越限
*/
private Integer isOrNot2 = 0;
/**
* 30%~40%区间时间Json
*/
private String minsTime3;
/**
* 30%~40%区间个数
*/
private Integer minsNum3 = 0;
/**
* 30%~40%区间是否越限
*/
private Integer isOrNot3 = 0;
/**
* 40%~50%区间时间Json
*/
private String minsTime4;
/**
* 40%~50%区间个数
*/
private Integer minsNum4 = 0;
/**
* 40%~50%区间是否越限
*/
private Integer isOrNot4 = 0;
/**
* 50%~60%区间时间Json
*/
private String minsTime5;
/**
* 50%~60%区间个数
*/
private Integer minsNum5 = 0;
/**
* 50%~60%区间是否越限
*/
private Integer isOrNot5 = 0;
/**
* 60%~70%区间时间Json
*/
private String minsTime6;
/**
* 60%~70%区间个数
*/
private Integer minsNum6 = 0;
/**
* 60%~70%区间是否越限
*/
private Integer isOrNot6 = 0;
/**
* 70%~80%区间时间Json
*/
private String minsTime7;
/**
* 70%~80%区间个数
*/
private Integer minsNum7 = 0;
/**
* 70%~80%区间是否越限
*/
private Integer isOrNot7 = 0;
/**
* 80%~90%区间时间Json
*/
private String minsTime8;
/**
* 80%~90%区间个数
*/
private Integer minsNum8 = 0;
/**
* 80%~90%区间是否越限
*/
private Integer isOrNot8 = 0;
/**
* 90%~100%区间时间Json
*/
private String minsTime9;
/**
* 90%~100%区间个数
*/
private Integer minsNum9 = 0;
/**
* 90%~100%区间是否越限
*/
private Integer isOrNot9 = 0;
/**
* 状态：0-删除 1-正常
*/
private Integer state;
}

33
data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/pojo/dto/SpThroughDto.java Normal file
View File

@@ -0,0 +1,33 @@
package com.njcn.dataProcess.pojo.dto;
import lombok.Data;
/**
* @Description: 高低电压穿越 实体类
* @Author: wr
* @Date: 2025/4/1 15:55
*/
@Data
public class SpThroughDto {
/**
* 暂降事件ID
*/
private String eventId;
/**
* 暂降类型（暂升、暂降）
*/
private String eventType;
/**
* （关联Dic_tree表）变电站类型（风电场、光伏电站）
*/
private String stationType;
/**
* 是否穿越
*/
private Integer isOrNot;
}

225
data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/pojo/po/RActivePowerRange.java Normal file
View File

@@ -0,0 +1,225 @@
package com.njcn.dataProcess.pojo.po;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.github.jeffreyning.mybatisplus.anno.MppMultiId;
import com.njcn.db.bo.BaseEntity;
import lombok.Data;
import java.time.LocalDate;
/**
* 有功功率趋势
* @Author: wr
* @Date: 2025/4/1 19:33
*/
@Data
@TableName("r_active_power_range")
public class RActivePowerRange extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* 日期（天）
*/
@MppMultiId
@TableField(value = "time_id")
private LocalDate timeId;
/**
* 监测点ID
*/
@MppMultiId
@TableField(value = "line_id")
private String lineId;
/**
* 0%~10%区间时间Json
*/
@TableField(value = "mins_time0")
private String minsTime0;
/**
* 0%~10%区间个数
*/
@TableField(value = "mins_num0")
private Integer minsNum0 = 0;
/**
* 0%~10%区间是否越限
*/
@TableField(value = "is_or_not0")
private Integer isOrNot0 = 0;
/**
* 10%~20%区间时间Json
*/
@TableField(value = "mins_time1")
private String minsTime1;
/**
* 10%~20%区间个数
*/
@TableField(value = "mins_num1")
private Integer minsNum1 = 0;;
/**
* 10%~20%区间是否越限
*/
@TableField(value = "is_or_not1")
private Integer isOrNot1 = 0;
/**
* 20%~30%区间时间Json
*/
@TableField(value = "mins_time2")
private String minsTime2;
/**
* 20%~30%区间个数
*/
@TableField(value = "mins_num2")
private Integer minsNum2 = 0;;
/**
* 20%~30%区间是否越限
*/
@TableField(value = "is_or_not2")
private Integer isOrNot2 = 0;
/**
* 30%~40%区间时间Json
*/
@TableField(value = "mins_time3")
private String minsTime3;
/**
* 30%~40%区间个数
*/
@TableField(value = "mins_num3")
private Integer minsNum3 = 0;;
/**
* 30%~40%区间是否越限
*/
@TableField(value = "is_or_not3")
private Integer isOrNot3 = 0;
/**
* 40%~50%区间时间Json
*/
@TableField(value = "mins_time4")
private String minsTime4;
/**
* 40%~50%区间个数
*/
@TableField(value = "mins_num4")
private Integer minsNum4 = 0;;
/**
* 40%~50%区间是否越限
*/
@TableField(value = "is_or_not4")
private Integer isOrNot4 = 0;
/**
* 50%~60%区间时间Json
*/
@TableField(value = "mins_time5")
private String minsTime5;
/**
* 50%~60%区间个数
*/
@TableField(value = "mins_num5")
private Integer minsNum5 = 0;;
/**
* 50%~60%区间是否越限
*/
@TableField(value = "is_or_not5")
private Integer isOrNot5 = 0;
/**
* 60%~70%区间时间Json
*/
@TableField(value = "mins_time6")
private String minsTime6;
/**
* 60%~70%区间个数
*/
@TableField(value = "mins_num6")
private Integer minsNum6 = 0;;
/**
* 60%~70%区间是否越限
*/
@TableField(value = "is_or_not6")
private Integer isOrNot6 = 0;
/**
* 70%~80%区间时间Json
*/
@TableField(value = "mins_time7")
private String minsTime7;
/**
* 70%~80%区间个数
*/
@TableField(value = "mins_num7")
private Integer minsNum7 = 0;;
/**
* 70%~80%区间是否越限
*/
@TableField(value = "is_or_not7")
private Integer isOrNot7 = 0;
/**
* 80%~90%区间时间Json
*/
@TableField(value = "mins_time8")
private String minsTime8;
/**
* 80%~90%区间个数
*/
@TableField(value = "mins_num8")
private Integer minsNum8 = 0;;
/**
* 80%~90%区间是否越限
*/
@TableField(value = "is_or_not8")
private Integer isOrNot8 = 0;
/**
* 90%~100%区间时间Json
*/
@TableField(value = "mins_time9")
private String minsTime9;
/**
* 90%~100%区间个数
*/
@TableField(value = "mins_num9")
private Integer minsNum9 = 0;;
/**
* 90%~100%区间是否越限
*/
@TableField(value = "is_or_not9")
private Integer isOrNot9 = 0;
/**
* 状态：0-删除 1-正常
*/
@TableField(value = "state")
private Integer state;
}

55
data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/pojo/po/SpThrough.java Normal file
View File

@@ -0,0 +1,55 @@
package com.njcn.dataProcess.pojo.po;
import com.baomidou.mybatisplus.annotation.TableName;
import com.njcn.db.bo.BaseEntity;
import lombok.Data;
import java.time.LocalDateTime;
/**
* @Description: 高低电压穿越 实体类
* @Author: wr
* @Date: 2025/4/1 15:55
*/
@Data
@TableName("sp_through")
public class SpThrough extends BaseEntity {
private static final long serialVersionUID = 1L;
/**
* ID
*/
private String id;
/**
* 暂降事件ID
*/
private String eventId;
/**
* 暂降类型（暂升、暂降）
*/
private String eventType;
/**
* （关联PQS_Dictionary表）变电站类型（风电场、光伏电站）
*/
private String stationType;
/**
* 是否穿越
*/
private Integer isOrNot;
/**
* 状态：0-删除 1-正常
*/
private Boolean state;
/**
* 创建时间(自定义)
*/
private LocalDateTime createTime;
}

14
data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/DataLimitRateDetailController.java
View File

@@ -18,10 +18,7 @@ import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller; import org.springframework.stereotype.Controller;
import org.springframework.validation.annotation.Validated; import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.*;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List; import java.util.List;
@@ -54,7 +51,14 @@ public class DataLimitRateDetailController extends BaseController {
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe); return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
} }
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/getLimitRateDetailTime")
@ApiOperation("根据监测点id获取所有超标时间")
public HttpResult< List<String>> getLimitRateDetailTime(@RequestParam("id") String id, @RequestParam("time") String time) {
String methodDescribe = getMethodDescribe("getLimitRateDetailTime");
List<String> limitRateDetailTime = limitRateDetailInsert.getLimitRateDetailTime(id, time);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, limitRateDetailTime, methodDescribe);
}
@OperateInfo(info = LogEnum.BUSINESS_COMMON) @OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/getRawData") @PostMapping("/getRawData")
@ApiOperation("获取原始数据") @ApiOperation("获取原始数据")

52
data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/RActivePowerRangeController.java Normal file
View File

@@ -0,0 +1,52 @@
package com.njcn.dataProcess.controller;
import com.njcn.common.pojo.annotation.OperateInfo;
import com.njcn.common.pojo.constant.OperateType;
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.dataProcess.annotation.InsertBean;
import com.njcn.dataProcess.pojo.dto.RActivePowerRangeDto;
import com.njcn.dataProcess.pojo.dto.SpThroughDto;
import com.njcn.dataProcess.service.IRActivePowerRangeService;
import com.njcn.dataProcess.service.ISpThroughService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* @author hongawen
* @version 1.0
* @data 2024/11/6 19:48
*/
@Validated
@Slf4j
@Controller
@RestController
@RequestMapping("/specialAnalysis")
@Api(tags = "有功功率数据获取")
public class RActivePowerRangeController extends BaseController {
@InsertBean
private IRActivePowerRangeService irActivePowerRangeService;
@OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
@PostMapping("/batchInsertionPower")
@ApiOperation("有功功率批量插入")
public HttpResult<String> batchInsertionPower(@RequestBody List<RActivePowerRangeDto> dtoList) {
String methodDescribe = getMethodDescribe("batchInsertionPower");
irActivePowerRangeService.batchInsertion(dtoList);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

47
data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/SpThroughController.java Normal file
View File

@@ -0,0 +1,47 @@
package com.njcn.dataProcess.controller;
import com.njcn.common.pojo.annotation.OperateInfo;
import com.njcn.common.pojo.constant.OperateType;
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.dataProcess.annotation.InsertBean;
import com.njcn.dataProcess.pojo.dto.SpThroughDto;
import com.njcn.dataProcess.service.ISpThroughService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Controller;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* @author hongawen
* @version 1.0
* @data 2024/11/6 19:48
*/
@Validated
@Slf4j
@Controller
@RestController
@RequestMapping("/specialAnalysis")
@Api(tags = "高低电压穿越数据获取")
public class SpThroughController extends BaseController {
@InsertBean
private ISpThroughService spThroughService;
@OperateInfo(info = LogEnum.BUSINESS_COMMON,operateType = OperateType.ADD)
@PostMapping("/batchInsertionThrough")
@ApiOperation("高低电压穿越批量插入")
public HttpResult<String> batchInsertionThrough(@RequestBody List<SpThroughDto> dtoList) {
String methodDescribe = getMethodDescribe("batchInsertionThrough");
spThroughService.batchInsertion(dtoList);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}

13
data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/dao/relation/mapper/RActivePowerRangeMapper.java Normal file
View File

@@ -0,0 +1,13 @@
package com.njcn.dataProcess.dao.relation.mapper;
import com.github.jeffreyning.mybatisplus.base.MppBaseMapper;
import com.njcn.dataProcess.pojo.po.RActivePowerRange;
/**
* 有功功率趋势 Mapper 接口
* @author guofeihu
* @since 2024-08-20
*/
public interface RActivePowerRangeMapper extends MppBaseMapper<RActivePowerRange> {
}

14
data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/dao/relation/mapper/SpThroughMapper.java Normal file
View File

@@ -0,0 +1,14 @@
package com.njcn.dataProcess.dao.relation.mapper;
import com.github.jeffreyning.mybatisplus.base.MppBaseMapper;
import com.njcn.dataProcess.pojo.po.SpThrough;
/**
* @Description: 高低电压穿越
* @Author: wr
* @Date: 2025/4/1 16:03
*/
public interface SpThroughMapper extends MppBaseMapper<SpThrough> {
}

9
data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/IDataLimitRateDetail.java
View File

@@ -15,6 +15,15 @@ import java.util.List;
*/ */
public interface IDataLimitRateDetail extends IMppService<RStatLimitRateDetailD> { public interface IDataLimitRateDetail extends IMppService<RStatLimitRateDetailD> {
/**
* 根据监测点id获取所有超标时间
* @param id
* @return: java.util.List<java.lang.String>
* @Author: wr
* @Date: 2025/4/2 10:49
*/
List<String> getLimitRateDetailTime(String id,String time);
/** /**
* 批量插入数据 * 批量插入数据
* @param limitRateDetailList * @param limitRateDetailList

24
data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/IRActivePowerRangeService.java Normal file
View File

@@ -0,0 +1,24 @@
package com.njcn.dataProcess.service;
import com.github.jeffreyning.mybatisplus.service.IMppService;
import com.njcn.dataProcess.pojo.dto.RActivePowerRangeDto;
import com.njcn.dataProcess.pojo.po.RActivePowerRange;
import java.util.List;
/**
* 有功功率趋势 服务类
* @author guofeihu
* @since 2024-08-22
*/
public interface IRActivePowerRangeService extends IMppService<RActivePowerRange> {
/**
* 批量插入数据
* @param dtoList
* @Author: wr
* @Date: 2025/3/14 14:03
*/
void batchInsertion(List<RActivePowerRangeDto> dtoList);
}

25
data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/ISpThroughService.java Normal file
View File

@@ -0,0 +1,25 @@
package com.njcn.dataProcess.service;
import com.github.jeffreyning.mybatisplus.service.IMppService;
import com.njcn.dataProcess.pojo.dto.SpThroughDto;
import com.njcn.dataProcess.pojo.po.SpThrough;
import java.util.List;
/**
* @Description: 高低电压穿越
* @Author: wr
* @Date: 2025/4/1 16:09
*/
public interface ISpThroughService extends IMppService<SpThrough> {
/**
* 批量插入数据
* @param dtoList
* @Author: wr
* @Date: 2025/3/14 14:03
*/
void batchInsertion(List<SpThroughDto> dtoList);
}

6
data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/influxdb/InfluxdbDataLimitRateDetailImpl.java
View File

@@ -9,6 +9,7 @@ import com.njcn.dataProcess.service.IDataLimitRateDetail;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.util.Collections;
import java.util.List; import java.util.List;
/** /**
@@ -20,6 +21,11 @@ import java.util.List;
@RequiredArgsConstructor @RequiredArgsConstructor
public class InfluxdbDataLimitRateDetailImpl extends MppServiceImpl<RStatLimitRateDetailRelationMapper, RStatLimitRateDetailD> implements IDataLimitRateDetail { public class InfluxdbDataLimitRateDetailImpl extends MppServiceImpl<RStatLimitRateDetailRelationMapper, RStatLimitRateDetailD> implements IDataLimitRateDetail {
@Override
public List<String> getLimitRateDetailTime(String id,String time) {
return Collections.emptyList();
}
@Override @Override
public void batchInsertion(List<DataLimitRateDetailDto> limitRateList) { public void batchInsertion(List<DataLimitRateDetailDto> limitRateList) {

49
data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationDataLimitRateDetailImpl.java
View File

@@ -2,20 +2,25 @@ package com.njcn.dataProcess.service.impl.relation;
import cn.hutool.core.collection.CollUtil; import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSON;
import com.github.jeffreyning.mybatisplus.service.MppServiceImpl; import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
import com.njcn.dataProcess.dao.relation.mapper.RStatLimitRateDetailRelationMapper; import com.njcn.dataProcess.dao.relation.mapper.RStatLimitRateDetailRelationMapper;
import com.njcn.dataProcess.pojo.dto.AbnormalData;
import com.njcn.dataProcess.param.LineCountEvaluateParam; import com.njcn.dataProcess.param.LineCountEvaluateParam;
import com.njcn.dataProcess.pojo.dto.DataLimitRateDetailDto; import com.njcn.dataProcess.pojo.dto.DataLimitRateDetailDto;
import com.njcn.dataProcess.pojo.dto.DataQualifiedDetail;
import com.njcn.dataProcess.pojo.po.RStatLimitQualifiedD;
import com.njcn.dataProcess.pojo.po.RStatLimitRateDetailD; import com.njcn.dataProcess.pojo.po.RStatLimitRateDetailD;
import com.njcn.dataProcess.service.IDataLimitRateDetail; import com.njcn.dataProcess.service.IDataLimitRateDetail;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils; import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import java.lang.reflect.Field;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.stream.Collectors;
/** /**
@@ -28,6 +33,46 @@ import java.util.List;
public class RelationDataLimitRateDetailImpl extends MppServiceImpl<RStatLimitRateDetailRelationMapper, RStatLimitRateDetailD> implements IDataLimitRateDetail { public class RelationDataLimitRateDetailImpl extends MppServiceImpl<RStatLimitRateDetailRelationMapper, RStatLimitRateDetailD> implements IDataLimitRateDetail {
@Override
public List<String> getLimitRateDetailTime(String id, String time) {
RStatLimitRateDetailD one = this.getOne(new LambdaQueryWrapper<RStatLimitRateDetailD>()
.eq(RStatLimitRateDetailD::getLineId, id)
.eq(RStatLimitRateDetailD::getTime, time)
);
if (ObjectUtil.isNotNull(one)) {
List<AbnormalData.Json> json = new ArrayList<>();
try {
// 获取类的Class对象
Class<RStatLimitRateDetailD> clazz = RStatLimitRateDetailD.class;
// 获取类中声明的所有字段
Field[] fields = clazz.getDeclaredFields();
// 遍历字段数组
for (Field field : fields) {
if (!"lineId".equals(field.getName()) && !"time".equals(field.getName())) {
field.setAccessible(true);
Object o = field.get(one);
if (ObjectUtil.isNotNull(o)) {
String string = o.toString();
json.addAll(JSON.parseArray(string, AbnormalData.Json.class));
}
}
// 获取字段的类型
Class<?> fieldType = field.getType();
System.out.println("Field name: " + field.getName() + ", Type: " + fieldType.getName());
}
} catch (SecurityException |IllegalAccessException e) {
e.printStackTrace();
}
if (CollUtil.isNotEmpty(json)){
List<String> times = json.stream().map(AbnormalData.Json::getTime).collect(Collectors.toList());
String join = String.join(",", times);
String[] split = join.split(",");
return Arrays.stream(split).distinct().collect(Collectors.toList());
}
}
return Collections.emptyList();
}
@Override @Override
public void batchInsertion(List<DataLimitRateDetailDto> limitRateList) { public void batchInsertion(List<DataLimitRateDetailDto> limitRateList) {
List<RStatLimitRateDetailD> result = new ArrayList<>(); List<RStatLimitRateDetailD> result = new ArrayList<>();

37
data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationRActivePowerRangeServiceImpl.java Normal file
View File

@@ -0,0 +1,37 @@
package com.njcn.dataProcess.service.impl.relation;
import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
import com.njcn.dataProcess.dao.relation.mapper.RActivePowerRangeMapper;
import com.njcn.dataProcess.pojo.dto.RActivePowerRangeDto;
import com.njcn.dataProcess.pojo.po.RActivePowerRange;
import com.njcn.dataProcess.service.IRActivePowerRangeService;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
/**
* @Description: 有功功率
* @Author: wr
* @Date: 2025/4/1 16:03
*/
@Service("RelationRActivePowerRangeServiceImpl")
@RequiredArgsConstructor
public class RelationRActivePowerRangeServiceImpl extends MppServiceImpl<RActivePowerRangeMapper, RActivePowerRange> implements IRActivePowerRangeService {
@Override
public void batchInsertion(List<RActivePowerRangeDto> dtoList) {
List<RActivePowerRange> result = new ArrayList<>();
dtoList.forEach(item->{
RActivePowerRange powerRange = new RActivePowerRange();
BeanUtils.copyProperties(item, powerRange);
powerRange.setState(1);
result.add(powerRange);
});
this.saveOrUpdateBatchByMultiId(result);
}
}

44
data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationSpThroughServiceImpl.java Normal file
View File

@@ -0,0 +1,44 @@
package com.njcn.dataProcess.service.impl.relation;
import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.github.jeffreyning.mybatisplus.service.MppServiceImpl;
import com.njcn.dataProcess.dao.relation.mapper.SpThroughMapper;
import com.njcn.dataProcess.pojo.dto.SpThroughDto;
import com.njcn.dataProcess.pojo.po.RStatPollutionSubstationY;
import com.njcn.dataProcess.pojo.po.SpThrough;
import com.njcn.dataProcess.service.ISpThroughService;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Description: 高低电压穿越
* @Author: wr
* @Date: 2025/4/1 16:03
*/
@Service("RelationSpThroughServiceImpl")
@RequiredArgsConstructor
public class RelationSpThroughServiceImpl extends MppServiceImpl<SpThroughMapper, SpThrough> implements ISpThroughService {
@Override
public void batchInsertion(List<SpThroughDto> dtoList) {
List<String> eventIds = dtoList.stream().map(SpThroughDto::getEventId).distinct().collect(Collectors.toList());
List<SpThrough> result = new ArrayList<>();
dtoList.forEach(item->{
SpThrough limitRate = new SpThrough();
BeanUtils.copyProperties(item, limitRate);
limitRate.setId(IdUtil.simpleUUID());
limitRate.setState(true);
result.add(limitRate);
});
this.remove(new LambdaQueryWrapper<SpThrough>().in(SpThrough::getEventId,eventIds));
this.saveBatch(result);
}
}