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
package com.iailab.module.data.point.collection.handler;
 
import com.iailab.module.data.api.point.DataPointApi;
import com.iailab.module.data.api.point.dto.ApiPointDTO;
import com.iailab.module.data.api.point.dto.ApiPointValueQueryDTO;
import com.iailab.module.data.common.enums.CommonConstant;
import com.iailab.module.data.enums.DataPointFreqEnum;
import com.iailab.module.data.influxdb.pojo.InfluxPointValuePOJO;
import com.iailab.module.data.point.collection.PointCollector;
import com.iailab.module.data.point.collection.utils.GenInfluxPointValueUtils;
import com.iailab.module.data.point.common.ExtremaUnitEnum;
import com.iailab.module.data.point.common.ExtremalTypeEnum;
import com.iailab.module.data.point.dto.DaPointDTO;
import com.iailab.module.data.point.service.DaPointService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
 
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.*;
 
/**
 * 极值点处理类
 *
 * @author PanZhibao
 * @Description
 * @createTime 2025年05月14日
 */
@Slf4j
@Component
public class ExtremalHandle {
 
    @Resource
    private DaPointService daPointService;
 
    @Autowired
    @Lazy
    private DataPointApi dataPointApi;
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    public List<InfluxPointValuePOJO> handle(Date collectTime, List<DaPointDTO> dtos, Map<String, Object> dataMap, List<String> listGood, List<String> listBad) {
        List<InfluxPointValuePOJO> result = new ArrayList<>();
        try {
            log.info("极值点处理开始");
            if (CollectionUtils.isEmpty(dtos)) {
                return result;
            }
            dtos.forEach(dto -> {
                try {
                    Object rawValue = singleCompute(dto, collectTime, listGood, listBad);
                    BigDecimal coefficient = dto.getUnittransfactor() == null ? BigDecimal.ONE : dto.getUnittransfactor();
                    BigDecimal calValue = new BigDecimal(rawValue.toString()).multiply(coefficient);
                    InfluxPointValuePOJO pojo = GenInfluxPointValueUtils.getByPoint(dto, calValue);
                    pojo.setTimestamp(GenInfluxPointValueUtils.getByMin(collectTime, DataPointFreqEnum.getEumByCode(dto.getMinfreqid())));
                    dataMap.put(dto.getPointNo(), calValue);
                    result.add(pojo);
                } catch (Exception ex) {
                    ex.printStackTrace();
                    log.info("极值点异常！PointNo=" + dto.getPointNo());
                }
            });
        } catch (Exception ex) {
            ex.printStackTrace();
            log.info("极值点处理异常！");
        }
        return result;
    }
 
    public Map<String, Object> getCurrent(List<String> pointNos) {
        Map<String, Object> data = new HashMap<>();
        List<DaPointDTO> pointExtremalList = daPointService.getExtremalPoint(pointNos);
        if (CollectionUtils.isEmpty(pointExtremalList)) {
            return data;
        }
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.MILLISECOND, 0);
        calendar.set(Calendar.SECOND, 0);
        pointExtremalList.forEach(item -> {
            Object value = CommonConstant.BAD_VALUE;
            if (redisTemplate.hasKey(PointCollector.PV + item.getPointNo())) {
                value = redisTemplate.opsForValue().get(PointCollector.PV + item.getPointNo());
            } else {
                value = singleCompute(item, calendar.getTime(), new ArrayList<>(), new ArrayList<>());
                BigDecimal coefficient = item.getUnittransfactor() == null ? BigDecimal.ONE : item.getUnittransfactor();
                value = new BigDecimal(value.toString()).multiply(coefficient);
            }
            data.put(item.getPointNo(), value);
        });
        return data;
    }
 
    private Object singleCompute(DaPointDTO dto, Date collectTime, List<String> listGood, List<String> listBad) {
        Object value = CommonConstant.BAD_VALUE;
        ApiPointDTO momentPoint = dataPointApi.getInfoByNo(dto.getMomentPoint());
        if (momentPoint == null) {
            if (listBad != null) {
                listBad.add(dto.getPointNo());
            }
            return CommonConstant.BAD_VALUE;
        }
        log.info("极值:" + dto.getPointNo());
 
        // 动态长度
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(collectTime);
        calendar.add(Calendar.SECOND, -1 * DataPointFreqEnum.getEumByCode(momentPoint.getMinfreqid()).getValue());
        Date endTime = calendar.getTime();
        Date startTime = ExtremaUnitEnum.getStartTime(calendar, dto.getLength(), dto.getExtremalUnit());
        ApiPointValueQueryDTO queryDto = new ApiPointValueQueryDTO();
        queryDto.setPointNo(momentPoint.getPointNo());
        queryDto.setStart(startTime);
        queryDto.setEnd(endTime);
        Map<String, Object> eValue = new HashMap<>();
        switch (ExtremalTypeEnum.getEumByCode(dto.getExtremalType())) {
            case MAX:
                eValue = dataPointApi.queryPointMaxValueRange(queryDto);
                break;
            case MIN:
                eValue = dataPointApi.queryPointMinValueRange(queryDto);
                break;
            default:
                break;
        }
        if (eValue != null) {
            value = eValue.get(momentPoint.getPointNo());
            listGood.add(dto.getPointNo());
        }
        return value;
    }
}