arima预测和hst预测更新最新数据；对预报水位去重

guoshilong

2023-08-11 3c096d3cfd56a23e6794f30ccd150bfe19aa4ae8

 skjcmanager/skjcmanager-service/skjcmanager-nky/src/main/java/cn/gistack/nky/service/impl/HstPredictServiceImpl.java

@@ -1,90 +1,166 @@
package cn.gistack.nky.service.impl;

import cn.gistack.nky.entity.ArimaPredict;
import cn.gistack.nky.entity.HstPredict;
import cn.gistack.nky.mapper.HstPredictMapper;
import cn.gistack.nky.requestpojo.HstPredictReqPo;
import cn.gistack.nky.requestpojo.PredictWatersPo;
import cn.gistack.nky.requestpojo.QueryReqPo;
import cn.gistack.nky.resultpojo.DataResChildrenPo;
import cn.gistack.nky.service.IHstPredictService;
import cn.gistack.nky.service.IHsybService;
import cn.gistack.nky.service.INkyService;
import cn.gistack.nky.service.IZtApiService;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.AllArgsConstructor;
import org.springblade.core.mp.support.Condition;
import org.springblade.core.tool.utils.ObjectUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@AllArgsConstructor
@Service
public class HstPredictServiceImpl extends ServiceImpl<HstPredictMapper, HstPredict> implements IHstPredictService {
   @Autowired
   private  INkyService nkyService;
   @Autowired
   private  IZtApiService ztApiService;
   @Autowired
   private  IHsybService hsybService;

   private final INkyService nkyService;
   private final IZtApiService ztApiService;

   @Override
   public void getData(String type) {
      List<DataResChildrenPo> cdList = getCdList(type);

      cdList.forEach(dataResChildrenPo -> {
      List<DataResChildrenPo> collect = cdList.stream().filter(item -> item.getRes_cd().equals("42011640018") || item.getRes_cd().equals("42128140006")).collect(Collectors.toList());
      collect.forEach(dataResChildrenPo -> {
         //循环请求预测结果
         QueryReqPo queryReqPo = new QueryReqPo(dataResChildrenPo,type);
         QueryReqPo queryReqPo = new QueryReqPo(dataResChildrenPo, type);
         //请求预测结果
         HstPredict hstPredict = nkyService.hstQuery(queryReqPo);
         if (hstPredict != null){
         if (hstPredict != null) {
            //存储预测结果至数据库
            save(hstPredict);
         }
      });
   }

   private String resCd = "";

   @Override
   public void predictData(String type) {
      List<DataResChildrenPo> cdList = getCdList(type);
      cdList.forEach(dataResChildrenPo -> {
         HstPredictReqPo arimaPredictReqPo = new HstPredictReqPo(dataResChildrenPo, type);
         //循环预测请求
         nkyService.hstPredict(arimaPredictReqPo);
      //暂时筛选出这两个水库的数据
      List<DataResChildrenPo> collect = cdList.stream().filter(item -> item.getRes_cd().equals("42011640018") || item.getRes_cd().equals("42128140006")).collect(Collectors.toList());


      if (type.equals("1")){
         //渗压
         collect.forEach(dataResChildrenPo -> {
            //所有水库请求预报数据
            if (!resCd.equals(dataResChildrenPo.getRes_cd())) {
               //请求预报水位
               List<List<String>> future = hsybService.getFuture(dataResChildrenPo.getRes_cd());
               resCd = dataResChildrenPo.getRes_cd();
               if (future != null && future.size() > 0) {
                  List<PredictWatersPo> po = new ArrayList<>();
                  future.forEach(item -> {
                     PredictWatersPo predictWatersPo = new PredictWatersPo();
                     //设置时间
                     predictWatersPo.setTime(item.get(0));
                     //设置预测水位
                     predictWatersPo.setValue(Double.parseDouble(item.get(2)));
                     po.add(predictWatersPo);
                  });
                  HstPredictReqPo arimaPredictReqPo = new HstPredictReqPo(dataResChildrenPo, type,po);
                  //循环预测请求
                  nkyService.hstPredict(arimaPredictReqPo);
               }
            }
         });
      }else if (type.equals("2")){
         //渗流
      }else if (type.equals("3") || type.equals("4") || type.equals("5")){
         collect.forEach(dataResChildrenPo -> {
            //所有水库请求预报数据
            if (!resCd.equals(dataResChildrenPo.getRes_cd())) {
               //请求预报水位
               List<List<String>> future = hsybService.getFuture(dataResChildrenPo.getRes_cd());
               resCd = dataResChildrenPo.getRes_cd();
               if (future != null && future.size() > 0) {
                  List<PredictWatersPo> po = new ArrayList<>();
                  future.forEach(item -> {
                     PredictWatersPo predictWatersPo = new PredictWatersPo();
                     //设置时间
                     predictWatersPo.setTime(item.get(0));
                     //设置预测水位
                     predictWatersPo.setValue(Double.parseDouble(item.get(2)));
                     po.add(predictWatersPo);
                  });
                  //循环预测请求(位移一起请求减少请求次数)
                  HstPredictReqPo arimaPredictReqPoX = new HstPredictReqPo(dataResChildrenPo, "3",po);
                  nkyService.hstPredict(arimaPredictReqPoX);

                  HstPredictReqPo arimaPredictReqPoY= new HstPredictReqPo(dataResChildrenPo, "4",po);
                  nkyService.hstPredict(arimaPredictReqPoY);

                  HstPredictReqPo arimaPredictReqPoZ = new HstPredictReqPo(dataResChildrenPo, "5",po);
                  nkyService.hstPredict(arimaPredictReqPoZ);
               }
            }
         });
      }
      resCd = "";
   }

   @Override
   public List<HstPredict> getFutureData(String resCd, String type) {

      List<HstPredict> list = baseMapper.getFutureData(resCd,type);
      list.forEach(hstPredict -> {
         hstPredict.setPredictList(JSON.parse(hstPredict.getPredictList().toString()));
         hstPredict.setPreWaterList(JSON.parse(hstPredict.getPreWaterList().toString()));
      });

      return list;
   }

   @Override
   public boolean save(HstPredict entity) {

      if (ObjectUtil.isEmpty(entity.getCreateTime())){
      if (ObjectUtil.isEmpty(entity.getCreateTime())) {
         return false;
      }

      HstPredict params = new HstPredict();
      params.setDamId(entity.getDamId());
      params.setPointId(entity.getPointId());
      params.setType(entity.getType());
      params.setCreateTime(entity.getCreateTime());

      List<HstPredict> list = list(Condition.getQueryWrapper(params));
      List<HstPredict> list = baseMapper.selectTodayData(entity);

      if (list.size()>0){
         return false;
         //删除该数据，添加最新数据
         baseMapper.deleteById(list.get(0));
         return super.save(entity);
      }else {
         return super.save(entity);
      }
   }

   public  List<DataResChildrenPo> getCdList(String type){
   public List<DataResChildrenPo> getCdList(String type) {
      List<DataResChildrenPo> cdList = new ArrayList<>();
      if (type.equals("1")){
      if (type.equals("1")) {
         //获取渗压测点
         cdList = ztApiService.getSy();
      }else if (type.equals("2")){
      } else if (type.equals("2")) {
         //获取渗流测点
         return null;
      }else if (type.equals("3") || type.equals("4") || type.equals("5")){
      } else if (type.equals("3") || type.equals("4") || type.equals("5")) {
         //获取位移测点
         cdList = ztApiService.getWy();
      }else {
      } else {
         return null;
      }
      return cdList;
   }

}