Merge branch 'master' of https://gitlab.sunboxauto.com/tianchao/gf_back

 Conflicts:
	D03-deploy/deploy-pps-all/src/main/java/app/DeployPpsAllApplication.java
	D03-deploy/deploy-pps-all/src/main/resources/deploy-pps-all.app.properties
	D03-deploy/deploy-pps-task/src/main/java/app/DeployPpsTaskApplication.java
	D03-deploy/deploy-pps-task/src/main/resources/deploy-pps-task.app.properties

C00-common/pps-common/src/main/java/pps/core/common/constant/BusinessConstant.java

@@ -11,6 +11,23 @@ import cn.hutool.core.date.DateUtil;
  */
 public class BusinessConstant {
 
+    /**
+     * 初始父级组织机构ID
+     */
+    public static final String PARENT_OU_ID = "00000000-0000-0000-0000-000000000000";
+
+    /**
+     * 光伏电站
+     */
+    public static final String PHOTOVOLTAIC_POWER_STATION = "photovoltaic_power_station";
+
+    /**
+     * 井口
+     */
+    public static final String WELLHEAD = "wellhead";
+
+    /*------------------------------数字------------------------------*/
+
     /**
      * 1
      */
@@ -26,10 +43,17 @@ public class BusinessConstant {
      */
     public static final Integer TEN = 10;
 
+    /*------------------------------日期------------------------------*/
+
     /**
-     * 初始父级组织机构ID
+     * 日期格式化到天
      */
-    public static final String PARENT_OU_ID = "00000000-0000-0000-0000-000000000000";
+    public static final String DATE_FORMAT_DAY = "yyyy-MM-dd";
+
+    /**
+     * 日期格式化到天(年月日)
+     */
+    public static final String DATE_FORMAT_DAY_C = "yyyy年MM月dd日";
 
     /**
      * 时间格式

C00-common/pps-common/src/main/java/pps/core/common/utils/BaseUtils.java

@@ -104,9 +104,39 @@ public class BaseUtils {
      */
     public static String getExecutionCycleForMonth(Date date) {
         StringBuilder stringBuilder = new StringBuilder();
-        stringBuilder.append(DateUtil.format(DateUtil.beginOfMonth(date), "yyyy-MM-dd"))
+        stringBuilder.append(DateUtil.format(DateUtil.beginOfDay(date), BusinessConstant.DATE_FORMAT_DAY_C))
                 .append('-')
-                .append(DateUtil.format(DateUtil.endOfMonth(date), "yyyy-MM-dd"));
+                .append(DateUtil.format(DateUtil.endOfMonth(date), BusinessConstant.DATE_FORMAT_DAY_C));
+        return stringBuilder.toString();
+    }
+
+    /**
+     * 获取周执行周期
+     *
+     * @param date 日期
+     * @return {@link String}
+     */
+    public static String getExecutionCycleForWeek(DateTime date) {
+        StringBuilder stringBuilder = new StringBuilder();
+        stringBuilder.append(date.year())
+                .append("年第")
+                .append(date.weekOfYear())
+                .append('周');
+        return stringBuilder.toString();
+    }
+
+    /**
+     * 获取校准执行周期
+     *
+     * @param date   日期
+     * @param offset 抵消
+     * @return {@link String}
+     */
+    public static String getExecutionCycleForCalibration(Date date, int offset) {
+        StringBuilder stringBuilder = new StringBuilder();
+        stringBuilder.append(DateUtil.format(DateUtil.beginOfDay(date), BusinessConstant.DATE_FORMAT_DAY_C))
+                .append('-')
+                .append(DateUtil.format(DateUtil.offsetDay(date, offset), BusinessConstant.DATE_FORMAT_DAY_C));
         return stringBuilder.toString();
     }
 

C10-task/pps-core-task/src/main/java/pps/core/task/constant/CronConstant.java

@@ -9,12 +9,22 @@ package pps.core.task.constant;
 public class CronConstant {
 
     /**
-     * 每月第一天 0点
+     * 每月第一天 00:30:00
      */
-    public static final String FIRST_DAY_OF_THE_MONTH = "0 0 0 1 * ?";
+    public static final String FIRST_DAY_OF_THE_MONTH = "0 30 0 1 * ?";
 
     /**
-     * 每周一 0点
+     * 每周一 00:00:00
      */
     public static final String EVERY_MONDAY = "0 0 0 ? * 2";
+
+    /**
+     * 每一天 00:15:00
+     */
+    public static final String EVERY_DAY = "0 15 0 * * ?";
+
+    /**
+     * 每一天结束时间 23:30:00
+     */
+    public static final String END_OF_DAY = "0 30 23 * * ?";
 }

C10-task/pps-core-task/src/main/java/pps/core/task/job/SpaceCalibrationJob.java

+package pps.core.task.job;
+
+import pps.cloud.space.service.ISpaceCalibrationCloudService;
+import pps.core.task.constant.CronConstant;
+import xstartup.annotation.XService;
+import xstartup.annotation.XText;
+import xstartup.base.XContext;
+import xstartup.base.tool.XLoggerTool;
+import xstartup.data.XServiceResult;
+import xstartup.service.job.XJob;
+import xstartup.service.job.annotation.XCronTrigger;
+
+/**
+ * 定期校准定时任务
+ *
+ * @author ZWT
+ * @date 2023/09/20 09:20
+ */
+@XText("长期间开优化定时任务")
+@XService
+public class SpaceCalibrationJob implements XJob {
+
+    /**
+     * 处决
+     *
+     * @param xContext x上下文
+     * @return {@link XServiceResult}
+     */
+    @XCronTrigger(value = CronConstant.EVERY_DAY)
+    @Override
+    public XServiceResult execute(XContext xContext) {
+        XLoggerTool logger = xContext.getLogger();
+        logger.info("------ SpaceCalibrationJob start:{}", System.currentTimeMillis());
+        ISpaceCalibrationCloudService service = xContext.getBean(ISpaceCalibrationCloudService.class);
+        XServiceResult result = service.calibrateJob(xContext);
+        result.throwIfFail();
+        logger.info("------ SpaceCalibrationJob end:{}", System.currentTimeMillis());
+        return XServiceResult.OK;
+    }
+}

C10-task/pps-core-task/src/main/java/pps/core/task/job/SpaceOptimizeLongJob.java

@@ -5,6 +5,7 @@ import pps.core.task.constant.CronConstant;
 import xstartup.annotation.XService;
 import xstartup.annotation.XText;
 import xstartup.base.XContext;
+import xstartup.base.tool.XLoggerTool;
 import xstartup.data.XServiceResult;
 import xstartup.service.job.XJob;
 import xstartup.service.job.annotation.XCronTrigger;
@@ -28,9 +29,12 @@ public class SpaceOptimizeLongJob implements XJob {
     @XCronTrigger(value = CronConstant.FIRST_DAY_OF_THE_MONTH)
     @Override
     public XServiceResult execute(XContext xContext) {
+        XLoggerTool logger = xContext.getLogger();
+        logger.info("------ SpaceOptimizeLongJob start:{}", System.currentTimeMillis());
         ISpaceOptimizeLongCloudService service = xContext.getBean(ISpaceOptimizeLongCloudService.class);
         XServiceResult result = service.optimizeLongJob(xContext);
         result.throwIfFail();
+        logger.info("------ SpaceOptimizeLongJob end:{}", System.currentTimeMillis());
         return XServiceResult.OK;
     }
 }
\ No newline at end of file

C10-task/pps-core-task/src/main/java/pps/core/task/job/SpaceOptimizeMidJob.java

 package pps.core.task.job;
 
+import pps.cloud.space.service.ISpaceOptimizeMidCloudService;
 import pps.core.task.constant.CronConstant;
 import xstartup.annotation.XService;
 import xstartup.annotation.XText;
 import xstartup.base.XContext;
+import xstartup.base.tool.XLoggerTool;
 import xstartup.data.XServiceResult;
 import xstartup.service.job.XJob;
 import xstartup.service.job.annotation.XCronTrigger;
@@ -27,6 +29,12 @@ public class SpaceOptimizeMidJob implements XJob {
     @XCronTrigger(value = CronConstant.EVERY_MONDAY)
     @Override
     public XServiceResult execute(XContext xContext) {
+        XLoggerTool logger = xContext.getLogger();
+        logger.info("------ SpaceOptimizeMidJob start:{}", System.currentTimeMillis());
+        ISpaceOptimizeMidCloudService service = xContext.getBean(ISpaceOptimizeMidCloudService.class);
+        XServiceResult result = service.optimizeMidJob(xContext);
+        result.throwIfFail();
+        logger.info("------ SpaceOptimizeMidJob end:{}", System.currentTimeMillis());
         return XServiceResult.OK;
     }
 }

C10-task/pps-core-task/src/main/java/pps/core/task/job/SpaceOptimizeShortJob.java

+package pps.core.task.job;
+
+import pps.cloud.space.service.ISpaceOptimizeShortCloudService;
+import pps.core.task.constant.CronConstant;
+import xstartup.annotation.XService;
+import xstartup.annotation.XText;
+import xstartup.base.XContext;
+import xstartup.base.tool.XLoggerTool;
+import xstartup.data.XServiceResult;
+import xstartup.service.job.XJob;
+import xstartup.service.job.annotation.XCronTrigger;
+
+/**
+ * 短期间开优化定时任务
+ *
+ * @author ZWT
+ * @date 2023/09/20 11:39
+ */
+@XText("短期间开优化定时任务")
+@XService
+public class SpaceOptimizeShortJob implements XJob {
+
+    /**
+     * 每一天 23:30:00 执行
+     *
+     * @param xContext x上下文
+     * @return {@link XServiceResult}
+     */
+    @XCronTrigger(value = CronConstant.END_OF_DAY)
+    @Override
+    public XServiceResult execute(XContext xContext) {
+        XLoggerTool logger = xContext.getLogger();
+        logger.info("------ SpaceOptimizeShortJob start:{}", System.currentTimeMillis());
+        ISpaceOptimizeShortCloudService service = xContext.getBean(ISpaceOptimizeShortCloudService.class);
+        XServiceResult result = service.optimizeShortJob(xContext);
+        result.throwIfFail();
+        logger.info("------ SpaceOptimizeShortJob end:{}", System.currentTimeMillis());
+        return XServiceResult.OK;
+    }
+}

C11-space/pps-cloud-space/src/main/java/pps/cloud/space/service/ISpaceCalibrationCloudService.java

+package pps.cloud.space.service;
+
+import xstartup.annotation.XService;
+import xstartup.annotation.XText;
+import xstartup.base.XContext;
+import xstartup.data.XServiceResult;
+
+/**
+ * 定期校准Cloud模块
+ *
+ * @author ZWT
+ * @date 2023/09/20 09:36
+ */
+@XService
+@XText("定期校准Cloud模块")
+public interface ISpaceCalibrationCloudService {
+
+    /**
+     * 定期校准Cloud模块--定时任务
+     *
+     * @param context 上下文
+     * @return {@link XServiceResult}
+     */
+    @XText("定期校准Cloud模块--定时任务")
+    XServiceResult calibrateJob(XContext context);
+}

C11-space/pps-cloud-space/src/main/java/pps/cloud/space/service/ISpaceOptimizeMidCloudService.java

+package pps.cloud.space.service;
+
+import xstartup.annotation.XService;
+import xstartup.annotation.XText;
+import xstartup.base.XContext;
+import xstartup.data.XServiceResult;
+
+/**
+ * 中短期间开优化Cloud模块
+ *
+ * @author ZWT
+ * @date 2023/09/13 14:03
+ */
+@XService
+@XText("中短期间开优化Cloud模块")
+public interface ISpaceOptimizeMidCloudService {
+
+    /**
+     * 中短期间开优化Cloud模块--定时任务
+     *
+     * @param context 上下文
+     * @return {@link XServiceResult}
+     */
+    @XText("中短期间开优化Cloud模块--定时任务")
+    XServiceResult optimizeMidJob(XContext context);
+}
\ No newline at end of file

C11-space/pps-cloud-space/src/main/java/pps/cloud/space/service/ISpaceOptimizeShortCloudService.java

+package pps.cloud.space.service;
+
+import xstartup.annotation.XService;
+import xstartup.annotation.XText;
+import xstartup.base.XContext;
+import xstartup.data.XServiceResult;
+
+/**
+ * 短期间开优化Cloud模块
+ *
+ * @author ZWT
+ * @date 2023/09/20 11:43
+ */
+@XService
+@XText("短期间开优化Cloud模块")
+public interface ISpaceOptimizeShortCloudService {
+
+    /**
+     * 短期间开优化Cloud模块--定时任务
+     *
+     * @param context 上下文
+     * @return {@link XServiceResult}
+     */
+    @XText("中短期间开优化Cloud模块--定时任务")
+    XServiceResult optimizeShortJob(XContext context);
+}

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

+package pps.core.space.entity;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import lombok.Data;
+import pps.core.common.entity.BaseModel;
+import xstartup.annotation.XText;
+
+import java.io.Serializable;
+
+/**
+ * 间开优化井口制度记录
+ *
+ * @author ZWT
+ * @date 2023/09/05
+ */
+@Data
+public class SpaceOptimizeDurationDTO extends BaseModel implements Serializable {
+
+    @XText("井口记录ID")
+    @TableField
+    private String recordId;
+
+    @XText("间开优化周期ID")
+    @TableField
+    private String periodId;
+
+    @XText("井口ID")
+    @TableField
+    private String wellheadId;
+
+    @XText("是否优化(0_是;1_否)")
+    @TableField
+    private Integer isOptimize;
+
+    @XText("发电类型key(字典获取)")
+    @TableField
+    private String generationTypeKey;
+
+    @XText("开井时间")
+    @TableField
+    private String openWellTime;
+
+    @XText("关井时间")
+    @TableField
+    private String closeWellTime;
+}

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

+package pps.core.space.entity;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import lombok.Data;
+import pps.core.common.entity.BaseModel;
+import xstartup.annotation.XText;
+
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * 间开优化周期记录
+ *
+ * @author ZWT
+ * @date 2023/09/05
+ */
+@Data
+public class SpaceOptimizePeriodDTO extends BaseModel implements Serializable {
+
+    @XText("线路ID")
+    @TableField
+    private String lineId;
+
+    @XText("间开制度ID")
+    @TableField
+    private String institutionId;
+
+    @XText("执行周期")
+    @TableField
+    private String executionCycle;
+
+    @XText("优化状态(0_已优化;1_未优化)")
+    @TableField
+    private Integer optimizeState;
+
+    @XText("优化截止日期")
+    @TableField
+    private Date optimizeDeadline;
+}

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

+package pps.core.space.entity;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import lombok.Data;
+import pps.core.common.entity.BaseModel;
+import xstartup.annotation.XText;
+
+import java.io.Serializable;
+
+/**
+ * 间开优化井口记录
+ *
+ * @author ZWT
+ * @date 2023/09/05
+ */
+@Data
+public class SpaceOptimizeWellheadDTO extends BaseModel implements Serializable {
+
+    @XText("间开优化周期ID")
+    @TableField
+    private String periodId;
+
+    @XText("井口ID")
+    @TableField
+    private String wellheadId;
+
+    @XText("井号")
+    @TableField
+    private String wellNumber;
+}

C11-space/pps-core-space/src/main/java/pps/core/space/enums/BusinessError.java

@@ -11,9 +11,11 @@ import xstartup.error.XError;
 public enum BusinessError implements XError {
     LineExists(2100, "当前线路已设定周期"),
     RepeatSetting(2101, "请勿重复设定"),
-    DidNotFindSpace(2102, "未发现可优化基础间开制度"),
+    DidNotFindSpace(2102, "未发现可用基础间开制度"),
     DidNotFindWellhead(2103, "未发现可优化井口"),
     DidNotFindPlant(2104, "未发现可用光伏电站"),
+    DidNotFindCalibration(2105, "未发现可用周期配置"),
+    UnableToOptimize(2106, "无法优化"),
     ;
 
     private int code;

C11-space/pps-core-space/src/main/java/pps/core/space/mapper/SpaceCalibrationHistoryViewMapper.java

 package pps.core.space.mapper;
 
+import org.apache.ibatis.annotations.Param;
 import org.springframework.stereotype.Repository;
 import pps.core.space.entity.SpaceCalibrationHistoryView;
 
@@ -29,4 +30,12 @@ public interface SpaceCalibrationHistoryViewMapper {
      * @return {@link List}<{@link SpaceCalibrationHistoryView}>
      */
     List<SpaceCalibrationHistoryView> selectList(SpaceCalibrationHistoryView record);
+
+    /**
+     * 批量新增
+     *
+     * @param list 列表
+     * @return int
+     */
+    int batchInsertList(@Param(value = "list") List<SpaceCalibrationHistoryView> list);
 }

C11-space/pps-core-space/src/main/java/pps/core/space/mapper/SpaceOptimizeViewMapper.java

+package pps.core.space.mapper;
+
+import org.apache.ibatis.annotations.Param;
+import org.springframework.stereotype.Repository;
+import pps.core.space.entity.*;
+
+import java.util.List;
+
+/**
+ * 间开优化
+ *
+ * @author ZWT
+ * @date 2023/09/19 09:40
+ */
+@Repository(value = "pps.core.space.mapper.SpaceOptimizeViewMapper")
+public interface SpaceOptimizeViewMapper {
+
+    /**
+     * 长期间开优化批量新增
+     *
+     * @param list 列表
+     * @return int
+     */
+    int longPeriodBatchInsertList(@Param(value = "list") List<SpaceOptimizePeriodDTO> list);
+
+    /**
+     * 长期间开优化井口批量新增
+     *
+     * @param list 列表
+     * @return int
+     */
+    int longWellheadBatchInsertList(@Param(value = "list") List<SpaceOptimizeWellheadDTO> list);
+
+    /**
+     * 长期间开优化井口配置批量新增
+     *
+     * @param list 列表
+     * @return int
+     */
+    int longDurationBatchInsertList(@Param(value = "list") List<SpaceOptimizeDurationDTO> list);
+
+    /**
+     * 长期间开优化批量新增
+     *
+     * @param list 列表
+     * @return int
+     */
+    int midPeriodBatchInsertList(@Param(value = "list") List<SpaceOptimizePeriodDTO> list);
+
+    /**
+     * 长期间开优化井口批量新增
+     *
+     * @param list 列表
+     * @return int
+     */
+    int midWellheadBatchInsertList(@Param(value = "list") List<SpaceOptimizeWellheadDTO> list);
+
+    /**
+     * 长期间开优化井口配置批量新增
+     *
+     * @param list 列表
+     * @return int
+     */
+    int midDurationBatchInsertList(@Param(value = "list") List<SpaceOptimizeDurationDTO> list);
+}

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

+package pps.core.space.service;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.date.DateTime;
+import cn.hutool.core.date.DateUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import pps.cloud.space.service.ISpaceCalibrationCloudService;
+import pps.core.common.constant.BusinessConstant;
+import pps.core.common.entity.BaseModel;
+import pps.core.common.utils.BaseUtils;
+import pps.core.space.entity.SpaceCalibrationHistoryEnt;
+import pps.core.space.entity.SpaceCalibrationHistoryView;
+import pps.core.space.entity.SpaceCalibrationPeriodEnt;
+import pps.core.space.entity.SpaceInstitutionDetailEnt;
+import pps.core.space.enums.BusinessError;
+import pps.core.space.mapper.SpaceCalibrationHistoryMapper;
+import pps.core.space.mapper.SpaceCalibrationHistoryViewMapper;
+import pps.core.space.mapper.SpaceCalibrationPeriodMapper;
+import pps.core.space.mapper.SpaceInstitutionDetailMapper;
+import xstartup.annotation.XService;
+import xstartup.base.XContext;
+import xstartup.data.XServiceResult;
+import xstartup.helper.XTransactionHelper;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 定期校准Cloud模块
+ *
+ * @author ZWT
+ * @date 2023/09/20 09:40
+ */
+@XService
+public class SpaceCalibrationCloudServiceImpl implements ISpaceCalibrationCloudService {
+
+    /**
+     * 定期校准Cloud模块--定时任务
+     *
+     * @param context 上下文
+     * @return {@link XServiceResult}
+     */
+    @Override
+    public XServiceResult calibrateJob(XContext context) {
+        //查出所有周期配置
+        SpaceCalibrationPeriodMapper mapper = context.getBean(SpaceCalibrationPeriodMapper.class);
+        List<SpaceCalibrationPeriodEnt> calibrationList = mapper.selectList(new LambdaQueryWrapper<SpaceCalibrationPeriodEnt>()
+                .eq(BaseModel::getIsDeleted, BusinessConstant.ONE)
+        );
+        if (CollUtil.isEmpty(calibrationList)) {
+            return XServiceResult.error(context, BusinessError.DidNotFindCalibration);
+        }
+        //取当前时间
+        DateTime date = DateUtil.date();
+        String sameDay = date.toString(BusinessConstant.DATE_FORMAT_DAY);
+        //查生效中的基础间开
+        SpaceInstitutionDetailMapper detailMapper = context.getBean(SpaceInstitutionDetailMapper.class);
+        List<SpaceInstitutionDetailEnt> detailEntList = detailMapper.selectList(new LambdaQueryWrapper<SpaceInstitutionDetailEnt>()
+                .eq(BaseModel::getIsDeleted, BusinessConstant.ONE)
+                .eq(SpaceInstitutionDetailEnt::getIsCurrentBasic, BusinessConstant.ZERO)
+                .in(SpaceInstitutionDetailEnt::getLineId,
+                        calibrationList.stream()
+                                .map(SpaceCalibrationPeriodEnt::getLineId)
+                                .collect(Collectors.toList()))
+                .le(SpaceInstitutionDetailEnt::getInstitutionStartDate, sameDay)
+                .ge(SpaceInstitutionDetailEnt::getInstitutionEndDate, sameDay)
+        );
+        if (CollUtil.isEmpty(detailEntList)) {
+            return XServiceResult.error(context, BusinessError.DidNotFindSpace);
+        }
+        //生效中的间开按照线路ID分组
+        Map<String, List<SpaceInstitutionDetailEnt>> institutionDetailMap = detailEntList.stream()
+                .collect(Collectors.groupingBy(SpaceInstitutionDetailEnt::getLineId));
+        //周期数据处理
+        List<SpaceCalibrationHistoryView> historyViewList = new ArrayList<>(128);
+        String lineId;
+        Integer dayNumber;
+        List<SpaceInstitutionDetailEnt> institutionDetailList;
+        SpaceCalibrationHistoryMapper historyMapper = context.getBean(SpaceCalibrationHistoryMapper.class);
+        for (SpaceCalibrationPeriodEnt calibration : calibrationList) {
+            lineId = calibration.getLineId();
+            if (!institutionDetailMap.containsKey(lineId)) {
+                continue;
+            }
+            institutionDetailList = institutionDetailMap.get(lineId);
+            if (CollUtil.isEmpty(institutionDetailList)) {
+                continue;
+            }
+            dayNumber = Integer.valueOf(calibration.getDayNumber());
+            for (SpaceInstitutionDetailEnt detailEnt : institutionDetailList) {
+                String institutionId = detailEnt.getId();
+                //查当前制度最新的的历史周期
+                SpaceCalibrationHistoryEnt lastHistory = historyMapper.selectOne(new LambdaQueryWrapper<SpaceCalibrationHistoryEnt>()
+                        .eq(BaseModel::getIsDeleted, BusinessConstant.ONE)
+                        .eq(SpaceCalibrationHistoryEnt::getInstitutionId, institutionId)
+                        .orderByDesc(SpaceCalibrationHistoryEnt::getCalibrationDate)
+                        .last("limit 1")
+                );
+                if (Objects.isNull(lastHistory)) {
+                    //创建周期
+                    this.createCalibrationHistory(historyViewList, lineId, institutionId, date, dayNumber);
+                } else {
+                    //判断当前时间是否大于等于周期校准时间
+                    Date calibrationDate = lastHistory.getCalibrationDate();
+                    if (DateUtil.compare(date, calibrationDate) >= 0) {
+                        this.createCalibrationHistory(historyViewList, lineId, institutionId, calibrationDate, dayNumber);
+                    }
+                }
+            }
+        }
+        //开启事务
+        return XTransactionHelper.begin(context, () -> {
+            SpaceCalibrationHistoryViewMapper historyViewMapper = context.getBean(SpaceCalibrationHistoryViewMapper.class);
+            if (CollUtil.isNotEmpty(historyViewList)) {
+                int size = historyViewList.size();
+                if (size > BaseUtils.BATCH_SIZE) {
+                    List<List<SpaceCalibrationHistoryView>> subList = BaseUtils.getSubList(historyViewList);
+                    subList.forEach(b -> historyViewMapper.batchInsertList(b));
+                } else {
+                    historyViewMapper.batchInsertList(historyViewList);
+                }
+            }
+            return XServiceResult.OK;
+        });
+    }
+
+    /*-----------------------------------private-----------------------------------*/
+
+    /**
+     * 创建校准历史记录
+     *
+     * @param historyViewList 历史视图列表
+     * @param lineId          线路id
+     * @param institutionId   机构id
+     * @param date            日期
+     * @param dayNumber       天数
+     */
+    private void createCalibrationHistory(List<SpaceCalibrationHistoryView> historyViewList, String lineId,
+                                          String institutionId, Date date, Integer dayNumber) {
+        SpaceCalibrationHistoryView historyView = new SpaceCalibrationHistoryView();
+        BaseUtils.setBaseModelDefaultForJob(historyView);
+        historyView.setLineId(lineId);
+        historyView.setInstitutionId(institutionId);
+        historyView.setExecutionCycle(BaseUtils.getExecutionCycleForCalibration(date, dayNumber));
+        historyView.setCalibrationDate(DateUtil.beginOfDay(DateUtil.offsetDay(date, dayNumber + 1)));
+        historyViewList.add(historyView);
+    }
+}

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

 package pps.core.space.service;
 
 import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.date.DateTime;
+import cn.hutool.core.date.DateUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
@@ -10,10 +12,12 @@ import pps.core.common.session.PpsUserSession;
 import pps.core.common.utils.BaseUtils;
 import pps.core.space.entity.SpaceCalibrationHistoryView;
 import pps.core.space.entity.SpaceCalibrationPeriodEnt;
+import pps.core.space.entity.SpaceInstitutionDetailEnt;
 import pps.core.space.entity.SpaceInstitutionWellheadEnt;
 import pps.core.space.enums.BusinessError;
 import pps.core.space.mapper.SpaceCalibrationHistoryViewMapper;
 import pps.core.space.mapper.SpaceCalibrationPeriodMapper;
+import pps.core.space.mapper.SpaceInstitutionDetailMapper;
 import pps.core.space.mapper.SpaceInstitutionWellheadMapper;
 import pps.core.space.service.data.space_calibration_history.QuerySpaceCalibrationHistoryInput;
 import pps.core.space.service.data.space_calibration_history.QuerySpaceCalibrationHistoryOutput;
@@ -38,10 +42,7 @@ import xstartup.feature.api.annotation.XApiGet;
 import xstartup.feature.api.annotation.XApiPost;
 import xstartup.helper.XTransactionHelper;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -66,15 +67,39 @@ public class SpaceCalibrationService {
     @XText("校准周期--新增")
     public XServiceResult createSpaceCalibrationPeriod(XContext context, CreateSpaceCalibrationPeriodInput input) {
         PpsUserSession session = context.getSession(PpsUserSession.class);
-        return XTransactionHelper.begin(context, () -> {
-            SpaceCalibrationPeriodMapper mapper = context.getBean(SpaceCalibrationPeriodMapper.class);
-            SpaceCalibrationPeriodEnt periodEnt = this.getPeriodEntByParam(mapper, input.getLineId(), input.getOuId());
-            if (Objects.nonNull(periodEnt)) {
-                return XServiceResult.error(context, BusinessError.LineExists);
+        SpaceCalibrationPeriodMapper mapper = context.getBean(SpaceCalibrationPeriodMapper.class);
+        SpaceCalibrationPeriodEnt periodEnt = this.getPeriodEntByParam(mapper, input.getLineId(), input.getOuId());
+        if (Objects.nonNull(periodEnt)) {
+            return XServiceResult.error(context, BusinessError.LineExists);
+        }
+        SpaceCalibrationPeriodEnt entity = XCopyUtils.copyNewObject(input, SpaceCalibrationPeriodEnt.class);
+        //查生效中的基础间开
+        String lineId = entity.getLineId();
+        //取当前时间
+        DateTime date = DateUtil.date();
+        String sameDay = date.toString(BusinessConstant.DATE_FORMAT_DAY);
+        SpaceInstitutionDetailMapper detailMapper = context.getBean(SpaceInstitutionDetailMapper.class);
+        List<SpaceInstitutionDetailEnt> detailEntList = detailMapper.selectList(new LambdaQueryWrapper<SpaceInstitutionDetailEnt>()
+                .eq(BaseModel::getIsDeleted, BusinessConstant.ONE)
+                .eq(SpaceInstitutionDetailEnt::getIsCurrentBasic, BusinessConstant.ZERO)
+                .eq(SpaceInstitutionDetailEnt::getLineId, lineId)
+                .le(SpaceInstitutionDetailEnt::getInstitutionStartDate, sameDay)
+                .ge(SpaceInstitutionDetailEnt::getInstitutionEndDate, sameDay)
+        );
+        List<SpaceCalibrationHistoryView> historyViewList = new ArrayList<>(8);
+        if (CollUtil.isNotEmpty(detailEntList)) {
+            for (SpaceInstitutionDetailEnt detailEnt : detailEntList) {
+                //创建周期
+                this.createCalibrationHistory(historyViewList, lineId, detailEnt.getId(), date, Integer.valueOf(entity.getDayNumber()));
             }
-            SpaceCalibrationPeriodEnt entity = XCopyUtils.copyNewObject(input, SpaceCalibrationPeriodEnt.class);
+        }
+        return XTransactionHelper.begin(context, () -> {
             BaseUtils.setBaseModelDefault(entity, session);
             mapper.insert(entity);
+            SpaceCalibrationHistoryViewMapper historyViewMapper = context.getBean(SpaceCalibrationHistoryViewMapper.class);
+            if (CollUtil.isNotEmpty(historyViewList)) {
+                historyViewMapper.batchInsertList(historyViewList);
+            }
             return XServiceResult.OK;
         });
     }
@@ -217,4 +242,25 @@ public class SpaceCalibrationService {
                         .eq(SpaceCalibrationPeriodEnt::getOuId, ouId)
         );
     }
+
+    /**
+     * 创建校准历史记录
+     *
+     * @param historyViewList 历史视图列表
+     * @param lineId          线路id
+     * @param institutionId   机构id
+     * @param date            日期
+     * @param dayNumber       天数
+     */
+    private void createCalibrationHistory(List<SpaceCalibrationHistoryView> historyViewList, String lineId,
+                                          String institutionId, Date date, Integer dayNumber) {
+        SpaceCalibrationHistoryView historyView = new SpaceCalibrationHistoryView();
+        BaseUtils.setBaseModelDefaultForJob(historyView);
+        historyView.setLineId(lineId);
+        historyView.setInstitutionId(institutionId);
+        historyView.setExecutionCycle(BaseUtils.getExecutionCycleForCalibration(date, dayNumber));
+        historyView.setCalibrationDate(DateUtil.beginOfDay(DateUtil.offsetDay(date, dayNumber + 1)));
+        historyViewList.add(historyView);
+    }
+
 }

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

+package pps.core.space.service;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.date.DateTime;
+import cn.hutool.core.date.DateUtil;
+import pps.cloud.prediction.service.data.plant_predicted_power_data.DynamicQueryPlantPredictedPowerInput;
+import pps.cloud.prediction.service.data.plant_predicted_power_data.DynamicQueryPlantPredictedPowerOutput;
+import pps.cloud.space.service.ISpaceOptimizeMidCloudService;
+import pps.core.common.constant.BusinessConstant;
+import pps.core.common.utils.BaseUtils;
+import pps.core.space.entity.*;
+import pps.core.space.mapper.SpaceInstitutionDurationMapper;
+import pps.core.space.mapper.SpaceOptimizeViewMapper;
+import pps.core.space.service.data.SpaceOptimizeWellheadAndPlant;
+import xstartup.annotation.XService;
+import xstartup.base.XContext;
+import xstartup.data.XServiceResult;
+import xstartup.helper.XTransactionHelper;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 中短期间开优化Cloud模块
+ *
+ * @author ZWT
+ * @date 2023/09/18 14:14
+ */
+@XService
+public class SpaceOptimizeMidCloudServiceImpl extends SpaceOptimizeBaseService implements ISpaceOptimizeMidCloudService {
+
+    /**
+     * 中短期间开优化Cloud模块--定时任务
+     *
+     * @param context 上下文
+     * @return {@link XServiceResult}
+     */
+    @Override
+    public XServiceResult optimizeMidJob(XContext context) {
+        //取当前时间
+        DateTime date = DateUtil.date();
+        String startWeek = date.toString(BusinessConstant.DATE_FORMAT_DAY);
+        //取生效中的基础间开
+        List<SpaceInstitutionDetailEnt> detailEntList = super.getEffectiveSpaceInstitution(context, startWeek);
+        SpaceOptimizeWellheadAndPlant wellheadAndPlant = super.getWellheadAndPlant(context, detailEntList);
+        List<SpaceInstitutionWellheadView> spaceWellheadList = wellheadAndPlant.getSpaceWellheadList();
+        Map<String, List<String>> plantIdsByLineIdMap = wellheadAndPlant.getPlantIdsByLineIdMap();
+        //月份要加一
+        int monthNum = date.month() + 1;
+        SpaceInstitutionDurationMapper durationMapper = context.getBean(SpaceInstitutionDurationMapper.class);
+        List<SpaceOptimizePeriodDTO> periodDTOList = new ArrayList<>(32);
+        List<SpaceOptimizeWellheadDTO> wellheadDTOList = new ArrayList<>(64);
+        List<SpaceOptimizeDurationDTO> durationDTOList = new ArrayList<>(128);
+        List<SpaceOptimizeDurationDTO> unOptimizeDurationList = new ArrayList<>(128);
+        String executionCycleForWeek = BaseUtils.getExecutionCycleForWeek(date);
+        //优化截止日期
+        DateTime optimizeDeadline = DateUtil.endOfWeek(date);
+        //日期查询范围结束条件,下周一
+        String nextWeek = DateUtil.beginOfWeek(DateUtil.nextWeek()).toString(BusinessConstant.DATE_FORMAT_DAY);
+        //优化
+        for (SpaceInstitutionDetailEnt detail : detailEntList) {
+            String detailId = detail.getId();
+            String lineId = detail.getLineId();
+            //创建记录
+            String periodId = super.createOptimizePeriod(periodDTOList, detailId, lineId, executionCycleForWeek, optimizeDeadline);
+            switch (detail.getGridTypeKey()) {
+                //并网型优化
+                case "1":
+                    //获取当前制度对应的光伏预测数据列表
+                    List<DynamicQueryPlantPredictedPowerOutput> avgPowerList = super.getAveragePowerGenerationListByPlantIds(context,
+                            DynamicQueryPlantPredictedPowerInput.builder()
+                                    .plantIds(plantIdsByLineIdMap.get(lineId))
+                                    .startTime(startWeek)
+                                    .endTime(nextWeek)
+                                    .build()
+                    );
+                    super.gridConnectedOptimization(context, durationMapper, wellheadDTOList, durationDTOList, unOptimizeDurationList,
+                            spaceWellheadList, avgPowerList, detail, monthNum, detailId, periodId, lineId);
+                    break;
+                //离网型优化
+                case "0":
+                    break;
+                default:
+                    //电网类型不存在
+            }
+        }
+        //开启事务
+        return XTransactionHelper.begin(context, () -> {
+            int size;
+            SpaceOptimizeViewMapper optimizeViewMapper = context.getBean(SpaceOptimizeViewMapper.class);
+            if (CollUtil.isNotEmpty(periodDTOList)) {
+                size = periodDTOList.size();
+                if (size > BaseUtils.BATCH_SIZE) {
+                    List<List<SpaceOptimizePeriodDTO>> subList = BaseUtils.getSubList(periodDTOList);
+                    subList.forEach(b -> optimizeViewMapper.midPeriodBatchInsertList(b));
+                } else {
+                    optimizeViewMapper.midPeriodBatchInsertList(periodDTOList);
+                }
+            }
+            if (CollUtil.isNotEmpty(wellheadDTOList)) {
+                size = wellheadDTOList.size();
+                if (size > BaseUtils.BATCH_SIZE) {
+                    List<List<SpaceOptimizeWellheadDTO>> subList = BaseUtils.getSubList(wellheadDTOList);
+                    subList.forEach(b -> optimizeViewMapper.midWellheadBatchInsertList(b));
+                } else {
+                    optimizeViewMapper.midWellheadBatchInsertList(wellheadDTOList);
+                }
+            }
+            if (CollUtil.isNotEmpty(unOptimizeDurationList)) {
+                size = unOptimizeDurationList.size();
+                if (size > BaseUtils.BATCH_SIZE) {
+                    List<List<SpaceOptimizeDurationDTO>> subList = BaseUtils.getSubList(unOptimizeDurationList);
+                    subList.forEach(b -> optimizeViewMapper.midDurationBatchInsertList(b));
+                } else {
+                    optimizeViewMapper.midDurationBatchInsertList(unOptimizeDurationList);
+                }
+            }
+            if (CollUtil.isNotEmpty(durationDTOList)) {
+                size = durationDTOList.size();
+                if (size > BaseUtils.BATCH_SIZE) {
+                    List<List<SpaceOptimizeDurationDTO>> subList = BaseUtils.getSubList(durationDTOList);
+                    subList.forEach(b -> optimizeViewMapper.midDurationBatchInsertList(b));
+                } else {
+                    optimizeViewMapper.midDurationBatchInsertList(durationDTOList);
+                }
+            }
+            return XServiceResult.OK;
+        });
+    }
+
+    /*-----------------------------------private-----------------------------------*/
+}
\ No newline at end of file

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

+package pps.core.space.service;
+
+import pps.cloud.space.service.ISpaceOptimizeShortCloudService;
+import xstartup.annotation.XService;
+import xstartup.base.XContext;
+import xstartup.data.XServiceResult;
+
+/**
+ * 短期间开优化Cloud模块
+ *
+ * @author ZWT
+ * @date 2023/09/20 11:44
+ */
+@XService
+public class SpaceOptimizeShortCloudServiceImpl implements ISpaceOptimizeShortCloudService {
+
+    /**
+     * 短期间开优化Cloud模块--定时任务
+     *
+     * @param context 上下文
+     * @return {@link XServiceResult}
+     */
+    @Override
+    public XServiceResult optimizeShortJob(XContext context) {
+        return XServiceResult.OK;
+    }
+}

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

+package pps.core.space.service.data;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import pps.core.space.entity.SpaceInstitutionWellheadView;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 间开优化数据集
+ *
+ * @author ZWT
+ * @date 2023/09/18 16:42
+ */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Builder
+public class SpaceOptimizeWellheadAndPlant {
+
+    /**
+     * 井口列表
+     */
+    List<SpaceInstitutionWellheadView> spaceWellheadList;
+
+    /**
+     * 电站Map
+     */
+    Map<String, List<String>> plantIdsByLineIdMap;
+}

C11-space/pps-core-space/src/main/java/pps/core/space/utils/ServiceUtil.java

@@ -175,7 +175,7 @@ public class ServiceUtil {
             allList.add(
                     SpaceOptimizeDateDuration.builder()
                             .openWellTime("00:00")
-                            .closeWellTime("24:00")
+                            .closeWellTime("23:59")
                             .isOpen(0)
                             .build()
             );
@@ -219,11 +219,11 @@ public class ServiceUtil {
             }
             if (i == last) {
                 //如果结束时间不是24:00开始,初始化最终关井时间
-                if (!StringUtils.equals("24:00", closeWellTime)) {
+                if (!StringUtils.equals("23:59", closeWellTime)) {
                     allList.add(
                             SpaceOptimizeDateDuration.builder()
                                     .openWellTime(closeWellTime)
-                                    .closeWellTime("24:00")
+                                    .closeWellTime("23:59")
                                     .isOpen(0)
                                     .build()
                     );

C11-space/pps-core-space/src/main/resources/mybatis/mapper/pps/core/space/SpaceCalibrationHistoryViewMapper.xml

@@ -63,4 +63,25 @@
           AND h.line_id = #{lineId}
         ORDER BY h.calibration_date DESC
     </select>
+
+    <insert id="batchInsertList" parameterType="list">
+        INSERT INTO space_calibration_history ( id, create_by_id, create_by_name, create_time, modify_by_id,
+        modify_by_name, modify_time, line_id, institution_id, execution_cycle, calibration_date )
+        VALUES
+        <foreach collection="list" item="item" separator=",">
+            (
+            #{item.id},
+            #{item.createById},
+            #{item.createByName},
+            #{item.createTime},
+            #{item.modifyById},
+            #{item.modifyByName},
+            #{item.modifyTime},
+            #{item.lineId},
+            #{item.institutionId},
+            #{item.executionCycle},
+            #{item.calibrationDate}
+            )
+        </foreach>
+    </insert>
 </mapper>
\ No newline at end of file

C11-space/pps-core-space/src/main/resources/mybatis/mapper/pps/core/space/SpaceOptimizeViewMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="pps.core.space.mapper.SpaceOptimizeViewMapper">
+
+    <insert id="longPeriodBatchInsertList" parameterType="list">
+        INSERT INTO space_optimize_long_period ( id, create_by_id, create_by_name, create_time,
+        modify_by_id, modify_by_name, modify_time, line_id, institution_id, execution_cycle, optimize_state,
+        optimize_deadline )
+        VALUES
+        <foreach collection="list" item="item" separator=",">
+            (
+            #{item.id},
+            #{item.createById},
+            #{item.createByName},
+            #{item.createTime},
+            #{item.modifyById},
+            #{item.modifyByName},
+            #{item.modifyTime},
+            #{item.lineId},
+            #{item.institutionId},
+            #{item.executionCycle},
+            #{item.optimizeState},
+            #{item.optimizeDeadline}
+            )
+        </foreach>
+    </insert>
+
+    <insert id="longWellheadBatchInsertList" parameterType="list">
+        INSERT INTO space_optimize_long_wellhead ( id, create_by_id, create_by_name, create_time,
+        modify_by_id, modify_by_name, modify_time, long_period_id, wellhead_id, well_number )
+        VALUES
+        <foreach collection="list" item="item" separator=",">
+            (
+            #{item.id},
+            #{item.createById},
+            #{item.createByName},
+            #{item.createTime},
+            #{item.modifyById},
+            #{item.modifyByName},
+            #{item.modifyTime},
+            #{item.periodId},
+            #{item.wellheadId},
+            #{item.wellNumber}
+            )
+        </foreach>
+    </insert>
+
+    <insert id="longDurationBatchInsertList" parameterType="list">
+        INSERT INTO space_optimize_long_duration (
+        id,
+        create_by_id,
+        create_by_name,
+        create_time,
+        modify_by_id,
+        modify_by_name,
+        modify_time,
+        record_id,
+        long_period_id,
+        wellhead_id,
+        is_optimize,
+        generation_type_key,
+        open_well_time,
+        close_well_time
+        )
+        VALUES
+        <foreach collection="list" item="item" separator=",">
+            (
+            #{item.id},
+            #{item.createById},
+            #{item.createByName},
+            #{item.createTime},
+            #{item.modifyById},
+            #{item.modifyByName},
+            #{item.modifyTime},
+            #{item.recordId},
+            #{item.periodId},
+            #{item.wellheadId},
+            #{item.isOptimize},
+            <choose>
+                <when test="item.generationTypeKey != null and item.generationTypeKey != ''">
+                    #{item.generationTypeKey},
+                </when>
+                <otherwise>
+                    NULL,
+                </otherwise>
+            </choose>
+            #{item.openWellTime},
+            #{item.closeWellTime}
+            )
+        </foreach>
+    </insert>
+
+    <insert id="midPeriodBatchInsertList" parameterType="list">
+        INSERT INTO space_optimize_mid_period ( id, create_by_id, create_by_name, create_time,
+        modify_by_id, modify_by_name, modify_time, line_id, institution_id, execution_cycle, optimize_state,
+        optimize_deadline )
+        VALUES
+        <foreach collection="list" item="item" separator=",">
+            (
+            #{item.id},
+            #{item.createById},
+            #{item.createByName},
+            #{item.createTime},
+            #{item.modifyById},
+            #{item.modifyByName},
+            #{item.modifyTime},
+            #{item.lineId},
+            #{item.institutionId},
+            #{item.executionCycle},
+            #{item.optimizeState},
+            #{item.optimizeDeadline}
+            )
+        </foreach>
+    </insert>
+
+    <insert id="midWellheadBatchInsertList" parameterType="list">
+        INSERT INTO space_optimize_mid_wellhead ( id, create_by_id, create_by_name, create_time,
+        modify_by_id, modify_by_name, modify_time, mid_period_id, wellhead_id, well_number )
+        VALUES
+        <foreach collection="list" item="item" separator=",">
+            (
+            #{item.id},
+            #{item.createById},
+            #{item.createByName},
+            #{item.createTime},
+            #{item.modifyById},
+            #{item.modifyByName},
+            #{item.modifyTime},
+            #{item.periodId},
+            #{item.wellheadId},
+            #{item.wellNumber}
+            )
+        </foreach>
+    </insert>
+
+    <insert id="midDurationBatchInsertList" parameterType="list">
+        INSERT INTO space_optimize_mid_duration (
+        id,
+        create_by_id,
+        create_by_name,
+        create_time,
+        modify_by_id,
+        modify_by_name,
+        modify_time,
+        record_id,
+        mid_period_id,
+        wellhead_id,
+        is_optimize,
+        generation_type_key,
+        open_well_time,
+        close_well_time
+        )
+        VALUES
+        <foreach collection="list" item="item" separator=",">
+            (
+            #{item.id},
+            #{item.createById},
+            #{item.createByName},
+            #{item.createTime},
+            #{item.modifyById},
+            #{item.modifyByName},
+            #{item.modifyTime},
+            #{item.recordId},
+            #{item.periodId},
+            #{item.wellheadId},
+            #{item.isOptimize},
+            <choose>
+                <when test="item.generationTypeKey != null and item.generationTypeKey != ''">
+                    #{item.generationTypeKey},
+                </when>
+                <otherwise>
+                    NULL,
+                </otherwise>
+            </choose>
+            #{item.openWellTime},
+            #{item.closeWellTime}
+            )
+        </foreach>
+    </insert>
+</mapper>
\ No newline at end of file

C12-prediction/pps-cloud-prediction/src/main/java/pps/cloud/prediction/service/IStoragePredictedPowerCloudService.java

+package pps.cloud.prediction.service;
+
+import pps.cloud.prediction.service.data.plant_predicted_power_data.DynamicQueryPlantPredictedPowerOutput;
+import pps.cloud.prediction.service.data.storage_predicted_power_data.DynamicQueryStoragePredictedPowerInput;
+import pps.cloud.prediction.service.data.storage_predicted_power_data.DynamicQueryStoragePredictedPowerOutput;
+import xstartup.annotation.XService;
+import xstartup.annotation.XText;
+import xstartup.base.XContext;
+import xstartup.data.XListResult;
+import xstartup.feature.api.annotation.XApiPost;
+
+/**
+ * 储能预测电量数据Cloud模块(模拟数据测试用)
+ *
+ * @author ZWT
+ * @date 2023/09/20 15:40
+ */
+@XService
+@XText("储能预测Cloud模块")
+public interface IStoragePredictedPowerCloudService {
+
+    /**
+     * 储能预测Cloud模块--条件查询时段储能电量平均值
+     *
+     * @param context 上下文
+     * @param input   输入
+     * @return {@link XListResult}<{@link DynamicQueryPlantPredictedPowerOutput}>
+     */
+    @XText("储能预测Cloud模块--条件查询时段储能电量平均值")
+    @XApiPost
+    XListResult<DynamicQueryStoragePredictedPowerOutput> queryAverageEnergyStorageListByParam(XContext context, DynamicQueryStoragePredictedPowerInput input);
+}

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

@@ -31,4 +31,10 @@ public class DynamicQueryPlantPredictedPowerInput {
 
     @XText("月")
     private String monthTime;
+
+    @XText("开始时间")
+    private String startTime;
+
+    @XText("结束时间")
+    private String endTime;
 }

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

@@ -14,18 +14,12 @@ import java.math.BigDecimal;
 @Data
 public class DynamicQueryPlantPredictedPowerOutput {
 
-    @XText("日期")
-    private String dataDate;
-
     @XText("年")
     private String yearTime;
 
     @XText("月")
     private String monthTime;
 
-    @XText("日")
-    private String dayTime;
-
     @XText("时")
     private String hourTime;
 
@@ -34,4 +28,7 @@ public class DynamicQueryPlantPredictedPowerOutput {
 
     @XText("预测功率")
     private BigDecimal power;
+
+    @XText("是否满足")
+    private boolean meetFlag;
 }

C12-prediction/pps-cloud-prediction/src/main/java/pps/cloud/prediction/service/data/storage_predicted_power_data/DynamicQueryStoragePredictedPowerInput.java

+package pps.cloud.prediction.service.data.storage_predicted_power_data;
+
+import lombok.Data;
+import xstartup.annotation.XText;
+
+import java.util.List;
+
+/**
+ * 储能预测电量数据(模拟数据测试用)
+ *
+ * @author ZWT
+ * @date 2023/09/20
+ */
+@Data
+public class DynamicQueryStoragePredictedPowerInput {
+
+    @XText("储能设备id")
+    private String storageId;
+
+
+    @XText("储能设备ID集合")
+    private List<String> storageIds;
+
+    @XText("年")
+    private String yearTime;
+
+    @XText("月")
+    private String monthTime;
+
+    @XText("开始时间")
+    private String startTime;
+
+    @XText("结束时间")
+    private String endTime;
+}

C12-prediction/pps-cloud-prediction/src/main/java/pps/cloud/prediction/service/data/storage_predicted_power_data/DynamicQueryStoragePredictedPowerOutput.java

+package pps.cloud.prediction.service.data.storage_predicted_power_data;
+
+import lombok.Data;
+import xstartup.annotation.XText;
+
+import java.math.BigDecimal;
+
+/**
+ * 储能预测电量数据(模拟数据测试用)
+ *
+ * @author ZWT
+ * @date 2023/09/20
+ */
+@Data
+public class DynamicQueryStoragePredictedPowerOutput {
+
+    @XText("年")
+    private String yearTime;
+
+    @XText("月")
+    private String monthTime;
+
+    @XText("时")
+    private String hourTime;
+
+    @XText("分")
+    private String minTime;
+
+    @XText("预测功率")
+    private BigDecimal power;
+}

C12-prediction/pps-core-prediction/src/main/java/pps/core/prediction/entity/StoragePredictedPowerDataEnt.java

+package pps.core.prediction.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import xstartup.annotation.XText;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+
+/**
+ * 储能预测电量数据(模拟数据测试用)
+ *
+ * @author ZWT
+ * @date 2023/09/20
+ */
+@Data
+@TableName("storage_predicted_power_data")
+public class StoragePredictedPowerDataEnt implements Serializable {
+    @TableId(type = IdType.AUTO)
+    private Integer id;
+
+    @XText("储能设备id")
+    @TableField
+    private String storageId;
+
+    @XText("日期")
+    @TableField
+    private String dataDate;
+
+    @XText("年")
+    @TableField
+    private String yearTime;
+
+    @XText("月")
+    @TableField
+    private String monthTime;
+
+    @XText("日")
+    @TableField
+    private String dayTime;
+
+    @XText("时")
+    @TableField
+    private String hourTime;
+
+    @XText("分")
+    @TableField
+    private String minTime;
+
+    @XText("预测功率")
+    @TableField
+    private BigDecimal power;
+
+    @XText("创建时间")
+    @TableField
+    private Date createTime;
+}

C12-prediction/pps-core-prediction/src/main/java/pps/core/prediction/entity/StoragePredictedPowerDataView.java

+package pps.core.prediction.entity;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import lombok.Data;
+import xstartup.annotation.XText;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+
+/**
+ * 储能预测电量数据(模拟数据测试用)
+ *
+ * @author ZWT
+ * @date 2023/09/20
+ */
+@Data
+public class StoragePredictedPowerDataView implements Serializable {
+    @TableField
+    private Integer id;
+
+    @XText("储能设备id")
+    @TableField
+    private String storageId;
+
+    @XText("日期")
+    @TableField
+    private String dataDate;
+
+    @XText("年")
+    @TableField
+    private String yearTime;
+
+    @XText("月")
+    @TableField
+    private String monthTime;
+
+    @XText("日")
+    @TableField
+    private String dayTime;
+
+    @XText("时")
+    @TableField
+    private String hourTime;
+
+    @XText("分")
+    @TableField
+    private String minTime;
+
+    @XText("预测功率")
+    @TableField
+    private BigDecimal power;
+
+    @XText("创建时间")
+    @TableField
+    private Date createTime;
+}

C12-prediction/pps-core-prediction/src/main/java/pps/core/prediction/mapper/StoragePredictedPowerDataMapper.java

+package pps.core.prediction.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.springframework.stereotype.Repository;
+import pps.core.prediction.entity.StoragePredictedPowerDataEnt;
+
+/**
+ * 储能预测电量数据(模拟数据测试用)
+ *
+ * @author ZWT
+ * @date 2023/09/20
+ */
+@Repository(value = "pps.core.prediction.mapper.StoragePredictedPowerDataMapper")
+public interface StoragePredictedPowerDataMapper extends BaseMapper<StoragePredictedPowerDataEnt> {
+}

C12-prediction/pps-core-prediction/src/main/java/pps/core/prediction/mapper/StoragePredictedPowerDataViewMapper.java

+package pps.core.prediction.mapper;
+
+import org.springframework.stereotype.Repository;
+import pps.core.prediction.entity.StoragePredictedPowerDataView;
+
+import java.util.List;
+
+/**
+ * 储能预测电量数据(模拟数据测试用)
+ *
+ * @author ZWT
+ * @date 2023/09/20
+ */
+@Repository(value = "pps.core.prediction.mapper.StoragePredictedPowerDataViewMapper")
+public interface StoragePredictedPowerDataViewMapper {
+    StoragePredictedPowerDataView selectOne(StoragePredictedPowerDataView record);
+
+    List<StoragePredictedPowerDataView> selectList(StoragePredictedPowerDataView record);
+}

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

@@ -38,6 +38,8 @@ public class PlantPredictedPowerCloudServiceImpl implements IPlantPredictedPower
         List<String> plantIds = input.getPlantIds();
         String yearTime = input.getYearTime();
         String monthTime = input.getMonthTime();
+        String startTime = input.getStartTime();
+        String endTime = input.getEndTime();
         PlantPredictedPowerDataMapper mapper = context.getBean(PlantPredictedPowerDataMapper.class);
         List<PlantPredictedPowerDataEnt> list = mapper.selectList(
                 new QueryWrapper<PlantPredictedPowerDataEnt>()
@@ -51,6 +53,7 @@ public class PlantPredictedPowerCloudServiceImpl implements IPlantPredictedPower
                         .in(CollUtil.isNotEmpty(plantIds), PlantPredictedPowerDataEnt::getPlantId, plantIds)
                         .eq(StringUtils.isNotBlank(yearTime), PlantPredictedPowerDataEnt::getYearTime, yearTime)
                         .eq(StringUtils.isNotBlank(monthTime), PlantPredictedPowerDataEnt::getMonthTime, monthTime)
+                        .between(!StringUtils.isAnyBlank(startTime, endTime), PlantPredictedPowerDataEnt::getDataDate, startTime, endTime)
                         .groupBy(PlantPredictedPowerDataEnt::getYearTime,
                                 PlantPredictedPowerDataEnt::getMonthTime,
                                 PlantPredictedPowerDataEnt::getHourTime,

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

+package pps.core.prediction.service;
+
+import cn.hutool.core.collection.CollUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import org.apache.commons.lang3.StringUtils;
+import pps.cloud.prediction.service.IStoragePredictedPowerCloudService;
+import pps.cloud.prediction.service.data.storage_predicted_power_data.DynamicQueryStoragePredictedPowerInput;
+import pps.cloud.prediction.service.data.storage_predicted_power_data.DynamicQueryStoragePredictedPowerOutput;
+import pps.core.prediction.entity.StoragePredictedPowerDataEnt;
+import pps.core.prediction.mapper.StoragePredictedPowerDataMapper;
+import xstartup.annotation.XService;
+import xstartup.base.XContext;
+import xstartup.base.util.XCopyUtils;
+import xstartup.data.XListResult;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 储能预测电量数据Cloud模块(模拟数据测试用)
+ *
+ * @author ZWT
+ * @date 2023/09/20 15:44
+ */
+@XService
+public class StoragePredictedPowerCloudServiceImpl implements IStoragePredictedPowerCloudService {
+
+    /**
+     * 储能预测Cloud模块--条件查询时段储能电量平均值
+     *
+     * @param context 上下文
+     * @param input   输入
+     * @return {@link XListResult}<{@link DynamicQueryStoragePredictedPowerOutput}>
+     */
+    @Override
+    public XListResult<DynamicQueryStoragePredictedPowerOutput> queryAverageEnergyStorageListByParam(XContext context, DynamicQueryStoragePredictedPowerInput input) {
+        String storageId = input.getStorageId();
+        List<String> storageIds = input.getStorageIds();
+        String yearTime = input.getYearTime();
+        String monthTime = input.getMonthTime();
+        String startTime = input.getStartTime();
+        String endTime = input.getEndTime();
+        StoragePredictedPowerDataMapper mapper = context.getBean(StoragePredictedPowerDataMapper.class);
+        List<StoragePredictedPowerDataEnt> list = mapper.selectList(
+                new QueryWrapper<StoragePredictedPowerDataEnt>()
+                        .select("year_time",
+                                "month_time",
+                                "hour_time",
+                                "min_time",
+                                "AVG( power ) AS power")
+                        .lambda()
+                        .eq(StringUtils.isNotBlank(storageId), StoragePredictedPowerDataEnt::getStorageId, storageId)
+                        .in(CollUtil.isNotEmpty(storageIds), StoragePredictedPowerDataEnt::getStorageId, storageIds)
+                        .eq(StringUtils.isNotBlank(yearTime), StoragePredictedPowerDataEnt::getYearTime, yearTime)
+                        .eq(StringUtils.isNotBlank(monthTime), StoragePredictedPowerDataEnt::getMonthTime, monthTime)
+                        .between(!StringUtils.isAnyBlank(startTime, endTime), StoragePredictedPowerDataEnt::getDataDate, startTime, endTime)
+                        .groupBy(StoragePredictedPowerDataEnt::getYearTime,
+                                StoragePredictedPowerDataEnt::getMonthTime,
+                                StoragePredictedPowerDataEnt::getHourTime,
+                                StoragePredictedPowerDataEnt::getMinTime)
+        );
+        List<DynamicQueryStoragePredictedPowerOutput> outputs;
+        if (CollUtil.isEmpty(list)) {
+            outputs = new ArrayList<>(0);
+        } else {
+            outputs = XCopyUtils.copyNewList(list, DynamicQueryStoragePredictedPowerOutput.class);
+        }
+        return XListResult.success(outputs);
+    }
+}

C12-prediction/pps-core-prediction/src/main/resources/mybatis/mapper/pps/core/prediction/StoragePredictedPowerDataViewMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="pps.core.prediction.mapper.StoragePredictedPowerDataViewMapper">
+    <resultMap id="BaseResultMap" type="pps.core.prediction.entity.StoragePredictedPowerDataView">
+        <id column="id" property="id" jdbcType="INTEGER"/>
+        <result column="storage_id" property="storageId" jdbcType="VARCHAR"/>
+        <result column="data_date" property="dataDate" jdbcType="VARCHAR"/>
+        <result column="year_time" property="yearTime" jdbcType="VARCHAR"/>
+        <result column="month_time" property="monthTime" jdbcType="VARCHAR"/>
+        <result column="day_time" property="dayTime" jdbcType="VARCHAR"/>
+        <result column="hour_time" property="hourTime" jdbcType="VARCHAR"/>
+        <result column="min_time" property="minTime" jdbcType="VARCHAR"/>
+        <result column="power" property="power" jdbcType="DECIMAL"/>
+        <result column="create_time" property="createTime" jdbcType="DATE"/>
+    </resultMap>
+    <sql id="Base_Column_List">
+        id
+        ,
+    storage_id,
+    data_date,
+    year_time,
+    month_time,
+    day_time,
+    hour_time,
+    min_time,
+    power,
+    create_time
+    </sql>
+    <select id="selectOne" parameterType="pps.core.prediction.entity.StoragePredictedPowerDataView"
+            resultMap="BaseResultMap">
+        select
+        <include refid="Base_Column_List"/>
+        from storage_predicted_power_data
+        where
+        id=#{id}
+    </select>
+    <select id="selectList" parameterType="pps.core.prediction.entity.StoragePredictedPowerDataView"
+            resultMap="BaseResultMap">
+        select
+        <include refid="Base_Column_List"/>
+        from storage_predicted_power_data
+        where
+        id=#{id}
+    </select>
+</mapper>
\ No newline at end of file

D03-deploy/deploy-pps-all/src/main/java/app/DeployPpsAllApplication.java

@@ -33,8 +33,8 @@ public class DeployPpsAllApplication {
         startup.enable(XJobFeature.class).config(new XJobServiceConf(WeatherJob.class));
         startup.enable(XJobFeature.class).config(new XJobServiceConf(SpaceOptimizeLongJob.class));
         startup.enable(XJobFeature.class).config(new XJobServiceConf(SpaceOptimizeMidJob.class));
-        startup.enable(XJobFeature.class).config(new XJobServiceConf(PlantPredictedPowerLongTermDataJob.class));
-
+        startup.enable(XJobFeature.class).config(new XJobServiceConf(SpaceCalibrationJob.class));
+        startup.enable(XJobFeature.class).config(new XJobServiceConf(SpaceOptimizeShortJob.class));
         //startup.enable(XCloudHuaweiCseFeature.class);
         startup.run(args);
     }

D03-deploy/deploy-pps-all/src/main/resources/deploy-pps-all.app.properties

@@ -56,8 +56,9 @@ x.server.host=127.0.0.1
 x.job.service=pps.core.task.job.TestJob,\
   pps.core.task.job.SpaceOptimizeLongJob,\
   pps.core.task.job.SpaceOptimizeMidJob,\
-  pps.core.task.job.WeatherJob,\
-  pps.core.task.job.PlantPredictedPowerLongTermDataJob
+  pps.core.task.job.SpaceCalibrationJob,\
+  pps.core.task.job.SpaceOptimizeShortJob,\
+  pps.core.task.job.WeatherJob
 
 # redis
 x.cache.type=@x.cache.type@

D03-deploy/deploy-pps-task/src/main/java/app/DeployPpsTaskApplication.java

 package app;
 
 //import pps.core.common.job.CounterJob;
+
 import pps.core.common.utils.CounterBuilder;
 import pps.core.task.job.*;
 import xstartup.base.XStartup;
@@ -26,22 +27,22 @@ public class DeployPpsTaskApplication {
         startup.config(new XServerConf(22062).naming("pps-task"))
                 .config(new XServiceConf("pps"));
         startup.enable(XApiFeature.class)
-                .config(new XApiCookieConf("%4bH8s9&",43200));
+                .config(new XApiCookieConf("%4bH8s9&", 43200));
         startup.enable(XCorsFeature.class);
         startup.enable(XMybatisFeature.class);
         startup.enable(XJobFeature.class).config(new XJobServiceConf(TestJob.class));
         startup.enable(XJobFeature.class).config(new XJobServiceConf(WeatherJob.class));
         startup.enable(XJobFeature.class).config(new XJobServiceConf(SpaceOptimizeLongJob.class));
         startup.enable(XJobFeature.class).config(new XJobServiceConf(SpaceOptimizeMidJob.class));
-        startup.enable(XJobFeature.class).config(new XJobServiceConf(PlantPredictedPowerLongTermDataJob.class));
+        startup.enable(XJobFeature.class).config(new XJobServiceConf(SpaceCalibrationJob.class));
+        startup.enable(XJobFeature.class).config(new XJobServiceConf(SpaceOptimizeShortJob.class));
 
         startup.enable(XRpcFeature.class);
         startup.enable(XCloudHuaweiCseFeature.class)
                 .config(XCloudBundlesConf.with(
 //                        XCloudBundle.naming("pps-workflow").addModule("pps", "cloud", "task"),
                         XCloudBundle.naming("pps-base-info").addModule("pps", "cloud", "system"),
-                        XCloudBundle.naming("pps-base-info").addModule("pps", "cloud", "system"),
-                        XCloudBundle.naming("pps-base-prediction").addModule("pps", "cloud", "prediction")));
+                        XCloudBundle.naming("pps-base-info").addModule("pps", "cloud", "base")));
 
         startup.run(args);
     }

D03-deploy/deploy-pps-task/src/main/resources/deploy-pps-task.app.properties

@@ -10,8 +10,9 @@ pps.core.common.mq-config.ackImsMq=@pps.core.common.mq-config.ackImsMq@
 x.job.service=pps.core.task.job.TestJob,\
   pps.core.task.job.SpaceOptimizeLongJob,\
   pps.core.task.job.SpaceOptimizeMidJob,\
-  pps.core.task.job.WeatherJob,\
-  pps.core.task.job.PlantPredictedPowerLongTermDataJob
+  pps.core.task.job.SpaceCalibrationJob,\
+  pps.core.task.job.SpaceOptimizeShortJob,\
+  pps.core.task.job.WeatherJob
 
 #\uFFFD\uFFFD\u05BE\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD
 x.log.level=@x.log.level@