Skip to content

G
gf_back
Commit 524895a4 authored by ZWT's avatar ZWT
Browse files
Options

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

1.开发间开优化短期间开优化定时任务;
2.开发间开优化短期间开优化定时任务,增加大间开井口时段信息初始化逻辑;

BREAKING CHANGE: 无

Closes 无

[skip ci]
parent 2ee75b71
Hide whitespace changes
Inline Side-by-side
Showing with 240 additions and 94 deletions
C00-common/pps-common/src/main/java/pps/core/common/constant/BusinessConstant.java
View file @ 524895a4
......@@ -41,6 +41,16 @@ public class BusinessConstant {
*/
public static final String DIESEL_POWER = "cf";
/**
* 间抽井
*/
public static final String INTERVAL_PUMPING_WELL = "INTERVAL";
/**
* 连抽井
*/
public static final String CONTINUOUS_PUMPING_WELL = "CONTINUOUS";
/*------------------------------数字------------------------------*/
/**
......
C11-space/pps-core-space/src/main/java/pps/core/space/service/SpaceOptimizeBaseService.java
View file @ 524895a4
......@@ -448,6 +448,75 @@ public class SpaceOptimizeBaseService {
return periodDTO.getId();
}
/**
* 创建间开优化井口信息
*
* @param wellheadDTOList 井口dtolist
* @param periodId 期间id
* @param wellheadId 井口id
* @param wellNumber 井号
* @return {@link String}
*/
public String createOptimizeWellhead(List<SpaceOptimizeWellheadDTO> wellheadDTOList, String periodId,
String wellheadId, String wellNumber) {
SpaceOptimizeWellheadDTO wellheadDTO = new SpaceOptimizeWellheadDTO();
BaseUtils.setBaseModelDefaultForJob(wellheadDTO);
wellheadDTO.setPeriodId(periodId);
wellheadDTO.setWellheadId(wellheadId);
wellheadDTO.setWellNumber(wellNumber);
wellheadDTOList.add(wellheadDTO);
return wellheadDTO.getId();
}
/**
* 创建间开原始间开区间
*
* @param unOptimizeDurationList 取消优化工期列表
* @param durationEnt 持续时间ent
* @param periodId 期间id
* @param recordId 记录id
* @param wellheadId 井口id
*/
public void createUnOptimizeDuration(List<SpaceOptimizeDurationDTO> unOptimizeDurationList,
SpaceInstitutionDurationEnt durationEnt,
String periodId, String recordId, String wellheadId) {
SpaceOptimizeDurationDTO durationDTO = new SpaceOptimizeDurationDTO();
BaseUtils.setBaseModelDefaultForJob(durationDTO);
durationDTO.setRecordId(recordId);
durationDTO.setPeriodId(periodId);
durationDTO.setWellheadId(wellheadId);
durationDTO.setIsOptimize(BusinessConstant.ONE);
durationDTO.setOpenWellTime(durationEnt.getOpenWellTime());
durationDTO.setCloseWellTime(durationEnt.getCloseWellTime());
unOptimizeDurationList.add(durationDTO);
}
/**
* 创建间开优化井口区间配置信息
*
* @param durationDTOList 持续时间dtolist
* @param periodId 期间id
* @param recordId 记录id
* @param wellheadId 井口id
* @param generationTypeKey 生成类型密钥
* @param openWellTime 开井时间
* @param endTimeString 结束时间字符串
*/
public void createOptimizeDuration(List<SpaceOptimizeDurationDTO> durationDTOList, String periodId,
String recordId, String wellheadId, String generationTypeKey,
String openWellTime, String endTimeString) {
SpaceOptimizeDurationDTO durationDTO = new SpaceOptimizeDurationDTO();
BaseUtils.setBaseModelDefaultForJob(durationDTO);
durationDTO.setRecordId(recordId);
durationDTO.setPeriodId(periodId);
durationDTO.setWellheadId(wellheadId);
durationDTO.setGenerationTypeKey(generationTypeKey);
durationDTO.setIsOptimize(BusinessConstant.ZERO);
durationDTO.setOpenWellTime(openWellTime);
durationDTO.setCloseWellTime(endTimeString);
durationDTOList.add(durationDTO);
}
/*-----------------------------------private-----------------------------------*/
/**
......@@ -728,7 +797,7 @@ public class SpaceOptimizeBaseService {
.sorted(Comparator.comparing(SpaceInstitutionWellheadView::getStartSeq))
.collect(
Collectors.partitioningBy(w -> StringUtils.equals(detailId, w.getInstitutionId()) &&
StringUtils.equals("INTERVAL", w.getRunTypeKey()) &&
StringUtils.equals(BusinessConstant.INTERVAL_PUMPING_WELL, w.getRunTypeKey()) &&
StringUtils.equals("0", w.getIntervalTypeKey())
)
);
......@@ -918,75 +987,6 @@ public class SpaceOptimizeBaseService {
}
}
/**
* 创建间开优化井口信息
*
* @param wellheadDTOList 井口dtolist
* @param periodId 期间id
* @param wellheadId 井口id
* @param wellNumber 井号
* @return {@link String}
*/
private String createOptimizeWellhead(List<SpaceOptimizeWellheadDTO> wellheadDTOList, String periodId,
String wellheadId, String wellNumber) {
SpaceOptimizeWellheadDTO wellheadDTO = new SpaceOptimizeWellheadDTO();
BaseUtils.setBaseModelDefaultForJob(wellheadDTO);
wellheadDTO.setPeriodId(periodId);
wellheadDTO.setWellheadId(wellheadId);
wellheadDTO.setWellNumber(wellNumber);
wellheadDTOList.add(wellheadDTO);
return wellheadDTO.getId();
}
/**
* 创建间开优化井口区间配置信息
*
* @param durationDTOList 持续时间dtolist
* @param periodId 期间id
* @param recordId 记录id
* @param wellheadId 井口id
* @param generationTypeKey 生成类型密钥
* @param openWellTime 开井时间
* @param endTimeString 结束时间字符串
*/
private void createOptimizeDuration(List<SpaceOptimizeDurationDTO> durationDTOList, String periodId,
String recordId, String wellheadId, String generationTypeKey,
String openWellTime, String endTimeString) {
SpaceOptimizeDurationDTO durationDTO = new SpaceOptimizeDurationDTO();
BaseUtils.setBaseModelDefaultForJob(durationDTO);
durationDTO.setRecordId(recordId);
durationDTO.setPeriodId(periodId);
durationDTO.setWellheadId(wellheadId);
durationDTO.setGenerationTypeKey(generationTypeKey);
durationDTO.setIsOptimize(BusinessConstant.ZERO);
durationDTO.setOpenWellTime(openWellTime);
durationDTO.setCloseWellTime(endTimeString);
durationDTOList.add(durationDTO);
}
/**
* 创建间开原始间开区间
*
* @param unOptimizeDurationList 取消优化工期列表
* @param durationEnt 持续时间ent
* @param periodId 期间id
* @param recordId 记录id
* @param wellheadId 井口id
*/
private void createUnOptimizeDuration(List<SpaceOptimizeDurationDTO> unOptimizeDurationList,
SpaceInstitutionDurationEnt durationEnt,
String periodId, String recordId, String wellheadId) {
SpaceOptimizeDurationDTO durationDTO = new SpaceOptimizeDurationDTO();
BaseUtils.setBaseModelDefaultForJob(durationDTO);
durationDTO.setRecordId(recordId);
durationDTO.setPeriodId(periodId);
durationDTO.setWellheadId(wellheadId);
durationDTO.setIsOptimize(BusinessConstant.ONE);
durationDTO.setOpenWellTime(durationEnt.getOpenWellTime());
durationDTO.setCloseWellTime(durationEnt.getCloseWellTime());
unOptimizeDurationList.add(durationDTO);
}
/**
* 离网型间开记录
*
......
C11-space/pps-core-space/src/main/java/pps/core/space/service/SpaceOptimizeShortCloudServiceImpl.java
View file @ 524895a4
......@@ -4,20 +4,20 @@ 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 org.apache.commons.lang3.StringUtils;
import pps.cloud.space.service.ISpaceOptimizeShortCloudService;
import pps.core.common.constant.BusinessConstant;
import pps.core.common.entity.BaseModel;
import pps.core.common.utils.BaseUtils;
import pps.core.space.entity.*;
import pps.core.space.enums.BusinessError;
import pps.core.space.mapper.SpaceInstitutionDurationMapper;
import pps.core.space.mapper.SpaceInstitutionWellheadMapper;
import pps.core.space.mapper.SpaceOptimizeShortPeriodMapper;
import xstartup.annotation.XService;
import xstartup.base.XContext;
import xstartup.base.exception.XServiceException;
import xstartup.data.XServiceResult;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;
/**
......@@ -44,37 +44,173 @@ public class SpaceOptimizeShortCloudServiceImpl extends SpaceOptimizeBaseService
List<String> institutionIdList = detailEntList.stream()
.map(BaseModel::getId)
.collect(Collectors.toList());
//取制度关联的所有井口
SpaceInstitutionWellheadMapper wellheadMapper = context.getBean(SpaceInstitutionWellheadMapper.class);
List<SpaceInstitutionWellheadEnt> wellheadList = wellheadMapper.selectList(new LambdaQueryWrapper<SpaceInstitutionWellheadEnt>()
.eq(BaseModel::getIsDeleted, BusinessConstant.ONE)
.in(SpaceInstitutionWellheadEnt::getInstitutionId, institutionIdList)
);
if (CollUtil.isEmpty(wellheadList)) {
//未发现可优化井口
throw new XServiceException(BusinessError.DidNotFindWellhead);
}
Map<String, List<SpaceInstitutionWellheadEnt>> wellheadsByInstitutionIdIdMap = wellheadList.stream()
.collect(Collectors.groupingBy(SpaceInstitutionWellheadEnt::getInstitutionId));
List<SpaceOptimizePeriodDTO> periodDTOList = new ArrayList<>(32);
List<SpaceOptimizeWellheadDTO> wellheadDTOList = new ArrayList<>(64);
List<SpaceOptimizeDurationDTO> durationDTOList = new ArrayList<>(128);
List<SpaceOptimizeDurationDTO> unOptimizeDurationList = new ArrayList<>(128);
DateTime endOfDay = DateUtil.endOfDay(date);
DateTime beginOfDay = DateUtil.beginOfDay(date);
//优化
for (SpaceInstitutionDetailEnt detail : detailEntList) {
String detailId = detail.getId();
String lineId = detail.getLineId();
//创建记录
String periodId = super.createOptimizePeriod(periodDTOList, detailId, lineId, null, endOfDay);
if (!wellheadsByInstitutionIdIdMap.containsKey(detailId)) {
//查是否已经存有短期历史数据
SpaceOptimizeShortPeriodMapper shortPeriodMapper = context.getBean(SpaceOptimizeShortPeriodMapper.class);
SpaceOptimizeShortPeriodEnt shortPeriod = shortPeriodMapper.selectOne(new LambdaQueryWrapper<SpaceOptimizeShortPeriodEnt>()
.eq(BaseModel::getIsDeleted, BusinessConstant.ZERO)
.eq(SpaceOptimizeShortPeriodEnt::getOptimizeDate, beginOfDay)
.eq(SpaceOptimizeShortPeriodEnt::getInstitutionId, detailId)
);
String periodId;
if (Objects.isNull(shortPeriod)) {
//创建记录
periodId = super.createOptimizePeriod(periodDTOList, detailId, lineId, null, beginOfDay);
} else {
periodId = shortPeriod.getId();
}
//查未记录的井口
SpaceInstitutionWellheadMapper wellheadMapper = context.getBean(SpaceInstitutionWellheadMapper.class);
List<SpaceInstitutionWellheadEnt> wellheadEntList = wellheadMapper.selectList(new LambdaQueryWrapper<SpaceInstitutionWellheadEnt>()
.eq(BaseModel::getIsDeleted, BusinessConstant.ONE)
.eq(SpaceInstitutionWellheadEnt::getInstitutionId, detailId)
.notExists("SELECT 1 FROM space_optimize_short_wellhead WHERE is_deleted = 1 AND short_period_id = {0}", periodId)
);
if (CollUtil.isEmpty(wellheadEntList)) {
continue;
}
List<SpaceInstitutionWellheadEnt> wellheadEntList = wellheadsByInstitutionIdIdMap.get(detailId);
for (SpaceInstitutionWellheadEnt wellhead : wellheadEntList) {
List<String> wellheadIdList = wellheadEntList.stream()
.map(SpaceInstitutionWellheadEnt::getWellheadId)
.collect(Collectors.toList());
//查需要初始化的时段配置
SpaceInstitutionDurationMapper durationMapper = context.getBean(SpaceInstitutionDurationMapper.class);
List<SpaceInstitutionDurationEnt> durationEntList = durationMapper.selectList(new LambdaQueryWrapper<SpaceInstitutionDurationEnt>()
.eq(BaseModel::getIsDeleted, BusinessConstant.ONE)
.eq(SpaceInstitutionDurationEnt::getInstitutionId, detailId)
.in(SpaceInstitutionDurationEnt::getWellheadId, wellheadIdList)
);
if (CollUtil.isEmpty(durationEntList)) {
continue;
}
Map<String, List<SpaceInstitutionDurationEnt>> durationListMap = durationEntList.stream()
.collect(Collectors.groupingBy(SpaceInstitutionDurationEnt::getWellheadId));
//按类型拆分井口
Map<Boolean, List<SpaceInstitutionWellheadEnt>> interval = wellheadEntList.stream()
.sorted(Comparator.comparing(SpaceInstitutionWellheadEnt::getStartSeq))
.collect(
Collectors.partitioningBy(w -> StringUtils.equals(detailId, w.getInstitutionId()) &&
StringUtils.equals(BusinessConstant.INTERVAL_PUMPING_WELL, w.getRunTypeKey()) &&
StringUtils.equals("0", w.getIntervalTypeKey())
)
);
//不需要优化的井口
List<SpaceInstitutionWellheadEnt> unOptimizeWellheadList = interval.get(false);
if (CollUtil.isNotEmpty(unOptimizeWellheadList)) {
for (SpaceInstitutionWellheadEnt wellhead : unOptimizeWellheadList) {
String wellheadId = wellhead.getWellheadId();
String recordId = super.createOptimizeWellhead(wellheadDTOList, periodId, wellheadId, wellhead.getWellNumber());
if (!durationListMap.containsKey(wellheadId)) {
continue;
}
switch (wellhead.getIntervalTypeKey()) {
//小间开(不优化)
case "0":
//初始化未优化间开
List<SpaceInstitutionDurationEnt> durationList = durationListMap.get(wellheadId);
for (SpaceInstitutionDurationEnt durationEnt : durationList) {
super.createUnOptimizeDuration(unOptimizeDurationList, durationEnt, periodId, recordId, wellheadId);
super.createOptimizeDuration(durationDTOList, periodId, recordId, wellheadId, null,
durationEnt.getOpenWellTime(), durationEnt.getCloseWellTime()
);
}
break;
//大间开
case "1":
boolean openFlag = true;
//计算开关井周期总天数
Integer openWellDay = Objects.isNull(wellhead.getOpenWellDay()) ? 0 : wellhead.getOpenWellDay();
Integer closeWellDay = Objects.isNull(wellhead.getCloseWellDay()) ? 0 : wellhead.getCloseWellDay();
Integer totalDays = openWellDay + closeWellDay;
if (!totalDays.equals(0)) {
//获取间开井口创建时间和当天的时间差
int betweenDay = (int) DateUtil.betweenDay(wellhead.getCreateTime(), DateUtil.date(), true);
switch (totalDays.compareTo(betweenDay)) {
case -1:
//按周期取余数和开井时间比较,超过开井时间就是关井
if (openWellDay.compareTo(betweenDay % totalDays) >= 0) {
//开井
openFlag = true;
} else {
//关井
openFlag = false;
}
break;
case 0:
//相等为周期最后一天,只要关井天数不为0就是关井
if (closeWellDay.equals(0)) {
//开井
openFlag = true;
} else {
//关井
openFlag = false;
}
break;
case 1:
//当前未过一个执行周期,判断开井时间是否大于时差,大于就是开井
if (openWellDay.compareTo(betweenDay) >= 0) {
//开井
openFlag = true;
} else {
//关井
openFlag = false;
}
break;
default:
}
String closeWellTime = BusinessConstant.START_OF_DAY_TIME;
if (openFlag) {
closeWellTime = BusinessConstant.END_OF_DAY_TIME;
}
//创建间开记录
this.createDuration(unOptimizeDurationList, recordId, periodId, wellheadId, BusinessConstant.ONE, BusinessConstant.START_OF_DAY_TIME, closeWellTime);
this.createDuration(durationDTOList, recordId, periodId, wellheadId, BusinessConstant.ZERO, BusinessConstant.START_OF_DAY_TIME, closeWellTime);
}
break;
default:
//未配置不处理
}
}
}
//需要优化的井口
List<SpaceInstitutionWellheadEnt> needToOptimizeWellheadList = interval.get(true);
if (CollUtil.isNotEmpty(needToOptimizeWellheadList)) {
for (SpaceInstitutionWellheadEnt wellhead : needToOptimizeWellheadList) {
String wellheadId = wellhead.getWellheadId();
String recordId = super.createOptimizeWellhead(wellheadDTOList, periodId, wellheadId, wellhead.getWellNumber());
if (!durationListMap.containsKey(wellheadId)) {
continue;
}
//初始化未优化间开
List<SpaceInstitutionDurationEnt> durationList = durationListMap.get(wellheadId);
for (SpaceInstitutionDurationEnt durationEnt : durationList) {
super.createUnOptimizeDuration(unOptimizeDurationList, durationEnt, periodId, recordId, wellheadId);
}
}
}
}
return XServiceResult.OK;
}
private void createDuration(List<SpaceOptimizeDurationDTO> durationDTOList, String recordId,
String periodId, String wellheadId, Integer isOptimize,
String openWellTime, String closeWellTime) {
SpaceOptimizeDurationDTO durationDTO = new SpaceOptimizeDurationDTO();
BaseUtils.setBaseModelDefaultForJob(durationDTO);
durationDTO.setRecordId(recordId);
durationDTO.setPeriodId(periodId);
durationDTO.setWellheadId(wellheadId);
durationDTO.setIsOptimize(isOptimize);
durationDTO.setOpenWellTime(openWellTime);
durationDTO.setCloseWellTime(closeWellTime);
durationDTOList.add(durationDTO);
}
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment