baoshiwei
2025-04-19 5d36e1f987ef21e44ded2e8a1d06c28094ec1e76
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
package com.zhitan.carbonemission.service.impl;
 
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.zhitan.basicdata.domain.SysEnergy;
import com.zhitan.basicdata.mapper.SysEnergyMapper;
import com.zhitan.carbonemission.domain.CarbonEmission;
import com.zhitan.carbonemission.domain.dto.CarbonEmissionDTO;
import com.zhitan.carbonemission.domain.vo.CarbonEmissionRankVO;
import com.zhitan.carbonemission.domain.vo.carbonEmissionYQVO;
import com.zhitan.carbonemission.service.ICarbonEmissionService;
import com.zhitan.common.utils.DateUtils;
import com.zhitan.common.utils.StringUtils;
import com.zhitan.dataitem.mapper.DataItemMapper;
import org.springframework.stereotype.Service;
 
import javax.annotation.Resource;
import java.text.DecimalFormat;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
 
 
/**
 * 【碳排放核算】Service业务层处理
 *
 * @author lsk
 * @date 2024-10-29
 */
@Service
public class CarbonEmissionServiceImpl implements ICarbonEmissionService {
 
    @Resource
    private DataItemMapper dataItemMapper;
 
    @Resource
    private SysEnergyMapper sysEnergyMapper;
 
    private final static String[] YEAR = {"01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"};
    private final static String[] DAY = {"00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23"};
 
    //获取页面上部分的碳排放
    @Override
    public Map<String, Object> getUpCarbonEmission(CarbonEmissionDTO carbonEmissionDTO) {
        Map<String, Object> stringObjectMap = new HashMap<>();
        validate(carbonEmissionDTO, "N");
 
        // 获取查询时间的开始和结束时间
        Date queryTime = carbonEmissionDTO.getDataTime();
        Date beginTime;
        Date endTime;
        switch (carbonEmissionDTO.getTimeType()) {
            case "DAY":
                beginTime = DateUtil.beginOfDay(queryTime);
                endTime = DateUtil.endOfDay(queryTime);
                break;
            case "MONTH":
                beginTime = DateUtil.beginOfMonth(queryTime);
                endTime = DateUtil.endOfMonth(queryTime);
                break;
            case "YEAR":
                beginTime = DateUtil.beginOfYear(queryTime);
                endTime = DateUtil.endOfYear(queryTime);
                break;
            default:
                throw new RuntimeException("时间类型错误");
        }
        Date lastTime = DateUtil.offsetMonth(beginTime, -12);
        Date lastEndTime = DateUtil.offsetMonth(endTime, -12);
        // 获取当前年份和上一年份的碳排放数据
        List<CarbonEmission> upCarbonEmission = dataItemMapper.getUpCarbonEmission(beginTime, endTime, carbonEmissionDTO.getTimeType(), carbonEmissionDTO.getNodeId());
 
        List<CarbonEmission> upLastCarbonEmission = dataItemMapper.getUpCarbonEmission(lastTime, lastEndTime, carbonEmissionDTO.getTimeType(), carbonEmissionDTO.getNodeId());
        List<SysEnergy> sysEnergies = sysEnergyMapper.selectList(null);
        if (ObjectUtil.isEmpty(sysEnergies)) {
            throw new RuntimeException("获取碳排放转换率时出错: 系统能源数据为空");
        }
 
        // 构建能源映射和碳排放数据映射
        Map<String, SysEnergy> energyMap = sysEnergies.stream().collect(Collectors.toMap(SysEnergy::getEnersno, Function.identity()));
        final List<String> energyType = sysEnergies.stream().map(SysEnergy::getEnersno).collect(Collectors.toList());
 
        double allValue = 0.0;
        double allLastValue = 0.0;
 
        List<CarbonEmissionRankVO> upData = new ArrayList<>();
 
        // 计算每种能源的当前值和去年的值
        for (String s : energyType) {
            final double value = getValues(energyMap, upCarbonEmission, s);
            final double lastYearValueNum = getValues(energyMap, upLastCarbonEmission, s);
            allValue += value;
            allLastValue += lastYearValueNum;
            final CarbonEmissionRankVO carbonEmissionRankVO = new CarbonEmissionRankVO();
            carbonEmissionRankVO.setAllEneryType(energyMap.get(s).getEnername());
            carbonEmissionRankVO.setYoyEnery(String.format("%.2f", calculateYOY(value, lastYearValueNum)));
            carbonEmissionRankVO.setTotalEnery(value);
            upData.add(carbonEmissionRankVO);
        }
        CarbonEmissionRankVO carbonEmissionRankVOAll = new CarbonEmissionRankVO();
        carbonEmissionRankVOAll.setAllEneryType("总碳排放量");
        carbonEmissionRankVOAll.setYoyEnery(String.format("%.2f", calculateYOY(allValue, allLastValue)));
        carbonEmissionRankVOAll.setTotalEnery(allValue);
        upData.add(carbonEmissionRankVOAll);
 
        // 计算下方的碳排放并排序
        List<CarbonEmissionRankVO> carbonEmissionRankVOS = calculateDownCarbonEmission(beginTime, endTime, carbonEmissionDTO, energyMap, sysEnergies);
        carbonEmissionRankVOS.sort(Comparator.comparing(CarbonEmissionRankVO::getAllValue).reversed());
        stringObjectMap.put("down", carbonEmissionRankVOS);
        stringObjectMap.put("upData", upData);
 
        return stringObjectMap;
    }
 
    // 计算同比增长率
    private double calculateYOY(double current, double last) {
        if (last != 0.0) {
            return (current - last) / last * 100;
        }
        return 0;
//        return (current - last) / (last == 0.0 ? 1 : last) * 100;
    }
 
    // 计算下方的碳排放
    private List<CarbonEmissionRankVO> calculateDownCarbonEmission(Date beginTime, Date endTime, CarbonEmissionDTO carbonEmissionDTO, Map<String, SysEnergy> energyMap, List<SysEnergy> sysEnergies) {
        List<CarbonEmission> downCarbonEmission = dataItemMapper.getDownCarbonEmission(beginTime, endTime, carbonEmissionDTO.getTimeType(), carbonEmissionDTO.getNodeId());
        List<CarbonEmissionRankVO> carbonEmissionRankVOS = new ArrayList<>();
 
        final List<String> energyType = sysEnergies.stream().map(SysEnergy::getEnersno).collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(downCarbonEmission)) {
            DecimalFormat df = new DecimalFormat("#.00");
            Map<String, List<CarbonEmission>> nodeNameMap = downCarbonEmission.stream().collect(Collectors.groupingBy(CarbonEmission::getNodeName));
 
            nodeNameMap.forEach((k, v) -> {
                CarbonEmissionRankVO rankVO = new CarbonEmissionRankVO();
                rankVO.setNodeName(k);
                double totalValues = 0.0;
 
                // 计算每种能源的值
                for (String s : energyType) {
                    SysEnergy sysEnergy = energyMap.get(s);
                    if (sysEnergy == null || ObjectUtil.isEmpty(sysEnergy.getCoefficient())) {
                        throw new RuntimeException("获取碳排放转换率时出错: 系统能源数据中不存在" + s + "能源类型");
                    }
                    double value = v.stream().filter(ec -> ec.getEnergyId().equals(s))
                            .mapToDouble(CarbonEmission::getValue)
                            .sum();
                    double calculatedValue = Double.parseDouble(df.format(sysEnergy.getCoefficient().doubleValue() * value));
 
                    switch (s) {
                        case "water":
                            rankVO.setWater(calculatedValue);
                            break;
                        case "steam":
                            rankVO.setSteam(calculatedValue);
                            break;
                        case "electric":
                            rankVO.setElectric(calculatedValue);
                            break;
                    }
                    totalValues += calculatedValue;
                }
                rankVO.setAllValue(totalValues);
                carbonEmissionRankVOS.add(rankVO);
            });
        }
 
