鞍钢鲅鱼圈能源管控系统后端代码
dengzedong
4 天以前 60967a75142a2e813cde3540d29f1fa1701c3bd5
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
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
package com.iailab.module.ansteel.job.task;
 
import com.iailab.module.data.api.point.DataPointApi;
import com.iailab.module.data.api.point.dto.ApiPointValueWriteDTO;
import com.iailab.module.model.api.mcs.McsApi;
import com.iailab.module.model.api.mcs.dto.AlarmMessageRespDTO;
import com.iailab.module.model.api.mcs.dto.ScheduleSuggestRespDTO;
import com.iailab.module.model.api.mdk.MdkApi;
import com.iailab.module.model.api.mdk.dto.MdkScheduleReqDTO;
import com.iailab.module.model.api.mdk.dto.MdkScheduleRespDTO;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
import java.math.BigDecimal;
import java.util.Calendar;
import java.util.Map;
 
/**
 * 执行调度方案定时任务
 */
@Component("runScheduleModuleTask")
public class RunScheduleModuleTask implements ITask {
    private Logger logger = LoggerFactory.getLogger(getClass());
    private String GasCode = "AnSteelGasSchedule"; //日平衡
    private String LdgCode = "AnSteelldgstrategy"; //转炉实时调度
    private String CogCode = "AnSteelcogstrategy"; //焦炉实时调度
    private String BfgCode = "AnSteelbfgstrategy"; //高炉实时调度
    private String suggestionKey = "suggestion"; //建议key
    private String warningKey = "earlywarning"; //预警key
    private String cogLowerKey = "lower_limit_ad_cog_guiwei"; //COG下限key
    private String cogUpperKey = "upper_limit_ad_cog_guiwei"; //COG上限key
    private String bfgLowerKey = "lower_limit_ad_bfg_guiwei"; //BFG下限key
    private String bfgUupperKey = "upper_limit_ad_bfg_guiwei"; //BFG上限key
 
