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
package com.iailab.module.model.mdk.predict;
 
import com.baomidou.dynamic.datasource.annotation.DSTransactional;
import com.iailab.module.model.common.enums.CommonDict;
import com.iailab.module.model.mcs.pre.entity.MmItemOutputEntity;
import com.iailab.module.model.mcs.pre.service.MmItemResultService;
import com.iailab.module.model.mcs.sche.service.StAdjustResultService;
import com.iailab.module.model.mdk.factory.ItemEntityFactory;
import com.iailab.module.model.mdk.vo.DataValueVO;
import com.iailab.module.model.mdk.vo.PredictResultVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
 
import java.math.BigDecimal;
import java.util.*;
 
@Service
public class PredictResultHandler {
    @Autowired
    private MmItemResultService mmItemResultService;
 
    @Autowired
    private ItemEntityFactory itemEntityFactory;
 
    @Autowired
    private StAdjustResultService stAdjustResultService;
 
    /**
     * convertToPredictData
     *
     * @param predictResult
     * @return
     */
    public Map<String, List<DataValueVO>> convertToPredictData(PredictResultVO predictResult) {
        Map<String, List<DataValueVO>> resultMap = new HashMap<>();
        Map<MmItemOutputEntity, double[]> predictMatrixs = predictResult.getPredictMatrixs();
        HashMap<String, List<DataValueVO>> predictLists = new HashMap<>();
        for (Map.Entry<MmItemOutputEntity, double[]> entry : predictMatrixs.entrySet()) {
            Integer rows = entry.getValue().length;
            List<DataValueVO> predictDataList = new ArrayList<>();
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(predictResult.getPredictTime());
            for (Integer i = 0; i < rows; i++) {
                DataValueVO predictData = new DataValueVO();
                predictData.setDataTime(calendar.getTime());
                predictData.setDataValue(Double.valueOf(entry.getValue()[i]));
                predictDataList.add(predictData);
 
                calendar.add(Calendar.SECOND, predictResult.getGranularity());
            }
            resultMap.put(entry.getKey().getId(), predictDataList);
            predictLists.put(entry.getKey().getResultstr(), predictDataList);
 
            //处理累计计算
            if (entry.getKey().getIscumulant() == 1) {
                resultMap.put(entry.getKey().getId() + CommonDict.CUMULANT_SUFFIX, new ArrayList<DataValueVO>() {{
                    DataValueVO predictData = new DataValueVO();
                    // 时间 预测时间+预测长度*粒度
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(predictResult.getPredictTime());
                    calendar.add(Calendar.SECOND, predictResult.getGranularity() * (rows - 1));
                    predictData.setDataTime(calendar.getTime());
                    //值 所有值相加/除数
                    BigDecimal sum = BigDecimal.valueOf(Arrays.stream(entry.getValue()).sum());
                    BigDecimal divisor = BigDecimal.valueOf(entry.getKey().getCumuldivisor());
                    predictData.setDataValue(sum.divide(divisor, 2, BigDecimal.ROUND_HALF_UP).doubleValue());
                    add(predictData);
                }});
            }
        }
        predictResult.setPredictLists(predictLists);
        return resultMap;
    }
 
    public Map<String, List<DataValueVO>> convertToPredictData2(PredictResultVO predictResult) {
        Map<String, List<DataValueVO>> predictLists = new HashMap<>();
        if (!CollectionUtils.isEmpty(predictResult.getPredictList())) {
            return predictLists;
        }
        Map<MmItemOutputEntity, double[]> predictMatrixs = predictResult.getPredictMatrixs();
        for (Map.Entry<MmItemOutputEntity, double[]> entry : predictMatrixs.entrySet()) {
            Integer rows = entry.getValue().length;
            List<DataValueVO> predictDataList = new ArrayList<>();
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(predictResult.getPredictTime());
            for (Integer i = 0; i < rows; i++) {
                DataValueVO predictData = new DataValueVO();
                predictData.setDataTime(calendar.getTime());
                predictData.setDataValue(Double.valueOf(entry.getValue()[i]));
                predictDataList.add(predictData);
 
                calendar.add(Calendar.SECOND, predictResult.getGranularity());
            }
            predictLists.put(entry.getKey().getResultstr(), predictDataList);
        }
        return predictLists;
    }
 
    /**
     * savePredictResult
     *
     * @param predictResult
     */
    @DSTransactional
    public void savePredictResult(PredictResultVO predictResult) {
        Map<String, List<DataValueVO>> resultMap = convertToPredictData(predictResult);
        mmItemResultService.savePredictValue(resultMap, predictResult.getLt(), "n", predictResult.getPredictTime());
    }
 
    /**
     * savePredictAdjustResult
     *
     * @param predictResult
     */
    @DSTransactional
    public void savePredictAdjustResult(PredictResultVO predictResult, String adjustValue, String scheduleModelId) {
        Map<String, List<DataValueVO>> resultMap = convertToPredictData(predictResult);
        stAdjustResultService.saveResult(resultMap, predictResult.getPredictTime(), adjustValue, scheduleModelId);
    }
 
    public List<DataValueVO> getPredictValueByItemNo(String itemNo, Date start, Date end) {
        String itemId = itemEntityFactory.getItemByItemNo(itemNo).getId();
        List<MmItemOutputEntity> outputList = itemEntityFactory.getOutPutByItemId(itemId);
        return mmItemResultService.getPredictValue(outputList.get(0).getId(), start, end);
    }
 
    public List<DataValueVO> getPredictValueByItemId(String itemId, Date start, Date end) {
        List<MmItemOutputEntity> outputList = itemEntityFactory.getOutPutByItemId(itemId);
        return mmItemResultService.getPredictValue(outputList.get(0).getId(), start, end);
    }
}