guoshilong
2023-08-11 3c096d3cfd56a23e6794f30ccd150bfe19aa4ae8
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
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 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;
 
@Service
public class HstPredictServiceImpl extends ServiceImpl<HstPredictMapper, HstPredict> implements IHstPredictService {
    @Autowired
    private  INkyService nkyService;
    @Autowired
    private  IZtApiService ztApiService;
    @Autowired
    private  IHsybService hsybService;
 
 
    @Override
    public void getData(String type) {
        List<DataResChildrenPo> cdList = getCdList(type);
        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);
            //请求预测结果
            HstPredict hstPredict = nkyService.hstQuery(queryReqPo);
            if (hstPredict != null) {
                //存储预测结果至数据库
                save(hstPredict);
            }
        });
    }
 
    private String resCd = "";
 
    @Override
    public void predictData(String type) {
        List<DataResChildrenPo> cdList = getCdList(type);
        //暂时筛选出这两个水库的数据
        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())) {
            return false;
        }
 
        List<HstPredict> list = baseMapper.selectTodayData(entity);
 
        if (list.size()>0){
            //删除该数据,添加最新数据
            baseMapper.deleteById(list.get(0));
            return super.save(entity);
        }else {
            return super.save(entity);
        }
    }
 
    public List<DataResChildrenPo> getCdList(String type) {
        List<DataResChildrenPo> cdList = new ArrayList<>();
        if (type.equals("1")) {
            //获取渗压测点
            cdList = ztApiService.getSy();
        } else if (type.equals("2")) {
            //获取渗流测点
            return null;
        } else if (type.equals("3") || type.equals("4") || type.equals("5")) {
            //获取位移测点
            cdList = ztApiService.getWy();
        } else {
            return null;
        }
        return cdList;
    }
 
}