新能源专项分析算法迁移

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

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

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

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

algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/ExecutionCenter.java

@@ -18,6 +18,7 @@ import com.njcn.common.pojo.exception.BusinessException;
 import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
 import com.njcn.device.biz.pojo.dto.*;
 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.pojo.po.Dept;
 import com.njcn.web.controller.BaseController;
@@ -26,7 +27,6 @@ import com.yomahub.liteflow.flow.LiteflowResponse;
 import com.yomahub.liteflow.flow.entity.CmpStep;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
-import lombok.Data;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections.CollectionUtils;
@@ -62,7 +62,8 @@ public class ExecutionCenter extends BaseController {
     private DeptFeignClient deptFeignClient;
     @Resource
     private FlowExecutor flowExecutor;
-
+    @Resource
+    private DeptLineFeignClient deptLineFeignClient;
 
     /***
      * 1、校验非全链执行时，tagNames节点标签集合必须为非空，否则提示---无可执行节点
@@ -125,8 +126,6 @@ public class ExecutionCenter extends BaseController {
         CalculatedParam calculatedParam = judgeExecuteParam(baseParam);
         // 测点索引
         if (CollectionUtils.isEmpty(calculatedParam.getIdList())) {
-//            calculatedParam.setIdList(Arrays.asList("c5f4925dbe333230810fe1a6afc51dfb","293178e56cd207e6e33586090f5034be","2df0cb6a87ef523b726c0a9ff6cfd288","43a1391b503bcd7f1b9a2f8f90e53e0f"
-//                    ));
             calculatedParam.setIdList(commTerminalGeneralClient.getRunMonitorIds().getData());
         }
         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)
     @ApiOperation("监测点算法执行链(按小时执行的算法)")
     @PostMapping("/measurementPointExecutorByHour")
@@ -188,7 +221,7 @@ public class ExecutionCenter extends BaseController {
             }
         } else {
             //非补招
-            calculatedParam.setDataDate(DateUtil.format(DateUtil.offsetHour( DateUtil.parse(baseParam.getDataDate(), DatePattern.NORM_DATETIME_FORMAT),-1), DatePattern.NORM_DATETIME_FORMATTER));
+            calculatedParam.setDataDate(DateUtil.format(DateUtil.offsetHour(DateUtil.parse(baseParam.getDataDate(), DatePattern.NORM_DATETIME_FORMAT), -1), DatePattern.NORM_DATETIME_FORMATTER));
             liteflowResponse = flowExecutor.execute2Resp("measurement_point_hour", calculatedParam);
             dealResponse(calculatedParam, liteflowResponse, methodDescribe);
         }
@@ -272,7 +305,8 @@ public class ExecutionCenter extends BaseController {
         }
 
     }
-//
+
+    //
 //    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
 //    @ApiOperation("pms国网上送单位层级算法执行链")
 //    @PostMapping("/uploadOrgExecutor")

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

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

algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/executor/SpecialAnalysisExecutor.java

@@ -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());
+    }
+}

algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/service/line/ISpecialAnalysisService.java

@@ -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);
+
+}

algorithm/algorithm-boot/src/main/java/com/njcn/algorithm/serviceimpl/line/SpecialAnalysisServiceImpl.java

@@ -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;
+    }
+
+}

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

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

data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/api/SpThroughFeignClient.java

@@ -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);
+}

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

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

data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/api/fallback/SpThroughFeignClientFallbackFactory.java

@@ -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);
+            }
+
+
+
+        };
+    }
+}

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

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

data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/pojo/dto/RActivePowerRangeDto.java

@@ -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;
+
+}

data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/pojo/dto/SpThroughDto.java

@@ -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;
+
+}

data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/pojo/po/RActivePowerRange.java

@@ -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;
+
+}

data-processing/data-processing-api/src/main/java/com/njcn/dataProcess/pojo/po/SpThrough.java

@@ -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;
+
+}

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

@@ -18,10 +18,7 @@ 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.*;
-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;
 
@@ -54,7 +51,14 @@ public class DataLimitRateDetailController extends BaseController {
         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)
     @PostMapping("/getRawData")
     @ApiOperation("获取原始数据")

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/RActivePowerRangeController.java

@@ -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);
+    }
+
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/controller/SpThroughController.java

@@ -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);
+    }
+
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/dao/relation/mapper/RActivePowerRangeMapper.java

@@ -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> {
+
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/dao/relation/mapper/SpThroughMapper.java

@@ -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> {
+
+}

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

@@ -15,6 +15,15 @@ import java.util.List;
  */
 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

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/IRActivePowerRangeService.java

@@ -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);
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/ISpThroughService.java

@@ -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);
+
+}

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

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

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

@@ -2,20 +2,25 @@ package com.njcn.dataProcess.service.impl.relation;
 
 import cn.hutool.core.collection.CollUtil;
 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.njcn.dataProcess.dao.relation.mapper.RStatLimitRateDetailRelationMapper;
+import com.njcn.dataProcess.pojo.dto.AbnormalData;
 import com.njcn.dataProcess.param.LineCountEvaluateParam;
 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.service.IDataLimitRateDetail;
 import lombok.RequiredArgsConstructor;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 
+import java.lang.reflect.Field;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
+import java.util.stream.Collectors;
 
 
 /**
@@ -28,10 +33,50 @@ import java.util.List;
 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
     public void batchInsertion(List<DataLimitRateDetailDto> limitRateList) {
         List<RStatLimitRateDetailD> result = new ArrayList<>();
-        limitRateList.forEach(item->{
+        limitRateList.forEach(item -> {
             RStatLimitRateDetailD limitRate = new RStatLimitRateDetailD();
             BeanUtils.copyProperties(item, limitRate);
             result.add(limitRate);

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationRActivePowerRangeServiceImpl.java

@@ -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);
+    }
+}

data-processing/data-processing-boot/src/main/java/com/njcn/dataProcess/service/impl/relation/RelationSpThroughServiceImpl.java

@@ -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);
+    }
+}