支路用能分析优化

zt916916

2025-03-27 8b3b97865cb3ef4000b34ca6a3e643ecd58e841d

支路用能分析优化

 zhitan-common/src/main/java/com/zhitan/common/utils/DateTimeUtil.java

@@ -844,4 +844,76 @@
        }
        return resultList;
    }

    /**
     * 通过时间类型返回对应的时间list
     * <p>
     * 参数：
     * timeType="YEAR",dataTime="2025-01-01 00:00:00"
     * timeType="MONTH",dataTime="2025-01-01 00:00:00"
     * timeType="DAY",dataTime="2025-01-01 00:00:00"
     * 返回格式：
     * [
     * {"datatime":"2025-01-01 00:00:00","value":"value1"},
     * {"datatime":"2025-02-01 00:00:00","value":"value2"},
     * {"datatime":"2025-03-01 00:00:00","value":"value3"},
     * {"datatime":"2025-04-01 00:00:00","value":"value4"},
     * {"datatime":"2025-05-01 00:00:00","value":"value5"},
     * {"datatime":"2025-06-01 00:00:00","value":"value6"},
     * {"datatime":"2025-07-01 00:00:00","value":"value7"},
     * {"datatime":"2025-08-01 00:00:00","value":"value8"},
     * {"datatime":"2025-09-01 00:00:00","value":"value9"},
     * {"datatime":"2025-10-01 00:00:00","value":"value10"},
     * {"datatime":"2025-11-01 00:00:00","value":"value11"},
     * {"datatime":"2025-12-01 00:00:00","value":"value12"}
     * ]
     *
     * @param timeType
     * @param dataTime
     * @return
     */
    public static List<TypeTime> getDateTimeListSame(String timeType, Date dataTime) {

        List<TypeTime> resultList = new ArrayList<>();
        Date beginTime;
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_DAY:
                beginTime = DateUtil.beginOfDay(dataTime);
                for (int i = 1; i <= 24; i++) {
                    TypeTime typeTime = new TypeTime();
                    typeTime.setDataTime(DateUtil.format(beginTime, COMMON_PATTERN));
                    typeTime.setTimeCode(CommonConst.WORD_H + DateUtil.format(beginTime, COMMON_PATTERN_HOUR));
                    typeTime.setDateTime(beginTime);
                    typeTime.setValue("value" + i);
                    resultList.add(typeTime);
                    beginTime = addHours(beginTime, 1);
                }
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                beginTime = DateUtil.beginOfMonth(dataTime);
                for (int i = 1; i <= 31; i++) {
                    TypeTime typeTime = new TypeTime();
                    typeTime.setDataTime(DateUtil.format(beginTime, COMMON_PATTERN));
                    typeTime.setTimeCode(CommonConst.WORD_D + DateUtil.format(beginTime, COMMON_PATTERN_DAY));
                    typeTime.setDateTime(beginTime);
                    typeTime.setValue("value" + i);
                    resultList.add(typeTime);
                    beginTime = addDays(beginTime, 1);
                }
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                beginTime = DateUtil.beginOfYear(dataTime);
                for (int i = 1; i <= 12; i++) {
                    TypeTime typeTime = new TypeTime();
                    typeTime.setDataTime(DateUtil.format(beginTime, COMMON_PATTERN));
                    typeTime.setTimeCode(CommonConst.WORD_M + DateUtil.format(beginTime, COMMON_PATTERN_MONTH));
                    typeTime.setDateTime(beginTime);
                    typeTime.setValue("value" + i);
                    resultList.add(typeTime);
                    beginTime = addMonths(beginTime, 1);
                }
                break;
        }
        return resultList;
    }
}

 zhitan-system/src/main/java/com/zhitan/branchanalysis/service/impl/BranchAnalysisServiceImpl.java

