package com.ruoyi.http.util;
|
|
import com.ruoyi.http.vo.StatisticEleComparisonVo;
|
import com.ruoyi.http.vo.StatisticEleRecordVo;
|
import com.ruoyi.http.vo.StatisticEleSplitItemVo;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.DayOfWeek;
|
import java.time.LocalDate;
|
import java.time.YearMonth;
|
import java.time.format.DateTimeFormatter;
|
import java.time.temporal.ChronoUnit;
|
import java.time.temporal.WeekFields;
|
import java.util.ArrayList;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Locale;
|
import java.util.Map;
|
import java.util.function.Function;
|
|
/**
|
* 能耗综合分析计算
|
*/
|
public final class StatisticEleAnalyticsUtil {
|
|
private static final DateTimeFormatter DAY_FMT = DateTimeFormatter.ofPattern("yyyyMMdd");
|
private static final int SUMMARY_SCALE = 2;
|
/** 白班 08:00-19:59 */
|
private static final int DAY_SHIFT_START = 8;
|
private static final int DAY_SHIFT_END = 19;
|
|
private StatisticEleAnalyticsUtil() {
|
}
|
|
public static final Function<String, String> HOUR_TO_WEEK = tk -> {
|
if (tk == null || tk.length() < 8) {
|
return null;
|
}
|
LocalDate date = LocalDate.parse(tk.substring(0, 8), DAY_FMT);
|
WeekFields wf = WeekFields.of(Locale.CHINA);
|
int week = date.get(wf.weekOfWeekBasedYear());
|
int year = date.get(wf.weekBasedYear());
|
return String.format("%04dW%02d", year, week);
|
};
|
|
public static Function<String, String> trendBucketFn(String granularity) {
|
return switch (granularity) {
|
case "hour" -> StatisticEleAggregateUtil.HOUR_TO_HOUR;
|
case "week" -> HOUR_TO_WEEK;
|
case "month" -> StatisticEleAggregateUtil.HOUR_TO_MONTH;
|
case "year" -> StatisticEleAggregateUtil.HOUR_TO_YEAR;
|
default -> StatisticEleAggregateUtil.HOUR_TO_DAY;
|
};
|
}
|
|
/**
|
* 周期累计来自汇总桶，极值/均值始终来自小时桶。
|
*/
|
public static StatisticEleAggregateUtil.StatisticEleSummaryMetrics calcCombinedMetrics(
|
List<StatisticEleRecordVo> hourRecords,
|
List<StatisticEleRecordVo> periodChartRecords) {
|
List<StatisticEleRecordVo> hourlyBuckets = StatisticEleAggregateUtil.aggregateHourToBuckets(
|
hourRecords, StatisticEleAggregateUtil.HOUR_TO_HOUR);
|
StatisticEleAggregateUtil.StatisticEleSummaryMetrics hourMetrics =
|
StatisticEleAggregateUtil.calcMetrics(hourlyBuckets);
|
StatisticEleAggregateUtil.StatisticEleSummaryMetrics periodMetrics =
|
StatisticEleAggregateUtil.calcMetrics(periodChartRecords);
|
|
StatisticEleAggregateUtil.StatisticEleSummaryMetrics result =
|
new StatisticEleAggregateUtil.StatisticEleSummaryMetrics();
|
result.setRecordCount(periodMetrics.getRecordCount());
|
result.setTotalConsumption(hourMetrics.getTotalConsumption());
|
result.setAvgConsumption(hourMetrics.getAvgConsumption());
|
result.setMaxConsumption(hourMetrics.getMaxConsumption());
|
result.setMinConsumption(hourMetrics.getMinConsumption());
|
return result;
|
}
|
|
public static double calcLoadRate(Double avgHourly, Double maxHourly) {
|
if (avgHourly == null || maxHourly == null || maxHourly <= 0) {
|
return 0.0;
|
}
|
return roundSummary(BigDecimal.valueOf(avgHourly)
|
.divide(BigDecimal.valueOf(maxHourly), SUMMARY_SCALE + 2, RoundingMode.HALF_UP)
|
.multiply(BigDecimal.valueOf(100)));
|
}
|
|
public static List<StatisticEleSplitItemVo> calcPeriodSplits(List<StatisticEleRecordVo> hourRecords) {
|
double sharp = sumField(hourRecords, StatisticEleRecordVo::getSharpConsumption);
|
double peak = sumField(hourRecords, StatisticEleRecordVo::getPeakConsumption);
|
double flat = sumField(hourRecords, StatisticEleRecordVo::getFlatConsumption);
|
double valley = sumField(hourRecords, StatisticEleRecordVo::getValleyConsumption);
|
double total = sharp + peak + flat + valley;
|
if (total <= 0) {
|
total = sumField(hourRecords, StatisticEleRecordVo::getTotalConsumption);
|
}
|
List<StatisticEleSplitItemVo> items = new ArrayList<>();
|
addSplitItem(items, "尖", sharp, total);
|
addSplitItem(items, "峰", peak, total);
|
addSplitItem(items, "平", flat, total);
|
addSplitItem(items, "谷", valley, total);
|
return items.stream().filter(i -> i.getConsumption() != null && i.getConsumption() > 0).toList();
|
}
|
|
public static List<StatisticEleSplitItemVo> calcShiftSplits(List<StatisticEleRecordVo> hourRecords) {
|
Map<String, Double> map = new LinkedHashMap<>();
|
map.put("白班", 0.0);
|
map.put("夜班", 0.0);
|
for (StatisticEleRecordVo record : hourRecords) {
|
int hour = parseHour(record.getTimeKey());
|
if (hour < 0) {
|
continue;
|
}
|
double val = safe(record.getTotalConsumption());
|
if (hour >= DAY_SHIFT_START && hour <= DAY_SHIFT_END) {
|
map.merge("白班", val, Double::sum);
|
} else {
|
map.merge("夜班", val, Double::sum);
|
}
|
}
|
return toSplitItems(map);
|
}
|
|
public static List<StatisticEleSplitItemVo> calcDayTypeSplits(List<StatisticEleRecordVo> hourRecords) {
|
Map<String, Double> map = new LinkedHashMap<>();
|
map.put("工作日", 0.0);
|
map.put("休息日", 0.0);
|
for (StatisticEleRecordVo record : hourRecords) {
|
LocalDate date = parseDate(record.getTimeKey());
|
if (date == null) {
|
continue;
|
}
|
double val = safe(record.getTotalConsumption());
|
DayOfWeek dow = date.getDayOfWeek();
|
if (dow == DayOfWeek.SATURDAY || dow == DayOfWeek.SUNDAY) {
|
map.merge("休息日", val, Double::sum);
|
} else {
|
map.merge("工作日", val, Double::sum);
|
}
|
}
|
return toSplitItems(map);
|
}
|
|
public static StatisticEleComparisonVo buildComparison(
|
String type, String label, Double currentTotal, Double compareTotal) {
|
StatisticEleComparisonVo vo = new StatisticEleComparisonVo();
|
vo.setType(type);
|
vo.setLabel(label);
|
vo.setCurrentTotal(round(currentTotal));
|
vo.setCompareTotal(round(compareTotal));
|
double delta = round(safe(currentTotal) - safe(compareTotal));
|
vo.setDelta(delta);
|
if (compareTotal != null && compareTotal > 0) {
|
vo.setChangeRate(roundSummary(BigDecimal.valueOf(delta)
|
.divide(BigDecimal.valueOf(compareTotal), SUMMARY_SCALE + 2, RoundingMode.HALF_UP)
|
.multiply(BigDecimal.valueOf(100))));
|
} else {
|
vo.setChangeRate(currentTotal != null && currentTotal > 0 ? 100.0 : 0.0);
|
}
|
return vo;
|
}
|
|
public record DateBounds(LocalDate start, LocalDate end) {}
|
|
public static DateBounds resolveBounds(String dimension, String startTime, String endTime) {
|
LocalDate start = resolveStartDate(dimension, startTime);
|
LocalDate end = resolveEndDate(dimension, endTime);
|
if (start.isAfter(end)) {
|
LocalDate tmp = start;
|
start = end;
|
end = tmp;
|
}
|
return new DateBounds(start, end);
|
}
|
|
public static DateBounds shiftChain(DateBounds bounds) {
|
long days = ChronoUnit.DAYS.between(bounds.start(), bounds.end()) + 1;
|
return new DateBounds(bounds.start().minusDays(days), bounds.start().minusDays(1));
|
}
|
|
public static DateBounds shiftYoy(DateBounds bounds) {
|
return new DateBounds(bounds.start().minusYears(1), bounds.end().minusYears(1));
|
}
|
|
public static String defaultTrendGranularity(String dimension, boolean singleDay) {
|
if (singleDay) {
|
return "hour";
|
}
|
return switch (dimension) {
|
case "week", "day" -> "day";
|
case "month", "quarter" -> "week";
|
case "year" -> "month";
|
default -> "day";
|
};
|
}
|
|
private static LocalDate resolveStartDate(String dimension, String startTime) {
|
return switch (dimension) {
|
case "year" -> LocalDate.of(Integer.parseInt(startTime), 1, 1);
|
case "month" -> YearMonth.parse(startTime, DateTimeFormatter.ofPattern("yyyyMM")).atDay(1);
|
default -> LocalDate.parse(normalizeDayKey(startTime), DAY_FMT);
|
};
|
}
|
|
private static LocalDate resolveEndDate(String dimension, String endTime) {
|
return switch (dimension) {
|
case "year" -> LocalDate.of(Integer.parseInt(endTime), 12, 31);
|
case "month" -> YearMonth.parse(endTime, DateTimeFormatter.ofPattern("yyyyMM")).atEndOfMonth();
|
default -> LocalDate.parse(normalizeDayKey(endTime), DAY_FMT);
|
};
|
}
|
|
private static String normalizeDayKey(String timeKey) {
|
if (timeKey == null) {
|
return LocalDate.now().format(DAY_FMT);
|
}
|
if (timeKey.length() == 4) {
|
return timeKey + "0101";
|
}
|
if (timeKey.length() == 6) {
|
return timeKey + "01";
|
}
|
return timeKey.length() >= 8 ? timeKey.substring(0, 8) : timeKey;
|
}
|
|
private static List<StatisticEleSplitItemVo> toSplitItems(Map<String, Double> map) {
|
double total = map.values().stream().mapToDouble(v -> v).sum();
|
List<StatisticEleSplitItemVo> items = new ArrayList<>();
|
map.forEach((name, val) -> addSplitItem(items, name, val, total));
|
return items;
|
}
|
|
private static void addSplitItem(List<StatisticEleSplitItemVo> items, String name, double val, double total) {
|
if (val <= 0) {
|
return;
|
}
|
StatisticEleSplitItemVo item = new StatisticEleSplitItemVo();
|
item.setName(name);
|
item.setConsumption(round(val));
|
item.setRatio(total > 0 ? roundSummary(BigDecimal.valueOf(val)
|
.divide(BigDecimal.valueOf(total), SUMMARY_SCALE + 2, RoundingMode.HALF_UP)
|
.multiply(BigDecimal.valueOf(100))) : 0.0);
|
items.add(item);
|
}
|
|
private static double sumField(List<StatisticEleRecordVo> records,
|
Function<StatisticEleRecordVo, Double> getter) {
|
return records.stream().map(getter).mapToDouble(StatisticEleAnalyticsUtil::safe).sum();
|
}
|
|
private static int parseHour(String timeKey) {
|
if (timeKey == null || timeKey.length() < 10) {
|
return -1;
|
}
|
try {
|
return Integer.parseInt(timeKey.substring(8, 10));
|
} catch (NumberFormatException e) {
|
return -1;
|
}
|
}
|
|
private static LocalDate parseDate(String timeKey) {
|
if (timeKey == null || timeKey.length() < 8) {
|
return null;
|
}
|
try {
|
return LocalDate.parse(timeKey.substring(0, 8), DAY_FMT);
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
private static double safe(Double v) {
|
return v == null ? 0.0 : v;
|
}
|
|
private static double round(Double v) {
|
if (v == null) {
|
return 0.0;
|
}
|
return roundSummary(BigDecimal.valueOf(v));
|
}
|
|
private static double roundSummary(BigDecimal value) {
|
return value.setScale(SUMMARY_SCALE, RoundingMode.HALF_UP).doubleValue();
|
}
|
}
|
