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
package com.iailab.module.model.api;
 
import com.alibaba.fastjson.JSON;
import com.iailab.module.model.api.mdk.MdkApi;
import com.iailab.module.model.api.mdk.dto.*;
import com.iailab.framework.common.pojo.CommonResult;
import com.iailab.module.model.mcs.pre.entity.DmModuleEntity;
import com.iailab.module.model.mcs.pre.service.DmModuleService;
import com.iailab.module.model.mcs.pre.service.MmPredictItemService;
import com.iailab.module.model.mdk.predict.PredictModuleHandler;
import com.iailab.module.model.mdk.vo.ItemVO;
import com.iailab.module.model.mdk.vo.PredictResultVO;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
 
import javax.validation.Valid;
 
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
 
import static com.iailab.framework.common.pojo.CommonResult.error;
import static com.iailab.framework.common.pojo.CommonResult.success;
 
/**
 * @author PanZhibao
 * @Description
 * @createTime 2024年08月26日
 */
@Slf4j
@RestController
@Validated
public class MdkApiImpl implements MdkApi {
 
    @Autowired
    private DmModuleService dmModuleService;
 
    @Autowired
    private MmPredictItemService mmPredictItemService;
 
    @Autowired
    private PredictModuleHandler predictModuleHandler;
 
    /**
     * 按模块预测
     *
     * @param reqDTO
     * @return
     */
    @Override
    public CommonResult<MdkPredictModuleRespDTO> predictModule(MdkPredictReqDTO reqDTO) {
        MdkPredictModuleRespDTO resp = new MdkPredictModuleRespDTO();
        Map<String, MdkPredictItemRespDTO> predictItemRespMap = new HashMap<>();
        try {
            if (reqDTO.getPredictTime() == null) {
                throw new Exception("PredictTime不能为空");
            }
            if (reqDTO.getModuleType() == null) {
                throw new Exception("ModuleType不能为空");
            }
            log.info("预测参数：" + JSON.toJSONString(reqDTO));
            MdkPredictModuleRespDTO result = new MdkPredictModuleRespDTO();
            result.setPredictTime(reqDTO.getPredictTime());
            result.setModuleType(reqDTO.getModuleType());
            List<DmModuleEntity> moduleList = dmModuleService.getModuleByModuleType(reqDTO.getModuleType());
            log.info("预测计算开始: " + System.currentTimeMillis());
            for (DmModuleEntity module : moduleList) {
                int intervalTime = 0;
                if (module.getPredicttime() != null) {
                    intervalTime = (int) (reqDTO.getPredictTime().getTime() - module.getPredicttime().getTime()) / (1000 * 60);
                }
                List<ItemVO> predictItemList = mmPredictItemService.getByModuleId(module.getId());
                Map<String, PredictResultVO> predictResultMap = predictModuleHandler.predict(predictItemList, reqDTO.getPredictTime(), intervalTime);
                for (Map.Entry<String, PredictResultVO> entry : predictResultMap.entrySet()) {
                    List<MdkPredictDataDTO> predictData = entry.getValue().getPredictList().stream().map(t-> {
                        MdkPredictDataDTO dto1 = new MdkPredictDataDTO();
                        dto1.setDataTime(t.getDataTime());
                        dto1.setDataValue(t.getDataValue());
                        return dto1;
                    }).collect(Collectors.toList());
                    MdkPredictItemRespDTO itemResp = new MdkPredictItemRespDTO();
                    itemResp.setItemId(entry.getValue().getPredictId());
                    itemResp.setPredictData(predictData);
                    predictItemRespMap.put(entry.getKey(), itemResp);
                }
            }
            log.info("预测计算结束: " + System.currentTimeMillis());
        } catch (Exception ex) {
            return error(999, ex.getMessage());
        }
        resp.setPredictItemRespMap(predictItemRespMap);
        return success(resp);
    }
 
    /**
     * 单个预测
     *
     * @param reqDTO
     * @return
     */
    @Override
    public CommonResult<MdkPredictItemRespDTO> predictItem(@Valid @RequestBody MdkPredictReqDTO reqDTO) {
        MdkPredictItemRespDTO resp = new MdkPredictItemRespDTO();
 
        return success(resp);
    }
 
    /**
     * 预测调整
     *
     * @param reqDTO
     * @return
     */
    @Override
    public CommonResult<Boolean> predictAutoAdjust(@Valid @RequestBody MdkPredictReqDTO reqDTO) {
 
 
        return success(true);
    }
 
    /**
     * 执行调度模型
     *
     * @param reqDTO
     * @return
     */
    @Override
    public CommonResult<MdkScheduleRespDTO> doSchedule(@Valid @RequestBody MdkScheduleReqDTO reqDTO) {
        MdkScheduleRespDTO resp = new MdkScheduleRespDTO();
 
        return success(resp);
    }
}