guoshilong
2024-01-29 dc6668a538e1ef545fb5437f29f1db8d03af07da
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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
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 cn.gistack.nky.vo.HstPredictVO;
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")) {
            //渗流
            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("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<HstPredictVO> getFutureData(String resCd, String type) {
        List<HstPredictVO> list = new ArrayList<>();
        if (type.equals("3")) {
            list = baseMapper.getFutureDataWy(resCd, type);
        } else {
            list = baseMapper.getFutureData(resCd, type);
        }
 
 
        list.forEach(hstPredict -> {
            if (hstPredict.getPredictList() != null) {
                hstPredict.setPredictList(JSON.parse(hstPredict.getPredictList().toString()));
            } else {
                hstPredict.setPredictList("[]");
            }
            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);
            return false;
        } 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")) {
            //获取渗流测点
            cdList = ztApiService.getSl();
        } else if (type.equals("3") || type.equals("4") || type.equals("5")) {
            //获取位移测点
            cdList = ztApiService.getWy();
        } else {
            return null;
        }
        return cdList;
    }
 
}