    @Autowired
    private MdkApi mdkApi;
    @Autowired
    private McsApi mcsApi;
    @Autowired
    private DataPointApi dataPointApi;
 
 
    @Override
    public void run(String params) {
        logger.info("runScheduleModuleTask定时任务正在执行,参数为:{}", params);
        try {
            Calendar calendar = Calendar.getInstance();
            calendar.set(Calendar.SECOND, 0);
            calendar.set(Calendar.MILLISECOND, 0);
 
            MdkScheduleReqDTO dto = new MdkScheduleReqDTO();
            dto.setScheduleTime(calendar.getTime());
            dto.setScheduleCode(params);
            MdkScheduleRespDTO mdkScheduleRespDTO = mdkApi.doSchedule(dto);
            logger.info(params + "调度方案执行完成," + mdkScheduleRespDTO);
            logger.info("调度方案结果开始下发");
            if (mdkApi.scheduleModelOut(mdkScheduleRespDTO)) {
                logger.info("调度方案结果下发成功");
            } else {
                logger.error("调度方案结果下发失败");
            }
 
 
            //日平衡调度建议保存
            if (GasCode.equals(params)) {
                Object time8 =  mdkScheduleRespDTO.getResult().get("Time8");
                Object time16 = mdkScheduleRespDTO.getResult().get("Time16");
                Object time24 =  mdkScheduleRespDTO.getResult().get("Time24");
 
                if(time8!=null && StringUtils.isNotBlank(time8.toString())) {
                    ScheduleSuggestRespDTO suggestDto = new ScheduleSuggestRespDTO();
                    suggestDto.setTitle("日平衡建议");
                    suggestDto.setContent(time8.toString());
                    suggestDto.setScheduleObj("GAS");
                    suggestDto.setScheduleTime(dto.getScheduleTime());
                    suggestDto.setCreateTime(calendar.getTime());
                    if (mcsApi.createScheduleSuggest(suggestDto)) {
                        logger.info("日平衡建议{" + time8 + "}保存成功");
                    } else {
                        logger.error("日平衡建议保存失败");
                    }
                }
                if(time16!=null && StringUtils.isNotBlank(time16.toString())) {
                    ScheduleSuggestRespDTO suggestDto = new ScheduleSuggestRespDTO();
                    suggestDto.setTitle("日平衡建议");
                    suggestDto.setContent(time16.toString());
                    suggestDto.setScheduleObj("GAS");
                    suggestDto.setScheduleTime(dto.getScheduleTime());
                    suggestDto.setCreateTime(calendar.getTime());
                    if (mcsApi.createScheduleSuggest(suggestDto)) {
                        logger.info("日平衡建议{" + time16 + "}保存成功");
                    } else {
                        logger.error("日平衡建议保存失败");
                    }
                }
                if(time24!=null && StringUtils.isNotBlank(time24.toString())) {
                    ScheduleSuggestRespDTO suggestDto = new ScheduleSuggestRespDTO();
                    suggestDto.setTitle("日平衡建议");
                    suggestDto.setContent(time24.toString());
                    suggestDto.setScheduleObj("GAS");
                    suggestDto.setScheduleTime(dto.getScheduleTime());
                    suggestDto.setCreateTime(calendar.getTime());
                    if (mcsApi.createScheduleSuggest(suggestDto)) {
                        logger.info("日平衡建议{" + time24 + "}保存成功");
                    } else {
                        logger.error("日平衡建议保存失败");
                    }
                }
            }
            //转炉实时调度
            if (LdgCode.equals(params)) {
                // 建议
                Object suggestion = mdkScheduleRespDTO.getResult().get(suggestionKey);
                if (suggestion != null && StringUtils.isNotBlank(suggestion.toString())) {
                    ScheduleSuggestRespDTO suggestDto = new ScheduleSuggestRespDTO();
                    suggestDto.setTitle("转炉实时调度建议");
                    suggestDto.setContent(suggestion.toString());
                    suggestDto.setScheduleObj("LDG");
                    suggestDto.setScheduleTime(dto.getScheduleTime());
                    suggestDto.setCreateTime(calendar.getTime());
                    if (mcsApi.createScheduleSuggest(suggestDto)) {
                        logger.info("转炉实时调度建议{" + suggestion + "}保存成功");
                    } else {
                        logger.error("转炉实时调度建议保存失败");
                    }
                }
                // 预警
                Object earlywarning = mdkScheduleRespDTO.getResult().get(warningKey);
                if (earlywarning != null && StringUtils.isNotBlank(earlywarning.toString())) {
                    AlarmMessageRespDTO alarmMessageRespDTO = new AlarmMessageRespDTO();
                    alarmMessageRespDTO.setContent(earlywarning.toString());
                    alarmMessageRespDTO.setTitle("转炉实时调度预警");
                    alarmMessageRespDTO.setAlarmObj("LDG");
                    alarmMessageRespDTO.setAlarmTime(dto.getScheduleTime());
                    alarmMessageRespDTO.setCreateTime(calendar.getTime());
 
                    if (mcsApi.createAlarmMessage(alarmMessageRespDTO)) {
                        logger.info("转炉实时调度预警{" + earlywarning + "}保存成功");
                    } else {
                        logger.error("转炉实时调度预警保存失败");
                    }
                }
 
            }
            //焦炉实时调度
            if (CogCode.equals(params)) {
                // 建议
                Object suggestion = mdkScheduleRespDTO.getResult().get(suggestionKey);
                if (suggestion != null && StringUtils.isNotBlank(suggestion.toString())) {
                    ScheduleSuggestRespDTO suggestDto = new ScheduleSuggestRespDTO();
                    suggestDto.setTitle("焦炉实时调度建议");
                    suggestDto.setContent(suggestion.toString());
                    suggestDto.setScheduleObj("COG");
                    suggestDto.setScheduleTime(dto.getScheduleTime());
                    suggestDto.setCreateTime(calendar.getTime());
                    if (mcsApi.createScheduleSuggest(suggestDto)) {
                        logger.info("焦炉实时调度建议{" + suggestion + "}保存成功");
                    } else {
                        logger.error("焦炉实时调度建议保存失败");
                    }
                }
                // 预警
                Object earlywarning = mdkScheduleRespDTO.getResult().get(warningKey);
                if (earlywarning != null && StringUtils.isNotBlank(earlywarning.toString())) {
                    AlarmMessageRespDTO alarmMessageRespDTO = new AlarmMessageRespDTO();
                    alarmMessageRespDTO.setContent(earlywarning.toString());
                    alarmMessageRespDTO.setTitle("焦炉实时调度预警");
                    alarmMessageRespDTO.setAlarmObj("COG");
                    alarmMessageRespDTO.setAlarmTime(dto.getScheduleTime());
                    alarmMessageRespDTO.setCreateTime(calendar.getTime());
 
                    if (mcsApi.createAlarmMessage(alarmMessageRespDTO)) {
                        logger.info("焦炉实时调度预警{" + earlywarning + "}保存成功");
                    } else {
                        logger.error("焦炉实时调度预警保存失败");
                    }
                }
                // 下发上下限
                Object upper = mdkScheduleRespDTO.getResult().get(cogUpperKey);
                if (upper != null) {
                    BigDecimal value = new BigDecimal(upper.toString()).setScale(2,BigDecimal.ROUND_HALF_UP);
                    ApiPointValueWriteDTO pointValueWriteDTO = new ApiPointValueWriteDTO();
                    pointValueWriteDTO.setPointNo("F0000201831");
                    pointValueWriteDTO.setValue(value.doubleValue());
                    dataPointApi.writePointRealValue(pointValueWriteDTO);
                }
                Object lower = mdkScheduleRespDTO.getResult().get(cogLowerKey);
                if (lower != null) {
                    BigDecimal value = new BigDecimal(lower.toString()).setScale(2,BigDecimal.ROUND_HALF_UP);
                    ApiPointValueWriteDTO pointValueWriteDTO = new ApiPointValueWriteDTO();
                    pointValueWriteDTO.setPointNo("F0000201832");
                    pointValueWriteDTO.setValue(value.doubleValue());
                    dataPointApi.writePointRealValue(pointValueWriteDTO);
                }
 
            }
            //高炉实时调度
            if (BfgCode.equals(params)) {
                // 建议
                Object suggestion = mdkScheduleRespDTO.getResult().get(suggestionKey);
                if (suggestion != null && StringUtils.isNotBlank(suggestion.toString())) {
                    ScheduleSuggestRespDTO suggestDto = new ScheduleSuggestRespDTO();
                    suggestDto.setTitle("高炉实时调度建议");
                    suggestDto.setContent(suggestion.toString());
                    suggestDto.setScheduleObj("BFG");
                    suggestDto.setScheduleTime(dto.getScheduleTime());
                    suggestDto.setCreateTime(calendar.getTime());
                    if (mcsApi.createScheduleSuggest(suggestDto)) {
                        logger.info("高炉实时调度建议{" + suggestion + "}保存成功");
                    } else {
                        logger.error("高炉实时调度建议保存失败");
                    }
                }
                // 预警
                Object earlywarning = mdkScheduleRespDTO.getResult().get(warningKey);
                if (earlywarning != null && StringUtils.isNotBlank(earlywarning.toString())) {
                    AlarmMessageRespDTO alarmMessageRespDTO = new AlarmMessageRespDTO();
                    alarmMessageRespDTO.setContent(earlywarning.toString());
                    alarmMessageRespDTO.setTitle("高炉实时调度预警");
                    alarmMessageRespDTO.setAlarmObj("BFG");
                    alarmMessageRespDTO.setAlarmTime(dto.getScheduleTime());
                    alarmMessageRespDTO.setCreateTime(calendar.getTime());
 
                    if (mcsApi.createAlarmMessage(alarmMessageRespDTO)) {
                        logger.info("高炉实时调度预警{" + earlywarning + "}保存成功");
                    } else {
                        logger.error("高炉实时调度预警保存失败");
                    }
                }
                // 下发上下限
                Object upper = mdkScheduleRespDTO.getResult().get(bfgUupperKey);
                if (upper != null) {
                    BigDecimal value = new BigDecimal(upper.toString()).setScale(2,BigDecimal.ROUND_HALF_UP);
                    ApiPointValueWriteDTO pointValueWriteDTO = new ApiPointValueWriteDTO();
                    pointValueWriteDTO.setPointNo("F0000201829");
                    pointValueWriteDTO.setValue(value.doubleValue());
                    dataPointApi.writePointRealValue(pointValueWriteDTO);
                }
                Object lower = mdkScheduleRespDTO.getResult().get(bfgLowerKey);
                if (lower != null) {
                    BigDecimal value = new BigDecimal(lower.toString()).setScale(2,BigDecimal.ROUND_HALF_UP);
                    ApiPointValueWriteDTO pointValueWriteDTO = new ApiPointValueWriteDTO();
                    pointValueWriteDTO.setPointNo("F0000201830");
                    pointValueWriteDTO.setValue(value.doubleValue());
                    dataPointApi.writePointRealValue(pointValueWriteDTO);
                }
 
            }
        } catch (Exception ex) {
            logger.error("runScheduleModuleTask运行异常",ex);
        }
        logger.info("runScheduleModuleTask运行完成");
    }
}