@@ -9,6 +9,7 @@
import com.zhitan.common.utils.DateTimeUtil;
import com.zhitan.branchanalysis.service.IBranchAnalysisService;
import com.zhitan.common.utils.PropUtils;
import com.zhitan.common.utils.TypeTime;
import com.zhitan.dataitem.mapper.DataItemMapper;
import com.zhitan.model.domain.vo.ModelNodeIndexInfo;
import com.zhitan.model.domain.vo.ModelNodeIndexInfor;
@@ -18,8 +19,11 @@
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
@@ -49,43 +53,65 @@
            return new BranchAnalysisVO();
        }

        ModelNodeIndexInfo info = nodeIndexInfo.stream().findFirst().get();

        String pattern;
        List<TypeTime> dateTimeList;
        //根据时间类型调整时间范围
        switch (dto.getTimeType()) {
            case TimeTypeConst.TIME_TYPE_DAY:
                timeType = TimeTypeConst.TIME_TYPE_HOUR;
                endTime = DateUtil.endOfDay(beginTime);
                pattern = "HH";
                dateTimeList = DateTimeUtil.getDateTimeListSame(TimeTypeConst.TIME_TYPE_DAY, beginTime);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                timeType = TimeTypeConst.TIME_TYPE_DAY;
                endTime = DateUtil.endOfMonth(beginTime);
                pattern = "dd";
                dateTimeList = DateTimeUtil.getDateTimeListSame(TimeTypeConst.TIME_TYPE_MONTH, beginTime);
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                timeType = TimeTypeConst.TIME_TYPE_MONTH;
                endTime = DateUtil.endOfYear(beginTime);
                pattern = "MM";
                dateTimeList = DateTimeUtil.getDateTimeListSame(TimeTypeConst.TIME_TYPE_YEAR, beginTime);
                break;
            default:
                throw new ServiceException("时间格式错误");
        }

        BranchAnalysisVO vo = new BranchAnalysisVO();
        if (ObjectUtil.isEmpty(indexlist)) {
            return vo;
        }
        List<DataItem> dataItemlist = dataItemMapper.getDataItemTimeRangeInforByIndexIds(beginTime, endTime, timeType, indexlist);

        BranchAnalysisVO vo = new BranchAnalysisVO();
        double sum = dataItemlist.stream().mapToDouble(DataItem::getValue).sum();
        vo.setTotal(sum);
        if (ObjectUtil.isNotEmpty(info.getIndexId())) {
            vo.setUntil(info.getUnitId());
        }
        vo.setNodeId(dto.getNodeId());
        vo.setNodeName(nodeIndexInfo.get(0).getName());
        Map<Date, List<DataItem>> dateListMap = dataItemlist.stream().collect(Collectors.groupingBy(DataItem::getDataTime));

        vo.setNodeId(info.getNodeId());
        vo.setNodeName(info.getName());
        for (int i = 0; i < dataItemlist.size(); i++) {
            PropUtils.setValue(vo, "value" + i, dataItemlist.get(i).getValue());
        List<DataItem> results = new ArrayList<>();
        dateListMap.forEach((key, value) -> {
            DataItem dataItem = new DataItem();
            dataItem.setDataTime(key);
            //保留四位小数
            double totalValue = value.stream().map(data -> BigDecimal.valueOf(data.getValue()))
                    .reduce(BigDecimal.ZERO, BigDecimal::add).setScale(4, RoundingMode.HALF_UP).doubleValue();
            dataItem.setValue(totalValue);
            results.add(dataItem);
        });
        //根据时间排序
        results.sort(Comparator.comparing(DataItem::getDataTime));
        for (int i = 0; i < dateTimeList.size(); i++) {
            TypeTime typeTime = dateTimeList.get(i);
            Optional<DataItem> dataItem = results.stream().filter(result -> result.getDataTime().equals(typeTime.getDateTime())).findFirst();
            if (dataItem.isPresent()) {
                DataItem item = dataItem.get();
                PropUtils.setValue(vo, "value" + i, item.getValue());
            } else {
                PropUtils.setValue(vo, "value" + i, null);
            }
        }

        return vo;


    }
}