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

1.开发间开优化定期校准定时任务,配置表达式修改定时任务配置文件,创建cloud模块方法;
2.开发间开优化定期校准定时任务,完成业务逻辑开发;

BREAKING CHANGE: 无

Closes 无

[skip ci]

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

@@ -11,9 +11,10 @@ import xstartup.error.XError;
 public enum BusinessError implements XError {
     LineExists(2100, "当前线路已设定周期"),
     RepeatSetting(2101, "请勿重复设定"),
-    DidNotFindSpace(2102, "未发现可优化基础间开制度"),
+    DidNotFindSpace(2102, "未发现可用基础间开制度"),
     DidNotFindWellhead(2103, "未发现可优化井口"),
     DidNotFindPlant(2104, "未发现可用光伏电站"),
+    DidNotFindCalibration(2105, "未发现可用周期配置"),
     ;
 
     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/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模块
@@ -14,8 +34,130 @@ import xstartup.data.XServiceResult;
 @XService
 public class SpaceCalibrationCloudServiceImpl implements ISpaceCalibrationCloudService {
 
+    /**
+     * 定期校准Cloud模块--定时任务
+     *
+     * @param context 上下文
+     * @return {@link XServiceResult}
+     */
     @Override
     public XServiceResult calibrateJob(XContext context) {
-        return null;
+        //查出所有周期配置
+        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(this.getExecutionCycleForCalibration(date, dayNumber));
+        historyView.setCalibrationDate(DateUtil.beginOfDay(DateUtil.offsetDay(date, dayNumber + 1)));
+        historyViewList.add(historyView);
+    }
+
+    /**
+     * 获取校准执行周期
+     *
+     * @param date   日期
+     * @param offset 抵消
+     * @return {@link String}
+     */
+    private 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();
     }
 }

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