package com.iailab.module.model.api;
|
|
import com.alibaba.fastjson.JSON;
|
import com.iailab.framework.common.util.object.ConvertUtils;
|
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.factory.ItemEntityFactory;
|
import com.iailab.module.model.mdk.factory.PredictItemFactory;
|
import com.iailab.module.model.mdk.predict.PredictItemHandler;
|
import com.iailab.module.model.mdk.predict.PredictModuleHandler;
|
import com.iailab.module.model.mdk.predict.PredictResultHandler;
|
import com.iailab.module.model.mdk.schedule.ScheduleModelHandler;
|
import com.iailab.module.model.mdk.vo.DataValueVO;
|
import com.iailab.module.model.mdk.vo.ItemVO;
|
import com.iailab.module.model.mdk.vo.PredictResultVO;
|
import com.iailab.module.model.mdk.vo.ScheduleResultVO;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.validation.annotation.Validated;
|
import org.springframework.web.bind.annotation.RestController;
|
|
import java.util.*;
|
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;
|
|
@Autowired
|
private ItemEntityFactory itemEntityFactory;
|
|
@Autowired
|
private PredictItemFactory predictItemFactory;
|
|
@Autowired
|
private PredictResultHandler predictResultHandler;
|
|
@Autowired
|
private ScheduleModelHandler scheduleModelHandler;
|
|
/**
|
* 按模块预测
|
*
|
* @param reqDTO
|
* @return
|
*/
|
@Override
|
public MdkPredictModuleRespDTO predictModule(MdkPredictReqDTO reqDTO) {
|
MdkPredictModuleRespDTO resp = new MdkPredictModuleRespDTO();
|
resp.setPredictTime(reqDTO.getPredictTime());
|
resp.setModuleType(reqDTO.getModuleType());
|
|
Map<String, MdkPredictItemRespDTO> predictItemRespMap = new HashMap<>();
|
try {
|
if (reqDTO.getPredictTime() == null) {
|
throw new Exception("PredictTime不能为空");
|
}
|
if (reqDTO.getModuleType() == null) {
|
throw new Exception("ModuleType不能为空");
|
}
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTime(reqDTO.getPredictTime());
|
calendar.set(Calendar.MILLISECOND, 0);
|
calendar.set(Calendar.SECOND, 0);
|
reqDTO.setPredictTime(calendar.getTime());
|
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);
|
// 更新Module时间
|
dmModuleService.updatePredictTime(module.getId(), reqDTO.getPredictTime());
|
|
if (reqDTO.getIsResult() == null || !reqDTO.getIsResult()) {
|
return resp;
|
}
|
|
for (Map.Entry<String, PredictResultVO> entry : predictResultMap.entrySet()) {
|
MdkPredictItemRespDTO itemResp = new MdkPredictItemRespDTO();
|
itemResp.setItemId(entry.getKey());
|
itemResp.setPredictTime(reqDTO.getPredictTime());
|
Map<String, List<MdkPredictDataDTO>> itemPredictData = new HashMap<>();
|
|
Map<String, List<DataValueVO>> predictLists = predictResultHandler.convertToPredictData2(entry.getValue());
|
for (Map.Entry<String, List<DataValueVO>> dataListEntry : predictLists.entrySet()) {
|
List<MdkPredictDataDTO> predictData = dataListEntry.getValue().stream().map(t -> {
|
MdkPredictDataDTO dto1 = new MdkPredictDataDTO();
|
dto1.setDataTime(t.getDataTime());
|
dto1.setDataValue(t.getDataValue());
|
return dto1;
|
}).collect(Collectors.toList());
|
itemPredictData.put(dataListEntry.getKey(), predictData);
|
}
|
itemResp.setPredictData(itemPredictData);
|
predictItemRespMap.put(entry.getKey(), itemResp);
|
}
|
}
|
log.info("预测计算结束: " + System.currentTimeMillis());
|
} catch (Exception ex) {
|
ex.printStackTrace();
|
return resp;
|
}
|
resp.setPredictItemRespMap(predictItemRespMap);
|
return resp;
|
}
|
|
/**
|
* 单个预测
|
*
|
* @param reqDTO
|
* @return
|
*/
|
@Override
|
public MdkPredictItemRespDTO predictItem(MdkPredictReqDTO reqDTO) {
|
MdkPredictItemRespDTO resp = new MdkPredictItemRespDTO();
|
|
try {
|
log.info("预测计算开始: " + System.currentTimeMillis());
|
Map<String, List<MdkPredictDataDTO>> predictData = new HashMap<>();
|
ItemVO predictItem = itemEntityFactory.getItemByItemNo(reqDTO.getItemNo());
|
PredictItemHandler predictItemHandler = predictItemFactory.create(predictItem.getId());
|
PredictResultVO predictResult = predictItemHandler.predict(reqDTO.getPredictTime(), predictItem);
|
Map<String, List<DataValueVO>> resultMap = predictResultHandler.convertToPredictData(predictResult);
|
if (!CollectionUtils.isEmpty(resultMap)) {
|
for (Map.Entry<String, List<DataValueVO>> entry : resultMap.entrySet()) {
|
List<MdkPredictDataDTO> data = ConvertUtils.sourceToTarget(entry.getValue(), MdkPredictDataDTO.class);
|
predictData.put(entry.getKey(), data);
|
}
|
}
|
resp.setPredictData(predictData);
|
resp.setItemId(predictItem.getId());
|
resp.setPredictTime(reqDTO.getPredictTime());
|
log.info("预测计算结束: " + System.currentTimeMillis());
|
} catch (Exception ex) {
|
log.info("预测计算异常: " + System.currentTimeMillis(), ex);
|
return resp;
|
}
|
|
return resp;
|
}
|
|
/**
|
* 预测调整
|
*
|
* @param reqDTO
|
* @return
|
*/
|
@Override
|
public Boolean predictAutoAdjust(MdkPredictReqDTO reqDTO) {
|
|
|
return true;
|
}
|
|
/**
|
* 执行调度模型
|
*
|
* @param reqDTO
|
* @return
|
*/
|
@Override
|
public MdkScheduleRespDTO doSchedule(MdkScheduleReqDTO reqDTO) {
|
MdkScheduleRespDTO resp = new MdkScheduleRespDTO();
|
resp.setScheduleCode(reqDTO.getScheduleCode());
|
resp.setScheduleTime(reqDTO.getScheduleTime());
|
try {
|
log.info("调度计算开始: " + System.currentTimeMillis());
|
ScheduleResultVO scheduleResult = scheduleModelHandler.doSchedule(reqDTO.getModelCode(), reqDTO.getScheduleTime());
|
resp.setResult(scheduleResult.getResult());
|
log.info("预测计算结束: " + System.currentTimeMillis());
|
} catch (Exception ex) {
|
log.info("调度计算异常: " + System.currentTimeMillis());
|
ex.printStackTrace();
|
return resp;
|
}
|
return resp;
|
}
|
}
|
