feat(零碳): 长庆演示系统新增功能

1.修改第三方日累计数据推送表表结构,增加日累计储能放电量字段,同时修改代码对应实体及mapper文件,修改相关接口增加储能日累计放电量接收逻辑;
2.修改首页井场收益分析模块接口,修改获取储能累计放电量逻辑;
3.设计并创建井口日用电趋势表,生成对应实体类及mapper文件;
4.统计分析模块,新增本月累计节电经济效益查询接口,添加线上接口文档并完成接口冒烟测试;
5.统计分析模块,新增本月累计减碳量查询接口,添加线上接口文档并完成接口冒烟测试;
6.统计分析模块,新增光伏发电趋势查询接口,添加线上接口文档并完成接口冒烟测试;
7.统计分析模块,新增月度总览查询接口,添加线上接口文档并完成接口冒烟测试;

BREAKING CHANGE: 无

Closes 无

[skip ci]

C11-space/pps-core-space/src/main/java/pps/core/space/service/SpaceOptimizeBaseService.java

@@ -208,6 +208,8 @@ public class SpaceOptimizeBaseService {
         List<DynamicQueryPlantPredictedPowerOutput> powerList;
         List<GetBasePriceStrategyDetailOutput> strategyList;
         List<SpaceInstitutionWellheadView> wellheadList;
+        List<SpaceInstitutionWellheadView> unOptimizeWellhead;
+        List<String> plantIds;
         String periodId;
         Map<Boolean, List<SpaceInstitutionWellheadView>> collect;
         //权重数组
@@ -220,7 +222,11 @@ public class SpaceOptimizeBaseService {
         DateTime optimizeDate;
         DateTime begin;
         DateTime recordTime;
+        boolean isOffGrid;
+        List<SpaceOptimizeDurationDTO> offGridDTOList = null;
         for (SpaceInstitutionDetailEnt detail : detailEntList) {
+            //是否离网型线路
+            isOffGrid = CharSequenceUtil.equals(detail.getGridTypeKey(), "0");
             //查最新间开历史
             if (this.isOptimize(context, detail.getId(), flag, startDate)) {
                 continue;
@@ -231,37 +237,44 @@ public class SpaceOptimizeBaseService {
             if (optimizeDeadline.compareTo(institutionEndDate) > 0) {
                 optimizeDeadline = DateUtil.endOfDay(institutionEndDate);
             }
+            //取峰谷策略
+            strategyList = strategyMap.get(lineMap.get(detail.getLineId()));
+            //按是否需要优化分组
+            collect = wellheadMap.get(detail.getId()).stream()
+                    .sorted(Comparator.comparing(SpaceInstitutionWellheadView::getStartSeq))
+                    .collect(
+                            Collectors.partitioningBy(w ->
+                                    CharSequenceUtil.equals(BusinessConstant.INTERVAL_PUMPING_WELL, w.getRunTypeKey()) &&
+                                            CharSequenceUtil.equals("0", w.getIntervalTypeKey())
+                            )
+                    );
+            //取待优化井口并遍历
+            wellheadList = collect.get(Boolean.TRUE);
+            //保存不需要优化的井口
+            unOptimizeWellhead = collect.get(Boolean.FALSE);
+            //电站ID列表
+            plantIds = plantIdsMap.get(detail.getLineId());
+            if (CollUtil.isEmpty(plantIds) || (CollUtil.isEmpty(wellheadList) && CollUtil.isEmpty(unOptimizeWellhead))) {
+                //没有电站不优化
+                continue;
+            }
             //创建记录
             periodId = this.createOptimizePeriod(periodDTOList, detail.getId(), detail.getLineId(),
                     BaseUtils.getExecutionCycleForCalibration(startDate, DateUtil.offsetDay(optimizeDeadline, -1)), optimizeDeadline);
+            //按天优化
             for (int d = 0; d < offset; d++) {
                 begin = DateUtil.offsetDay(startDate, d);
                 optimizeDate = DateUtil.offsetDay(startDate, d + 1);
                 recordTime = offset > 1 ? begin : optimizeDate;
                 //查预测光伏出力
                 powerList = this.getAveragePowerHalfHour(context, DynamicQueryPlantPredictedPowerInput.builder()
-                        .plantIds(plantIdsMap.get(detail.getLineId()))
+                        .plantIds(plantIds)
                         .startTime(begin.toString(BusinessConstant.DATE_FORMAT_DAY))
                         .endTime(optimizeDate.toString(BusinessConstant.DATE_FORMAT_DAY))
                         .dateType(dateType)
                         .build());
-                //取峰谷策略
-                strategyList = strategyMap.get(lineMap.get(detail.getLineId()));
-                //按是否需要优化分组
-                collect = wellheadMap.get(detail.getId()).stream()
-                        .sorted(Comparator.comparing(SpaceInstitutionWellheadView::getStartSeq))
-                        .collect(
-                                Collectors.partitioningBy(w ->
-                                        CharSequenceUtil.equals(BusinessConstant.INTERVAL_PUMPING_WELL, w.getRunTypeKey()) &&
-                                                CharSequenceUtil.equals("0", w.getIntervalTypeKey())
-                                )
-                        );
-                //保存不需要优化的井口
-                List<SpaceInstitutionWellheadView> unOptimizeWellhead = collect.get(Boolean.FALSE);
                 this.setUnOptimizeWellheadConfig(durationDTOList, unOptimizeDurationList, wellheadDTOList,
                         unOptimizeWellhead, durationMap.get(detail.getId()), periodId, recordTime);
-                //取待优化井口并遍历
-                wellheadList = collect.get(Boolean.TRUE);
                 //防冻堵策略(一口井就全开不走优化)
                 SpaceInstitutionWellheadView tundraStrategyWellhead = null;
                 List<SpaceOptimizeDurationDTO> tundraStrategyList = new ArrayList<>(32);
@@ -302,11 +315,12 @@ public class SpaceOptimizeBaseService {
                 SpaceInstitutionWellheadView wellhead;
                 //记录第一次开井时间
                 DateTime firstOpenWellTime = null;
-/*             [第一次开井时间优化]
-            int offset = detail.getStartInterval();*/
                 startInterval = detail.getStartInterval();
                 if (CollUtil.isNotEmpty(wellheadList)) {
                     for (int i = 0; i < wellheadList.size(); i++) {
+                        if (isOffGrid) {
+                            offGridDTOList = new ArrayList<>(32);
+                        }
                         wellhead = wellheadList.get(i);
                         String wellheadId = wellhead.getWellheadId();
                         String recordId = this.createOptimizeWellhead(wellheadDTOList, periodId, wellheadId, wellhead.getWellNumber(), wellhead.getStartSeq(), recordTime, BusinessConstant.ONE);
@@ -317,7 +331,7 @@ public class SpaceOptimizeBaseService {
                         //累加运行功率
                         serviceRating = serviceRating.add(wellhead.getServiceRating());
                         //计算权重
-                        List<SpaceOptimizeWeight> weightList = this.calculateWeightList(serviceRating, rangeToList, powerList, strategyList);
+                        List<SpaceOptimizeWeight> weightList = this.calculateWeightList(serviceRating, rangeToList, powerList, strategyList, isOffGrid);
                         //每日最小开井时长(分钟)
                         int minOpenMinute = wellhead.getMinOpen()
                                 .multiply(BusinessConstant.BIG_DECIMAL_60)
@@ -329,8 +343,14 @@ public class SpaceOptimizeBaseService {
                         firstOpenWellTime = this.timePeriodOptimization(optimizeDurationDTOList, weightDurationList, firstOpenWellTime, i,
                                 startInterval, minOpenMinute, wellhead, weightList);
                         //创建优化后的间开区间
+                        if (isOffGrid) {
+                            this.addOptimizeDuration(optimizeDurationDTOList, offGridDTOList, tundraStrategyList, periodId, recordId, wellheadId, recordTime);
+                            //标注发电类型
+                            this.addOffGridOptimizeDuration(durationDTOList, offGridDTOList, weightList);
+                        } else {
                             this.addOptimizeDuration(optimizeDurationDTOList, durationDTOList, tundraStrategyList, periodId, recordId, wellheadId, recordTime);
                         }
+                    }
                     //防冻井
                     if (ObjectUtil.isNotNull(tundraStrategyWellhead) && CollUtil.isNotEmpty(tundraStrategyList)) {
                         List<SpaceOptimizeDurationDTO> closeList = new ArrayList<>(32);
@@ -435,7 +455,7 @@ public class SpaceOptimizeBaseService {
                                 .multiply(BusinessConstant.BIG_DECIMAL_60)
                                 .intValue();
                         serviceRating = serviceRating.add(tundraStrategyWellhead.getServiceRating());
-                        List<SpaceOptimizeWeight> weightList = this.calculateWeightList(serviceRating, rangeToList, powerList, strategyList);
+                        List<SpaceOptimizeWeight> weightList = this.calculateWeightList(serviceRating, rangeToList, powerList, strategyList, isOffGrid);
                         List<SpaceOptimizeWeightDuration> weightDurationList = this.weightListProcessing(ladder, weightList, minOpenMinute);
                         //创建优化记录
                         String wellheadId = tundraStrategyWellhead.getWellheadId();
@@ -1259,7 +1279,7 @@ public class SpaceOptimizeBaseService {
      */
     public void createOptimizeDuration(List<SpaceOptimizeDurationDTO> durationDTOList, String periodId,
                                        String recordId, String wellheadId, String generationTypeKey,
-                                       String openWellTime, String endTimeString, Integer firstStart, DateTime optimizeDate) {
+                                       String openWellTime, String endTimeString, Integer firstStart, Date optimizeDate) {
         this.createDuration(durationDTOList, recordId, periodId, wellheadId, BusinessConstant.ZERO,
                 openWellTime, endTimeString, generationTypeKey, firstStart, optimizeDate);
     }
@@ -1280,7 +1300,7 @@ public class SpaceOptimizeBaseService {
      */
     public void createDuration(List<SpaceOptimizeDurationDTO> durationDTOList, String recordId,
                                String periodId, String wellheadId, Integer isOptimize, String openWellTime,
-                               String closeWellTime, String generationTypeKey, Integer firstStart, DateTime optimizeDate) {
+                               String closeWellTime, String generationTypeKey, Integer firstStart, Date optimizeDate) {
         SpaceOptimizeDurationDTO durationDTO = new SpaceOptimizeDurationDTO();
         BaseUtils.setBaseModelDefaultForJob(durationDTO);
         durationDTO.setRecordId(recordId);
@@ -2180,13 +2200,13 @@ public class SpaceOptimizeBaseService {
      * @param rangeToList   要列出范围
      * @param powerList     电源列表
      * @param strategyList  策略列表
+     * @param isOffGrid     是否离网型
      * @return {@link List}<{@link SpaceOptimizeWeight}>
      */
-    private List<SpaceOptimizeWeight> calculateWeightList(BigDecimal serviceRating, List<DateTime> rangeToList, List<DynamicQueryPlantPredictedPowerOutput> powerList, List<GetBasePriceStrategyDetailOutput> strategyList) {
+    private List<SpaceOptimizeWeight> calculateWeightList(BigDecimal serviceRating, List<DateTime> rangeToList, List<DynamicQueryPlantPredictedPowerOutput> powerList, List<GetBasePriceStrategyDetailOutput> strategyList, boolean isOffGrid) {
         int rangeListSize = rangeToList.size();
         int powerListSize = powerList.size();
-        boolean empty = CollUtil.isEmpty(strategyList);
-        int strategyListSize = empty ? 0 : strategyList.size();
+        int strategyListSize = isOffGrid ? 0 : strategyList.size();
         int rangeIndex = 0;
         int powerIndex = 0;
         int strategyIndex = 0;
@@ -2208,12 +2228,14 @@ public class SpaceOptimizeBaseService {
                 powerFlag = firstPower.getPower().compareTo(serviceRating) >= 0;
                 if (powerFlag) {
                     firstWeight.setWeight(10);
+                    firstWeight.setGenerationTypeKey(BusinessConstant.PHOTOVOLTAIC);
                 }
                 powerIndex++;
             }
-            if (empty) {
+            if (isOffGrid) {
                 if (!powerFlag) {
                     firstWeight.setWeight(1);
+                    firstWeight.setGenerationTypeKey(BusinessConstant.STORED_ENERGY);
                 }
             } else {
                 firstStrategy = strategyList.get(strategyIndex);
@@ -2251,12 +2273,14 @@ public class SpaceOptimizeBaseService {
                 powerFlag = lastPower.getPower().compareTo(serviceRating) >= 0;
                 if (powerFlag) {
                     lastWeight.setWeight(10);
+                    lastWeight.setGenerationTypeKey(BusinessConstant.PHOTOVOLTAIC);
                 }
                 powerListSize--;
             }
-            if (empty) {
+            if (isOffGrid) {
                 if (!powerFlag) {
                     lastWeight.setWeight(1);
+                    lastWeight.setGenerationTypeKey(BusinessConstant.STORED_ENERGY);
                 }
             } else {
                 lastStrategy = strategyList.get(strategyListSize - 1);
@@ -2363,10 +2387,6 @@ public class SpaceOptimizeBaseService {
                 .intValue();
         //总开井时间
         long sumOpenTime = 0;
-/*                //中断标识     [第一次开井时间优化]
-                boolean breakFlag = false;
-                //重新计算标识
-                boolean againFlag = false;*/
         for (int i1 = 0; i1 < weightDurationList.size(); i1++) {
             SpaceOptimizeWeightDuration weightDuration = weightDurationList.get(i1);
             long duration = weightDuration.getDuration();
@@ -2547,48 +2567,9 @@ public class SpaceOptimizeBaseService {
                     }
                 }
                 break;
-/*                        //结束循环 [第一次开井时间优化]
-                        breakFlag = true;*/
             }
             //重新按开井时间排序
             optimizeDurationDTOList.sort(Comparator.comparing(SpaceOptimizeDurationDTO::getOpenTime));
-/*                    //判断第一次开井时间    [第一次开井时间优化]
-                    if (breakFlag || i1 == (weightDurationList.size() - 1)) {
-                        Date checkOpenTime = optimizeDurationDTOList.get(0).getOpenTime();
-                        int check = firstOpenWellTime.compareTo(checkOpenTime);
-                        if (check > 0) {
-                            //如果第一次开井时间大于当前开井时间,修改第一次开井时间
-                            firstOpenWellTime = DateUtil.date(checkOpenTime);
-                            if (breakFlag) {
-                                break;
-                            }
-                        } else if (check == 0) {
-                            if (againFlag) {
-                                break;
-                            }
-                            againFlag = true;
-                            if (0 == i) {
-                                //第一口井跳过
-                                continue;
-                            }
-                            //如果第一次开井时间等于当前开井时间,重置优化结果,偏移启动间隔,重新计算
-                            SpaceOptimizeWeightDuration spaceOptimizeWeightDuration = weightDurationList.get(0);
-                            spaceOptimizeWeightDuration.setOpenTime(
-                                    DateUtil.offsetMinute(spaceOptimizeWeightDuration.getOpenTime(), offset)
-                            );
-                            spaceOptimizeWeightDuration.setDuration(
-                                    spaceOptimizeWeightDuration.getDuration() - offset
-                            );
-                            offset += detail.getStartInterval();
-                            //信息重置
-                            i1 = -1;
-                            sumOpenTime = 0;
-                            optimizeDurationDTOList = new ArrayList<>(12);
-                            breakFlag = false;
-                        } else {
-                            break;
-                        }
-                    }*/
             //记录上一次第一次开井时间
             if (0 == i1) {
                 firstOpenWellTime = DateUtil.date(optimizeDurationDTOList.get(0).getOpenTime());
@@ -2806,4 +2787,55 @@ public class SpaceOptimizeBaseService {
             }
         }
     }
+
+    /**
+     * 添加离网优化时间
+     *
+     * @param durationDTOList 持续时间dtolist
+     * @param offGridDTOList  脱离网格dtolist
+     * @param weightList      重量清单
+     */
+    private void addOffGridOptimizeDuration(List<SpaceOptimizeDurationDTO> durationDTOList, List<SpaceOptimizeDurationDTO> offGridDTOList, List<SpaceOptimizeWeight> weightList) {
+        if (CollUtil.isNotEmpty(offGridDTOList)) {
+            SpaceOptimizeDurationDTO durationDTO;
+            int index = 0;
+            DateTime beginTime = null;
+            String beginTypeKey = null;
+            SpaceOptimizeWeight weight;
+            for (int i1 = 0; i1 < offGridDTOList.size(); i1++) {
+                durationDTO = offGridDTOList.get(i1);
+                DateTime startTime = DateUtil.parse(durationDTO.getOpenWellTime() + BusinessConstant.INITIALIZATION_SECOND, BusinessConstant.TIME_FORMAT);
+                DateTime endTime = DateUtil.parse(durationDTO.getCloseWellTime() + BusinessConstant.INITIALIZATION_SECOND, BusinessConstant.TIME_FORMAT);
+                for (int i2 = index; i2 < weightList.size(); i2++) {
+                    weight = weightList.get(i2);
+                    if (DateUtil.isIn(weight.getTimestamp(), startTime, endTime)) {
+                        if (CharSequenceUtil.isBlank(beginTypeKey)) {
+                            beginTypeKey = weight.getGenerationTypeKey();
+                            beginTime = startTime;
+                        }
+                        if (!CharSequenceUtil.equals(beginTypeKey, weight.getGenerationTypeKey())) {
+                            this.createOptimizeDuration(durationDTOList, durationDTO.getPeriodId(), durationDTO.getRecordId(), durationDTO.getWellheadId(), beginTypeKey,
+                                    beginTime.toString(BusinessConstant.MINUTES_FORMAT),
+                                    weight.getTimestamp().toString(BusinessConstant.MINUTES_FORMAT),
+                                    BusinessConstant.ONE, durationDTO.getOptimizeDate()
+                            );
+                            beginTime = weight.getTimestamp();
+                            beginTypeKey = weight.getGenerationTypeKey();
+                        }
+                    }
+                    //时间戳大于结束时间,跳出循环设置下次索引位置
+                    if (DateUtil.compare(weight.getTimestamp(), endTime) > 0) {
+                        this.createOptimizeDuration(durationDTOList, durationDTO.getPeriodId(), durationDTO.getRecordId(), durationDTO.getWellheadId(), beginTypeKey,
+                                beginTime.toString(BusinessConstant.MINUTES_FORMAT),
+                                endTime.toString(BusinessConstant.MINUTES_FORMAT),
+                                BusinessConstant.ONE, durationDTO.getOptimizeDate()
+                        );
+                        index = i2;
+                        beginTypeKey = null;
+                        break;
+                    }
+                }
+            }
+        }
+    }
 }
\ No newline at end of file

C11-space/pps-core-space/src/main/java/pps/core/space/service/data/SpaceOptimizeWeight.java

@@ -49,4 +49,9 @@ public class SpaceOptimizeWeight {
      * 电量是否满足标识
      */
     private Boolean batteryLowFlag;
+
+    /**
+     * 发电类型key
+     */
+    private String generationTypeKey;
 }

C11-space/pps-core-space/src/main/java/pps/core/space/service/data/SpaceOptimizeWeightDuration.java

@@ -39,4 +39,9 @@ public class SpaceOptimizeWeightDuration {
 
     @XText("需要优化的索引")
     private int optimizeIndex;
+
+    /**
+     * 发电类型key
+     */
+    private String generationTypeKey;
 }