feat(能源管理系统): 间开优化定时任务

1.开发间开优化定期校准定时任务,配置表达式修改定时任务配置文件,创建cloud模块方法;
2.开发间开优化定期校准定时任务,完成业务逻辑开发;
3.修改间开制度管理模块定期校准新增功能,增加初始化校准历史业务逻辑;
4.开发间开优化短期间开优化定时任务,配置表达式修改定时任务配置文件,创建cloud模块方法;
5.修改长期间开优化定时任务,添加离网型线路数据处理逻辑;
6.创建储能预测电量数据(模拟数据测试用)表,生成对应代码,添加条件查询各时段储能预测数据Cloud模块接口;
7.修改长期间开优化定时任务,增加离网型算法计算储能可用时长逻辑;
8.修改长期间开优化定时任务,优化部分sql查询语句查询逻辑,优化代码结构;

BREAKING CHANGE: 无

Closes 无

[skip ci]

C11-space/pps-core-space/src/main/java/pps/core/space/entity/SpaceInstitutionDurationEnt.java

@@ -7,6 +7,7 @@ import pps.core.common.entity.BaseModel;
 import xstartup.annotation.XText;
 
 import java.io.Serializable;
+import java.util.Date;
 
 /**
  * 间开制度小间开时段配置
@@ -41,4 +42,12 @@ public class SpaceInstitutionDurationEnt extends BaseModel implements Serializab
     @XText("关井时间")
     @TableField
     private String closeWellTime;
+
+    @XText("开井时间")
+    @TableField(exist = false)
+    private Date openTime;
+
+    @XText("关井时间")
+    @TableField(exist = false)
+    private Date closeTime;
 }

C11-space/pps-core-space/src/main/java/pps/core/space/entity/SpaceOptimizeDurationDTO.java

@@ -6,6 +6,7 @@ import pps.core.common.entity.BaseModel;
 import xstartup.annotation.XText;
 
 import java.io.Serializable;
+import java.util.Date;
 
 /**
  * 间开优化井口制度记录
@@ -43,4 +44,12 @@ public class SpaceOptimizeDurationDTO extends BaseModel implements Serializable
     @XText("关井时间")
     @TableField
     private String closeWellTime;
+
+    @XText("开井时间")
+    @TableField(exist = false)
+    private Date openTime;
+
+    @XText("关井时间")
+    @TableField(exist = false)
+    private Date closeTime;
 }

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

@@ -6,6 +6,7 @@ import cn.hutool.core.date.DateTime;
 import cn.hutool.core.date.DateUnit;
 import cn.hutool.core.date.DateUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import org.apache.commons.lang3.StringUtils;
 import pps.cloud.base.service.IBasePowerLineCloudService;
 import pps.cloud.base.service.IBaseWellheadCloudService;
@@ -195,7 +196,12 @@ public class SpaceOptimizeBaseService {
      */
     public Map<String, List<SpaceInstitutionDurationEnt>> getDurationMap(SpaceInstitutionDurationMapper durationMapper, String detailId) {
         //通过间开ID和井口ID查所有井口时段配置
-        List<SpaceInstitutionDurationEnt> durationList = durationMapper.selectList(new LambdaQueryWrapper<SpaceInstitutionDurationEnt>()
+        List<SpaceInstitutionDurationEnt> durationList = durationMapper.selectList(new QueryWrapper<SpaceInstitutionDurationEnt>()
+                .select("*",
+                        "STR_TO_DATE( CONCAT( open_well_time, ':00' ), '%H:%i:%s' ) AS openTime",
+                        "STR_TO_DATE( CONCAT( close_well_time, ':00' ), '%H:%i:%s' ) AS closeTime"
+                )
+                .lambda()
                 .eq(BaseModel::getIsDeleted, BusinessConstant.ONE)
                 .eq(SpaceInstitutionDurationEnt::getInstitutionId, detailId)
                 .orderByAsc(SpaceInstitutionDurationEnt::getOpenWellTime)
@@ -469,7 +475,7 @@ public class SpaceOptimizeBaseService {
                         int startDuration = (int) startTime.between(endTime, DateUnit.MINUTE);
                         DateTime endTimeOptimize = startTime.offset(DateField.MINUTE, startDuration);
                         this.createOptimizeDuration(durationDTOList, periodId, recordId, wellheadId, null,
-                                startTimeString, endTimeOptimize.toString(BusinessConstant.MINUTES_FORMAT)
+                                StringUtils.substringBeforeLast(startTimeString, BusinessConstant.INITIALIZATION_SECOND), endTimeOptimize.toString(BusinessConstant.MINUTES_FORMAT)
                         );
                         //计算时间偏移
                         DateTime startTimeOptimize = DateUtil.parse(startTimeString, BusinessConstant.TIME_FORMAT);
@@ -499,7 +505,7 @@ public class SpaceOptimizeBaseService {
                             int openDuration = (int) startTime.between(endTime, DateUnit.MINUTE);
                             DateTime endTimeOptimize = startTimeOptimize.offset(DateField.MINUTE, openDuration);
                             this.createOptimizeDuration(durationDTOList, periodId, recordId, wellheadId, null,
-                                    openWellTime, BaseUtils.getEndTimeString(endTimeOptimize)
+                                    startTimeOptimize.toString(BusinessConstant.MINUTES_FORMAT), BaseUtils.getEndTimeString(endTimeOptimize)
                             );
                             //取时间间隔(分钟)
                             between = BaseUtils.getTimeDifferenceMinute(endTimeOptimize, endTime);

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

@@ -25,10 +25,7 @@ import xstartup.helper.XTransactionHelper;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 /**
  * 长期间开优化Cloud模块
@@ -82,17 +79,17 @@ public class SpaceOptimizeLongCloudServiceImpl extends SpaceOptimizeBaseService
             String lineId = detail.getLineId();
             //创建记录
             String periodId = super.createOptimizePeriod(periodDTOList, detailId, lineId, executionCycleForMonth, optimizeDeadline);
-            //获取当前制度对应的光伏预测数据列表
-            avgPowerList = super.getAveragePowerGenerationListByPlantIds(context,
-                    DynamicQueryPlantPredictedPowerInput.builder()
-                            .plantIds(plantIdsByLineIdMap.get(lineId))
-                            .yearTime(String.valueOf(year))
-                            .monthTime(month)
-                            .build()
-            );
             switch (detail.getGridTypeKey()) {
                 //并网型优化
                 case "1":
+                    //获取当前制度对应的光伏预测数据列表
+                    avgPowerList = super.getAveragePowerGenerationListByPlantIds(context,
+                            DynamicQueryPlantPredictedPowerInput.builder()
+                                    .plantIds(plantIdsByLineIdMap.get(lineId))
+                                    .yearTime(String.valueOf(year))
+                                    .monthTime(month)
+                                    .build()
+                    );
                     super.gridConnectedOptimization(context, durationMapper, wellheadDTOList, durationDTOList, unOptimizeDurationList,
                             spaceWellheadList, avgPowerList, detail, monthNum, detailId, periodId, lineId);
                     break;
@@ -109,6 +106,14 @@ public class SpaceOptimizeLongCloudServiceImpl extends SpaceOptimizeBaseService
                         //没有设置时间段,无法优化
                         continue;
                     }
+                    //获取当前制度对应的光伏预测数据列表
+                    avgPowerList = super.getAveragePowerGenerationListByPlantIds(context,
+                            DynamicQueryPlantPredictedPowerInput.builder()
+                                    .plantIds(plantIdsByLineIdMap.get(lineId))
+                                    .yearTime(String.valueOf(year))
+                                    .monthTime(month)
+                                    .build()
+                    );
                     //时间差
                     int between = 0;
                     //启动间隔累积
@@ -149,9 +154,8 @@ public class SpaceOptimizeLongCloudServiceImpl extends SpaceOptimizeBaseService
                         }
                         for (int d = 0, durationSize = durationConfigList.size(); d < durationSize; d++) {
                             SpaceInstitutionDurationEnt duration = durationConfigList.get(d);
-                            String openWellTime = duration.getOpenWellTime();
-                            DateTime startTime = DateUtil.parse(openWellTime + BusinessConstant.INITIALIZATION_SECOND, BusinessConstant.TIME_FORMAT);
-                            DateTime endTime = DateUtil.parse(duration.getCloseWellTime() + BusinessConstant.INITIALIZATION_SECOND, BusinessConstant.TIME_FORMAT);
+                            DateTime startTime = DateUtil.date(duration.getOpenTime());
+                            DateTime endTime = DateUtil.date(duration.getCloseTime());
                             //第一次启动
                             if (d == 0) {
                                 //第一口井的启动时间
@@ -167,14 +171,12 @@ public class SpaceOptimizeLongCloudServiceImpl extends SpaceOptimizeBaseService
                                         }
                                     }
                                     DynamicQueryPlantPredictedPowerOutput start = avgPowerList.get(firstIndex);
-                                    String startTimeString = start.getHourTime() + start.getMinTime();
+                                    DateTime startTimeOptimize = DateUtil.date(start.getCreateTime());
                                     //计算第一次关井时间,按照间开时间段顺延
                                     int startDuration = (int) startTime.between(endTime, DateUnit.MINUTE);
                                     DateTime endTimeOptimize = startTime.offset(DateField.MINUTE, startDuration);
-                                    this.createDurationOffGridPeriod(offGridPeriodList, wellheadId, startTimeString, endTimeOptimize.toString(BusinessConstant.MINUTES_FORMAT));
-                                    //计算时间偏移
-                                    DateTime startTimeOptimize = DateUtil.parse(startTimeString, BusinessConstant.TIME_FORMAT);
-                                    //取时间间隔(分钟)
+                                    this.createDurationOffGridPeriod(offGridPeriodList, wellheadId, startTimeOptimize, endTimeOptimize);
+                                    //计算时间偏移,取时间间隔(分钟)
                                     between = BaseUtils.getTimeDifferenceMinute(startTimeOptimize, startTime);
                                 }
                                 //其它井口的第一次启动时间
@@ -183,8 +185,7 @@ public class SpaceOptimizeLongCloudServiceImpl extends SpaceOptimizeBaseService
                                     int startIndex = -1;
                                     for (int a = 0, avgPowerSize = avgPowerList.size(); a < avgPowerSize; a++) {
                                         DynamicQueryPlantPredictedPowerOutput predictedPower = avgPowerList.get(a);
-                                        if (DateUtil.parse(predictedPower.getHourTime() + predictedPower.getMinTime(), BusinessConstant.TIME_FORMAT)
-                                                .compareTo(startTimeOffset) >= 0) {
+                                        if (DateUtil.date(predictedPower.getCreateTime()).compareTo(startTimeOffset) >= 0) {
                                             //判断第一口井启动时间+启动间隔时日平均光伏出力-前两口井的运行功率是否为正数
                                             if (predictedPower.getPower().compareTo(totalOperatingPower) >= 0) {
                                                 //确定第二口井第一次开井时间为第一口井启动时间+启动间隔
@@ -195,11 +196,11 @@ public class SpaceOptimizeLongCloudServiceImpl extends SpaceOptimizeBaseService
                                     }
                                     if (startIndex > -1) {
                                         DynamicQueryPlantPredictedPowerOutput start = avgPowerList.get(startIndex);
-                                        DateTime startTimeOptimize = DateUtil.parse(start.getHourTime() + start.getMinTime(), BusinessConstant.TIME_FORMAT);
+                                        DateTime startTimeOptimize = DateUtil.date(start.getCreateTime());
                                         //计算未优化启动间隔
                                         int openDuration = (int) startTime.between(endTime, DateUnit.MINUTE);
                                         DateTime endTimeOptimize = startTimeOptimize.offset(DateField.MINUTE, openDuration);
-                                        this.createDurationOffGridPeriod(offGridPeriodList, wellheadId, openWellTime, BaseUtils.getEndTimeString(endTimeOptimize));
+                                        this.createDurationOffGridPeriod(offGridPeriodList, wellheadId, startTimeOptimize, endTimeOptimize);
                                         //取时间间隔(分钟)
                                         between = BaseUtils.getTimeDifferenceMinute(endTimeOptimize, endTime);
                                     } else {
@@ -213,10 +214,8 @@ public class SpaceOptimizeLongCloudServiceImpl extends SpaceOptimizeBaseService
                                     continue;
                                 }
                                 //计算偏移
-                                this.createDurationOffGridPeriod(offGridPeriodList, wellheadId,
-                                        offset.toString(BusinessConstant.MINUTES_FORMAT),
-                                        BaseUtils.getEndTimeString(DateUtil.parse(duration.getCloseWellTime() + BusinessConstant.INITIALIZATION_SECOND, BusinessConstant.TIME_FORMAT)
-                                                .offset(DateField.MINUTE, between))
+                                this.createDurationOffGridPeriod(offGridPeriodList, wellheadId, offset,
+                                        DateUtil.date(duration.getCloseTime()).offset(DateField.MINUTE, between)
                                 );
                             }
                         }
@@ -281,7 +280,7 @@ public class SpaceOptimizeLongCloudServiceImpl extends SpaceOptimizeBaseService
                         }
                         //拆分时间段
                         for (SpaceOptimizeDurationDTO durationDTO : offGridPeriodList) {
-
+                            durationDTO.getOpenWellTime();
                         }
                     }
                     break;
@@ -336,12 +335,20 @@ public class SpaceOptimizeLongCloudServiceImpl extends SpaceOptimizeBaseService
     /*-----------------------------------private-----------------------------------*/
 
 
+    /**
+     * 离网型间开记录
+     *
+     * @param offGridPeriodList 离网时段列表
+     * @param wellheadId        井口id
+     * @param openTime          断开时间
+     * @param closeTime         关闭时间
+     */
     public void createDurationOffGridPeriod(List<SpaceOptimizeDurationDTO> offGridPeriodList, String wellheadId,
-                                            String openWellTime, String endTimeString) {
+                                            Date openTime, Date closeTime) {
         SpaceOptimizeDurationDTO durationDTO = new SpaceOptimizeDurationDTO();
         durationDTO.setWellheadId(wellheadId);
-        durationDTO.setOpenWellTime(openWellTime);
-        durationDTO.setCloseWellTime(endTimeString);
+        durationDTO.setOpenTime(openTime);
+        durationDTO.setCloseTime(closeTime);
         offGridPeriodList.add(durationDTO);
     }
 }
\ No newline at end of file

C12-prediction/pps-cloud-prediction/src/main/java/pps/cloud/prediction/service/data/plant_predicted_power_data/DynamicQueryPlantPredictedPowerOutput.java

@@ -4,6 +4,7 @@ import lombok.Data;
 import xstartup.annotation.XText;
 
 import java.math.BigDecimal;
+import java.util.Date;
 
 /**
  * 光伏预测Cloud模块
@@ -34,4 +35,7 @@ public class DynamicQueryPlantPredictedPowerOutput {
 
     @XText("可供电时长")
     private int powerDuration;
+
+    @XText("创建时间")
+    private Date createTime;
 }

C12-prediction/pps-core-prediction/src/main/java/pps/core/prediction/service/PlantPredictedPowerCloudServiceImpl.java

@@ -47,7 +47,8 @@ public class PlantPredictedPowerCloudServiceImpl implements IPlantPredictedPower
                                 "month_time",
                                 "hour_time",
                                 "min_time",
-                                "AVG( power ) AS power")
+                                "AVG( power ) AS power",
+                                "STR_TO_DATE( CONCAT( hour_time, ':', min_time ), '%H:%i:%s' ) AS create_time")
                         .lambda()
                         .eq(StringUtils.isNotBlank(plantId), PlantPredictedPowerDataEnt::getPlantId, plantId)
                         .in(CollUtil.isNotEmpty(plantIds), PlantPredictedPowerDataEnt::getPlantId, plantIds)