        return carbonEmissionRankVOS;
    }
 
 
    @Override
    public List<carbonEmissionYQVO> getMiddleCarbonEmission(CarbonEmissionDTO carbonEmissionDTO) {
        validate(carbonEmissionDTO, "Y");
        // 该方法用于计算碳排放总值并返回结果
        Map<String, Object> stringObjectMap = new HashMap<>();
        Date beginTime;
        Date endTime;
        final String timeType = carbonEmissionDTO.getTimeType();
        final Date dataTime = carbonEmissionDTO.getDataTime();
        String timeTypeStr;
        String[] XAxis;
        switch (timeType) {
            case "DAY":
                timeTypeStr = "HOUR";
                XAxis = DAY;
                beginTime = DateUtil.beginOfDay(dataTime);
                endTime = DateUtil.endOfDay(dataTime);
                break;
            case "MONTH":
                timeTypeStr = "DAY";
                XAxis = DateUtils.getDays(dataTime);
                beginTime = DateUtil.beginOfMonth(dataTime);
                endTime = DateUtil.endOfMonth(dataTime);
                break;
            case "YEAR":
                timeTypeStr = "MONTH";
                XAxis = YEAR;
                beginTime = DateUtil.beginOfYear(dataTime);
                endTime = DateUtil.endOfYear(dataTime);
                break;
            default:
                throw new RuntimeException("时间类型错误");
        }
        Date lastTime = DateUtil.offsetMonth(beginTime, -12);
        Date lastEndTime = DateUtil.offsetMonth(endTime, -12);
 
        List<SysEnergy> sysEnergies = sysEnergyMapper.selectList(null);
        if (ObjectUtil.isEmpty(sysEnergies)) {
            throw new RuntimeException("获取碳排放转换率时出错: 系统能源数据为空");
        }
 
        // 构建能源映射和碳排放数据映射
        Map<String, SysEnergy> energyMap = sysEnergies.stream().collect(Collectors.toMap(SysEnergy::getEnersno, Function.identity()));
        final List<String> energyType = sysEnergies.stream().map(SysEnergy::getEnersno).collect(Collectors.toList());
        final List<CarbonEmission> middleCarbonEmission = dataItemMapper.getMiddleCarbonEmission(beginTime, endTime, timeTypeStr, carbonEmissionDTO.getNodeId(), carbonEmissionDTO.getEmissionType());
        final List<CarbonEmission> lastMiddleCarbonEmission = dataItemMapper.getMiddleCarbonEmission(lastTime, lastEndTime, timeTypeStr, carbonEmissionDTO.getNodeId(), carbonEmissionDTO.getEmissionType());
        final Map<String, List<CarbonEmission>> collect = middleCarbonEmission.stream().collect(Collectors.groupingBy(CarbonEmission::getDataTimeStr));
        final Map<String, List<CarbonEmission>> lastCollect = lastMiddleCarbonEmission.stream().collect(Collectors.groupingBy(CarbonEmission::getDataTimeStr));
        List<carbonEmissionYQVO> carbonEmissionYQVOS = new ArrayList<>();
        for (int i = 0; i < XAxis.length; i++) {
            // 当前时间段的碳排放数据
            final List<CarbonEmission> carbonEmissions = collect.get(XAxis[i]);
            // 上一时间段的碳排放数据
            final List<CarbonEmission> lastCarbonEmissions = lastCollect.get(XAxis[i]);
            // 总值
            double totalValue = getValues(energyMap, carbonEmissions, energyType);
            // 上一时间段的总值
            double totalLastValue = getValues(energyMap, lastCarbonEmissions, energyType);
            // 前一次的总值
            double totalFrontValue = (i == 0) ? 0.0 : getValues(energyMap, collect.get(XAxis[i - 1]), energyType);
            final carbonEmissionYQVO carbonEmissionYQVO = new carbonEmissionYQVO(XAxis[i], String.format("%.2f", totalValue), String.format("%.2f", calculateYOY(totalValue, totalLastValue)), String.format("%.2f", calculateYOY(totalValue, totalFrontValue)));
            carbonEmissionYQVOS.add(carbonEmissionYQVO);
        }
        return carbonEmissionYQVOS;
    }
 
    // 验证 CarbonEmissionDTO 对象的各项属性是否有效
    public static void validate(CarbonEmissionDTO carbonEmissionDTO, String type) {
        if (ObjectUtil.isNull(carbonEmissionDTO.getDataTime())) {
            throw new RuntimeException("请选择时间");
        }
        if (StringUtils.isEmpty(carbonEmissionDTO.getTimeType())) {
            throw new RuntimeException("请选择时间类型");
        }
        if (ObjectUtil.isEmpty(carbonEmissionDTO.getNodeId())) {
            throw new RuntimeException("请选择节点");
        }
        if ("Y".equals(type) && ObjectUtil.isEmpty(carbonEmissionDTO.getEmissionType())) {
            throw new RuntimeException("请选择排放类型");
        }
    }
 
 
    public static double getValues(Map<String, SysEnergy> energyMap, List<CarbonEmission> carbonEmissions, List<String> energyTypeList) {
        if (CollectionUtils.isEmpty(carbonEmissions)) {
            return 0.0;
        }
        // 初始化总值
        double allValue = 0.0;
        // 按能源ID分组
        final Map<String, List<CarbonEmission>> energyValueMap = carbonEmissions.stream()
                .collect(Collectors.groupingBy(CarbonEmission::getEnergyId));
 
        for (String energyType : energyTypeList) {
            // 计算每种能源的当前值
            SysEnergy sysEnergy = energyMap.get(energyType);
 
            // 确保能源存在且系数不为空
            if (sysEnergy == null || sysEnergy.getCoefficient() == null) {
                throw new RuntimeException("获取碳排放转换率时出错: 系统能源数据中不存在或系数为空" + energyType + "能源类型");
            }
 
            // 获取对应能源的值
            double value = energyValueMap.getOrDefault(energyType, Collections.emptyList()).stream()
                    .mapToDouble(CarbonEmission::getValue)
                    .sum();
 
            // 直接计算总值,避免冗余的转换
            allValue += sysEnergy.getCoefficient().doubleValue() * value;
        }
        // 格式化最终结果
        return Double.parseDouble(new DecimalFormat("#.00").format(allValue));
    }
 
    public static double getValues(Map<String, SysEnergy> energyMap, List<CarbonEmission> carbonEmissions, String energyType) {
        if (CollectionUtils.isEmpty(carbonEmissions)) {
            return 0.0;
        }
        // 初始化总值
        double allValue = 0.0;
        // 按能源ID分组
        final Map<String, List<CarbonEmission>> energyValueMap = carbonEmissions.stream()
                .collect(Collectors.groupingBy(CarbonEmission::getEnergyId));
        // 计算每种能源的当前值
        SysEnergy sysEnergy = energyMap.get(energyType);
 
        // 确保能源存在且系数不为空
        if (sysEnergy == null || sysEnergy.getCoefficient() == null) {
            throw new RuntimeException("获取碳排放转换率时出错: 系统能源数据中不存在或系数为空" + energyType + "能源类型");
        }
 
        // 获取对应能源的值
        double value = energyValueMap.getOrDefault(energyType, Collections.emptyList()).stream()
                .mapToDouble(CarbonEmission::getValue)
                .sum();
 
        // 直接计算总值,避免冗余的转换
        allValue += sysEnergy.getCoefficient().doubleValue() * value;
 
        // 格式化最终结果
        return Double.parseDouble(new DecimalFormat("#.00").format(allValue));
    }
 
}