package com.zhitan.home.service;
|
|
import cn.hutool.core.date.DateTime;
|
import cn.hutool.core.date.DateUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.zhitan.basicdata.domain.SysEnergy;
|
import com.zhitan.basicdata.mapper.SysEnergyMapper;
|
import com.zhitan.common.core.domain.entity.SysDictData;
|
import com.zhitan.common.enums.TimeType;
|
import com.zhitan.consumptionanalysis.domain.vo.RankingEnergyData;
|
import com.zhitan.dataitem.service.IDataItemService;
|
import com.zhitan.home.domain.vo.HomeEnergyConsumptionTrendVO;
|
import com.zhitan.home.domain.vo.HomeEnergyStatisticsVO;
|
import com.zhitan.home.domain.vo.HomePeakValleyVO;
|
import com.zhitan.home.service.impl.IHomePageService;
|
import com.zhitan.model.domain.EnergyIndex;
|
import com.zhitan.model.domain.ModelNode;
|
import com.zhitan.model.domain.vo.ModelNodeIndexInfo;
|
import com.zhitan.model.mapper.ModelNodeMapper;
|
import com.zhitan.model.service.IEnergyIndexService;
|
import com.zhitan.model.service.IModelNodeService;
|
import com.zhitan.peakvalley.domain.ElectricityDataItem;
|
import com.zhitan.peakvalley.mapper.PeakValleyMapper;
|
import com.zhitan.realtimedata.domain.DataItem;
|
import com.zhitan.system.service.ISysDictDataService;
|
import lombok.AllArgsConstructor;
|
import org.apache.commons.collections4.CollectionUtils;
|
import org.apache.commons.lang3.ObjectUtils;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.stereotype.Service;
|
|
import java.math.BigDecimal;
|
import java.text.DecimalFormat;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* description todu
|
*
|
* @author ZhiTan
|
* @date 2024-10-31 18:07
|
*/
|
@Service
|
@AllArgsConstructor
|
public class HomePageServiceImpl implements IHomePageService {
|
|
private final SysEnergyMapper sysEnergyMapper;
|
private final IModelNodeService modelNodeService;
|
private final IDataItemService dataItemService;
|
private final IEnergyIndexService energyIndexService;
|
private final ISysDictDataService sysDictDataService;
|
private ModelNodeMapper modelNodeMapper;
|
private PeakValleyMapper electricityDataItemMapper;
|
|
|
@Override
|
public List<HomeEnergyStatisticsVO> energyConsumptionSummation(String timeType, String modelcode) {
|
Date currentTime = new Date();
|
|
DateTime tongbiTime = DateUtil.offsetMonth(currentTime, -12);
|
DateTime huanbiTime = DateUtil.offsetMonth(currentTime, -1);
|
if (TimeType.DAY.name().equals(timeType)) {
|
huanbiTime = DateUtil.offsetDay(currentTime, -1);
|
}
|
|
final List<HomeEnergyStatisticsVO> current = getEnergyTotalByTime(timeType, modelcode, currentTime);
|
final List<HomeEnergyStatisticsVO> tongbi = getEnergyTotalByTime(timeType, modelcode, tongbiTime);
|
final List<HomeEnergyStatisticsVO> huanbi = getEnergyTotalByTime(timeType, modelcode, huanbiTime);
|
|
final Map<String, List<HomeEnergyStatisticsVO>> tongbiMap = tongbi.stream().collect(Collectors.groupingBy(HomeEnergyStatisticsVO::getEnergyNo));
|
final Map<String, List<HomeEnergyStatisticsVO>> huanbiMap = huanbi.stream().collect(Collectors.groupingBy(HomeEnergyStatisticsVO::getEnergyNo));
|
|
current.stream().forEach(vo -> {
|
final String energyNo = vo.getEnergyNo();
|
final Double count = vo.getCount();
|
final Double tongbiCount = tongbiMap.get(energyNo).stream().map(HomeEnergyStatisticsVO::getCount).mapToDouble(Double::doubleValue).sum();
|
final Double huanbiCount = huanbiMap.get(energyNo).stream().map(HomeEnergyStatisticsVO::getCount).mapToDouble(Double::doubleValue).sum();
|
|
vo.setTonCount(format2Double(count));
|
if (tongbiCount != 0) {
|
vo.setTongbi(format2Double((count - tongbiCount) / tongbiCount * 100));
|
} else {
|
vo.setTongbi(0D);
|
}
|
|
if (huanbiCount != 0) {
|
vo.setHuanbi(format2Double((count - huanbiCount) / huanbiCount * 100));
|
} else {
|
vo.setHuanbi(0D);
|
}
|
});
|
return current;
|
}
|
|
private List<HomeEnergyStatisticsVO> getEnergyTotalByTime(String timeType, String modelcode, Date queryTime) {
|
List<HomeEnergyStatisticsVO> voList = new ArrayList<>();
|
|
Date beginTime;
|
Date endTime;
|
String shixuTimeType;
|
if (TimeType.DAY.name().equals(timeType)) {
|
beginTime = DateUtil.beginOfDay(queryTime);
|
endTime = DateUtil.endOfDay(beginTime);
|
shixuTimeType = TimeType.HOUR.name();
|
// 月
|
} else if (TimeType.MONTH.name().equals(timeType)) {
|
beginTime = DateUtil.beginOfMonth(queryTime);
|
endTime = DateUtil.endOfMonth(beginTime);
|
shixuTimeType = TimeType.DAY.name();
|
// 年
|
} else {
|
beginTime = DateUtil.beginOfYear(queryTime);
|
endTime = DateUtil.endOfYear(beginTime);
|
shixuTimeType = TimeType.MONTH.name();
|
}
|
|
// 查询所有能源类型
|
List<SysEnergy> sysEnergies = sysEnergyMapper.selectSysEnergyList(new SysEnergy());
|
voList = sysEnergies.stream().map(dict -> {
|
HomeEnergyStatisticsVO vo = new HomeEnergyStatisticsVO();
|
vo.setEnergyName(dict.getEnername());
|
vo.setEnergyNo(dict.getEnersno());
|
vo.setEnergyUnit(dict.getMuid());
|
vo.setCount(0D);
|
vo.setTonCount(0D);
|
vo.setCoefficient(dict.getCoefficient().toString());
|
return vo;
|
}).sorted(Comparator.comparing(HomeEnergyStatisticsVO::getEnergyName)).collect(Collectors.toList());
|
// 通过code获取modelnode对应index信息
|
ModelNode modelNode = modelNodeService.getModelNodeByModelCodeByIndexCode(modelcode);
|
if (ObjectUtils.isEmpty(modelNode)) {
|
return voList;
|
}
|
List<ModelNodeIndexInfo> inforList = modelNodeService.getModelNodeIndexIdRelationInforByNodeId(modelNode.getNodeId());
|
List<String> indexIds = inforList.stream().map(ModelNodeIndexInfo::getIndexId).collect(Collectors.toList());
|
// 通过indexIds找data_Item数据
|
List<DataItem> itemList = dataItemService.getDataItemTimeRangeInforByIndexIds(beginTime, endTime, shixuTimeType, indexIds);
|
// 查询点位详细信息
|
List<EnergyIndex> energyIndexInforList = energyIndexService.getEnergyIndexByIds(indexIds);
|
// 获取点位能源类型
|
Map<String, List<String>> energyTypeMap = energyIndexInforList.stream()
|
.filter(l -> StringUtils.isNotEmpty(l.getEnergyId())).collect(Collectors.groupingBy(
|
EnergyIndex::getEnergyId, Collectors.mapping(EnergyIndex::getIndexId, Collectors.toList())
|
));
|
|
for (HomeEnergyStatisticsVO ratioVO : voList) {
|
List<String> indexs = energyTypeMap.get(ratioVO.getEnergyNo());
|
if (CollectionUtils.isEmpty(indexs)) {
|
ratioVO.setCount(0D);
|
} else {
|
// 找到合计值
|
double doubleCount = itemList.stream().filter(li -> indexs.contains(li.getIndexId())).mapToDouble(DataItem::getValue).sum();
|
ratioVO.setCount(format2Double(doubleCount));
|
}
|
}
|
return voList;
|
}
|
|
private double format2Double(double averageEnergy) {
|
// 创建DecimalFormat对象，设置保留两位小数
|
DecimalFormat df = new DecimalFormat("#.00");
|
|
// 格式化结果
|
String formattedResult = df.format(averageEnergy);
|
return Double.valueOf(formattedResult);
|
}
|
|
@Override
|
public List<HomePeakValleyVO> peakValley(String timeType, String modelcode) {
|
List<HomePeakValleyVO> voList = new ArrayList<>();
|
// 查询器具类型
|
final List<SysDictData> electricityPrice = sysDictDataService.selectDictDataByType("electricity_price");
|
electricityPrice.stream().forEach(v -> {
|
HomePeakValleyVO vo = new HomePeakValleyVO();
|
vo.setTimeName(v.getDictLabel());
|
vo.setTimeType(v.getDictValue());
|
vo.setCount(0D);
|
vo.setPercentage(0D);
|
voList.add(vo);
|
});
|
|
|
Date queryTime = new Date();
|
// Date queryTime = DateUtil.parseDateTime("2024-08-28 00:00:00");
|
Date beginTime;
|
Date endTime;
|
String shixuTimeType;
|
if (TimeType.DAY.name().equals(timeType)) {
|
beginTime = DateUtil.beginOfDay(queryTime);
|
endTime = DateUtil.endOfDay(beginTime);
|
shixuTimeType = TimeType.HOUR.name();
|
// 月
|
} else if (TimeType.MONTH.name().equals(timeType)) {
|
beginTime = DateUtil.beginOfMonth(queryTime);
|
endTime = DateUtil.endOfMonth(beginTime);
|
shixuTimeType = TimeType.DAY.name();
|
// 年
|
} else {
|
beginTime = DateUtil.beginOfYear(queryTime);
|
endTime = DateUtil.endOfYear(beginTime);
|
shixuTimeType = TimeType.MONTH.name();
|
}
|
|
Map<String, List<ElectricityDataItem>> electricityDataMap;
|
// 查询点位信息
|
final ModelNode firstModeNodeInfo = modelNodeMapper.getFirstModeNodeInfo(modelcode);
|
if (null == firstModeNodeInfo) {
|
return voList;
|
}
|
|
double totalElectric;
|
// 查询点位信息
|
List<ModelNodeIndexInfo> nodeIndexInfoList = modelNodeMapper.selectIndexByModelCodeAndNodeId(modelcode, firstModeNodeInfo.getNodeId());
|
if (CollectionUtils.isNotEmpty(nodeIndexInfoList)) {
|
Set<String> indexSet = nodeIndexInfoList.stream().map(ModelNodeIndexInfo::getIndexId).collect(Collectors.toSet());
|
List<ElectricityDataItem> dataItemList = electricityDataItemMapper.getDataStatistics(indexSet, beginTime, endTime, shixuTimeType);
|
if (null != dataItemList) {
|
totalElectric = dataItemList.stream().map(ElectricityDataItem::getElectricity).mapToDouble(BigDecimal::doubleValue).sum();
|
} else {
|
totalElectric = 0;
|
}
|
electricityDataMap = dataItemList.stream()
|
.collect(Collectors.groupingBy(ElectricityDataItem::getElectricityType));
|
} else {
|
totalElectric = 0;
|
electricityDataMap = null;
|
}
|
if (null != electricityDataMap) {
|
voList.stream().forEach(vo -> {
|
final List<ElectricityDataItem> electricityDataItems = electricityDataMap.get(vo.getTimeType());
|
if (null != electricityDataItems) {
|
final double sum = electricityDataItems.stream().map(ElectricityDataItem::getElectricity).mapToDouble(BigDecimal::doubleValue).sum();
|
vo.setCount(format2Double(sum));
|
if (totalElectric != 0) {
|
vo.setPercentage(format2Double(sum / totalElectric * 100));
|
}
|
}
|
});
|
}
|
return voList;
|
}
|
|
@Override
|
public HomeEnergyConsumptionTrendVO energyConsumptionTrend(String timeType, String modelcode) {
|
HomeEnergyConsumptionTrendVO vo = new HomeEnergyConsumptionTrendVO();
|
List<List<Double>> ydataList = new ArrayList<>();
|
List<String> xdataList = new ArrayList<>();
|
// 查询所有能源类型
|
List<SysEnergy> sysEnergies = sysEnergyMapper.selectSysEnergyList(new SysEnergy());
|
|
Date queryTime = new Date();
|
Date beginTime;
|
Date endTime;
|
String shixuTimeType;
|
String timeFormat;
|
if (TimeType.DAY.name().equals(timeType)) {
|
beginTime = DateUtil.beginOfDay(queryTime);
|
endTime = DateUtil.endOfDay(beginTime);
|
shixuTimeType = TimeType.HOUR.name();
|
timeFormat = "yyyy-MM-dd HH";
|
// 月
|
} else if (TimeType.MONTH.name().equals(timeType)) {
|
beginTime = DateUtil.beginOfMonth(queryTime);
|
endTime = DateUtil.endOfMonth(beginTime);
|
shixuTimeType = TimeType.DAY.name();
|
timeFormat = "yyyy-MM-dd";
|
// 年
|
} else {
|
beginTime = DateUtil.beginOfYear(queryTime);
|
endTime = DateUtil.endOfYear(beginTime);
|
shixuTimeType = TimeType.MONTH.name();
|
timeFormat = "yyyy-MM";
|
}
|
|
|
// 通过code获取modelnode对应index信息
|
ModelNode modelNode = modelNodeService.getModelNodeByModelCodeByIndexCode(modelcode);
|
if (ObjectUtils.isEmpty(modelNode)) {
|
return vo;
|
}
|
List<ModelNodeIndexInfo> inforList = modelNodeService.getModelNodeIndexIdRelationInforByNodeId(modelNode.getNodeId());
|
List<String> indexIds = inforList.stream().map(ModelNodeIndexInfo::getIndexId).collect(Collectors.toList());
|
// 通过indexIds找data_Item数据
|
List<DataItem> itemList = dataItemService.getDataItemTimeRangeInforByIndexIds(beginTime, endTime, shixuTimeType, indexIds);
|
final Map<String, List<DataItem>> dataItemMap = itemList.stream().collect(Collectors.groupingBy(li -> DateUtil.format(li.getDataTime(), timeFormat)));
|
// 查询点位详细信息
|
List<EnergyIndex> energyIndexInforList = energyIndexService.getEnergyIndexByIds(indexIds);
|
// 获取点位能源类型
|
Map<String, List<String>> energyTypeMap = energyIndexInforList.stream()
|
.filter(l -> StringUtils.isNotEmpty(l.getEnergyId())).collect(Collectors.groupingBy(
|
EnergyIndex::getEnergyId, Collectors.mapping(EnergyIndex::getIndexId, Collectors.toList())
|
));
|
|
List<String> lengList = new ArrayList<>();
|
|
while (!beginTime.after(endTime)) {
|
final String currentTime = DateUtil.format(beginTime, timeFormat);
|
xdataList.add(currentTime);
|
final List<DataItem> dataItems = dataItemMap.get(currentTime);
|
List<Double> energyCount = new ArrayList<>();
|
|
sysEnergies.forEach(x -> {
|
if(!lengList.contains(x.getEnername())){
|
lengList.add(x.getEnername());
|
}
|
List<String> indexIdList = energyTypeMap.get(x.getEnersno());
|
double sum;
|
if (null == dataItems || CollectionUtils.isEmpty(indexIdList)) {
|
sum = 0;
|
} else {
|
sum = dataItems.stream().filter(li -> indexIdList.contains(li.getIndexId())).mapToDouble(DataItem::getValue).sum();
|
}
|
energyCount.add(sum * x.getCoefficient().doubleValue());
|
});
|
ydataList.add(energyCount);
|
|
switch (TimeType.valueOf(timeType)) {
|
case DAY:
|
beginTime = DateUtil.offsetHour(beginTime, 1);
|
break;
|
case MONTH:
|
beginTime = DateUtil.offsetDay(beginTime, 1);
|
break;
|
default:
|
beginTime = DateUtil.offsetMonth(beginTime, 1);
|
break;
|
}
|
}
|
vo.setXdata(xdataList.toArray(new String[0]));
|
Double[][] array = new Double[sysEnergies.size()][xdataList.size()];
|
|
for (int i = 0; i < ydataList.size(); i++) {
|
final List<Double> doubleList = ydataList.get(i);
|
for (int n = 0; n < doubleList.size(); n++) {
|
array[n][i] = format2Double(doubleList.get(n));
|
}
|
}
|
vo.setYdata(array);
|
vo.setLegend(lengList.toArray(new String[0]));
|
return vo;
|
}
|
|
@Override
|
public List<RankingEnergyData> energyConsumptionRanking(String modelCode, String timeType) {
|
|
List<RankingEnergyData> energyDataList = new ArrayList<>();
|
Date queryTime = new Date();
|
Date beginTime;
|
Date endTime;
|
if (TimeType.DAY.name().equals(timeType)) {
|
beginTime = DateUtil.beginOfDay(queryTime);
|
endTime = DateUtil.endOfDay(queryTime);
|
timeType = TimeType.HOUR.name();
|
// 月
|
} else if (TimeType.MONTH.name().equals(timeType)) {
|
beginTime = DateUtil.beginOfMonth(queryTime);
|
endTime = DateUtil.endOfMonth(queryTime);
|
timeType = TimeType.DAY.name();
|
|
// 年
|
} else if (TimeType.YEAR.name().equals(timeType)) {
|
beginTime = DateUtil.beginOfYear(queryTime);
|
endTime = DateUtil.endOfYear(queryTime);
|
timeType = TimeType.MONTH.name();
|
|
} else {
|
return energyDataList;
|
}
|
|
LambdaQueryWrapper<ModelNode> parentNodeLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
parentNodeLambdaQueryWrapper.eq(ModelNode::getModelCode, modelCode);
|
List<ModelNode> modelNodeList = modelNodeMapper.selectList(parentNodeLambdaQueryWrapper);
|
if (CollectionUtils.isEmpty(modelNodeList)) {
|
return energyDataList;
|
}
|
ModelNode parentNode = modelNodeList.stream().filter(x -> ObjectUtils.isEmpty(x.getParentId())).findFirst().orElse(null);
|
if (ObjectUtils.isEmpty(parentNode)) {
|
return energyDataList;
|
}
|
List<String> nodeIds = modelNodeList.stream().filter(x -> ObjectUtils.isNotEmpty(x.getParentId()) && parentNode.getNodeId().equals(x.getParentId()))
|
.map(ModelNode::getNodeId).collect(Collectors.toList());
|
if (ObjectUtils.isEmpty(nodeIds)) {
|
return energyDataList;
|
}
|
energyDataList = dataItemService.getHomePageConsumptionRanking(nodeIds, timeType, beginTime, endTime);
|
energyDataList.forEach(x -> {
|
x.energyConsumption = new BigDecimal(x.energyConsumption).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
|
});
|
return energyDataList;
|
}
|
}
|
