chenluhua1980
6 天以前 dd4d7532a85ae70e303117a80dd65b3bc803d457
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
#ifndef ALARM_MANAGER_H
#define ALARM_MANAGER_H
 
#include <string>
#include <vector>
#include <mutex>
#include <unordered_map>
#include "Database.h"
 
struct AlarmInfo {
    std::string strUnitID;
    std::string strUnitNo;
    int nAlarmLevel;
    int nAlarmCode;
    int nAlarmID;
    std::string strAlarmText;
    std::string strDescription;
};
 
struct AlarmData {
    int nId;                       // 错误码
    int nSeverityLevel;            // 报警等级
    int nDeviceId;                 // 设备ID
    int nUnitId;                   // 单元ID
    std::string strDeviceName;     // 设备名称
    std::string strUnitName;       // 单元名称
    std::string strDescription;    // 描述
    std::string strStartTime;      // 开始时间
    std::string strEndTime;        // 结束时间
};
 
using AlarmInfoMap = std::unordered_map<int, AlarmInfo>;
using AlarmDataMap = std::unordered_map<int, AlarmData>;
 
class AlarmManager {
public:
    /**
     * 获取单例实例
     * @return AlarmManager实例的引用
     */
    static AlarmManager& getInstance();
 
    /**
     * 初始化报警表
     * @return 成功返回true,失败返回false
     */
    bool initAlarmTable();
 
    /**
     * 销毁报警表
     */
    void termAlarmTable();
 
    /**
     * 销毁报警表
     * @return 成功返回true,失败返回false
     */
    bool destroyAlarmTable();
 
    /**
    * 插入模拟数据
    */
    void insertMockData();
 
    /**
     * 添加报警
     * @param alarmData 报警数据的结构体
     * @param alarmEventId 最近插入的 alarm_event_id
     * @return 成功返回true,失败返回false
     */
    bool addAlarm(const AlarmData& alarmData, int& alarmEventId);
 
    /**
     * 查询所有报警数据
     * @return 包含所有报警数据的结构体
     */
    std::vector<AlarmData> getAllAlarms();
 
    /**
     * 根据报警ID查询报警
     * @param id 报警ID
     * @return 包含筛选后报警数据的结构体
     */
    std::vector<AlarmData> getAlarmsById(const std::string& id);
 
    /**
     * 根据描述查询报警
     * @param description 报警描述的筛选条件
     * @return 包含筛选后报警数据的结构体
     */
    std::vector<AlarmData> getAlarmsByDescription(const std::string& description);
 
    /**
     * 根据时间范围查询报警
     * @param startTime 起始时间
     * @param endTime 结束时间
     * @return 包含查询结果的报警数据
     */
    std::vector<AlarmData> getAlarmsByTimeRange(const std::string& startTime, const std::string& endTime);
 
    /**
    * 根据ID和时间范围查询报警
     * @param id 报警ID
     * @param startTime 起始时间
     * @param endTime 结束时间
     * @return 包含查询结果的报警数据
     */
    std::vector<AlarmData> getAlarmsByIdAndTimeRange(const std::string& id, const std::string& startTime, const std::string& endTime);
 
    /**
     * 获取报警数据
     * @param startPosition 起始位置
     * @param count 获取的记录数量
     * @return 包含查询结果的报警数据
     */
    std::vector<AlarmData> getAlarms(int startPosition, int count);
    std::vector<AlarmData> getActiveAlarms(int recentHours = 12);
 
    /**
     * 筛选报警数据
     * @param keyword 关键字筛选条件
     * @param startTime 起始时间筛选条件
     * @param endTime 结束时间筛选条件
     * @param pageNumber 页码
     * @param pageSize 每页记录数
     * @return 包含筛选后报警数据的结构体
     */
    std::vector<AlarmData> getFilteredAlarms(const std::string& keyword, const std::string& startTime, const std::string& endTime, int pageNumber, int pageSize);
 
    /**
     * 获取符合条件的报警总数
     * @param keyword 关键字筛选条件
     * @param startTime 起始时间筛选条件
     * @param endTime 结束时间筛选条件
     * @return 符合条件的报警总数
     */
    int getTotalAlarmCount(const std::string& keyword, const std::string& startTime, const std::string& endTime);
 
    /**
     * 更新报警结束时间
     * @param id 报警ID
     * @param severityLevel 报警等级筛选条件
     * @param deviceId 设备ID
     * @param unitId 单元ID
     * @param description 报警描述
     * @param startTime 报警开始时间
     * @param newEndTime 新的报警结束时间
     * @return 成功返回true,失败返回false
     */
    bool updateAlarmEndTime(
        const std::string& id,
        const std::string& severityLevel,
        const std::string& deviceId,
        const std::string& unitId,
        const std::string& description,
        const std::string& startTime,
        const std::string& newEndTime);
 
    /**
     * 清理旧报警
     * @param daysToKeep 保留的天数
     * @param deviceId 设备ID
     * @param unitId 单元ID
     */
    void cleanOldAlarms(int daysToKeep = 30, const std::string& deviceId = "", const std::string& unitId = "");
 
    /**
    * 通过设备ID获取设备名称
    * @param deviceId 设备ID
    * @return 成功返回设备名称,失败返回空
    */
    std::string getDeviceNameById(int deviceId);
 
    /**
    * 通过设备ID和单元ID获取单元名称
    * @param deviceId 设备ID
    * @param unitId 单元ID
    * @return 成功返回单元名称,失败返回空
    */
    std::string getUnitNameById(int deviceId, int unitId);
 
    /**
    * 获取最近插入的 alarm_event_id
    * @return 失败返回-1,成功返回最近插入的 alarm_event_id
    */
    int getLastInsertId();
 
    /**
    * 通过事件id解除报警(更新结束时间)
    * @param alarmEventId 事件ID
    * @param endTime 结束时间
    * @return 成功返回true,失败返回false
    */
    bool clearAlarmByEventId(int alarmEventId, const std::string& endTime);
 
    /**
    * 通过多个属性查找并解除报警(更新结束时间)
    * @param nId 报警ID
    * @param nSeverityLevel 报警等级
    * @param nDeviceId 设备ID
    * @param nUnitId 单元ID
    * @param strDescription 描述
    * @param endTime 结束时间
    * @return 成功返回true,失败返回false
    */
    bool clearAlarmByAttributes(int nId, int nDeviceId, int nUnitId, const std::string& endTime);
 
    /**
     * 读取报警文件
     * @param filename 文件名
     * @return 成功返回true,失败返回false
     */
    bool readAlarmFile(const std::string& filename);
 
    /**
     * 保存报警文件
     * @param filename 文件名
     * @return 成功返回true,失败返回false
     */
    bool saveAlarmFile(const std::string& filename);
 
    /**
     * 通过报警ID查询报警信息
     * @param nAlarmID 报警ID
     * @return 报警信息的指针
     */
    const AlarmInfo* getAlarmInfoByID(int nAlarmID) const;
 
    /**
    * 通过多个报警ID查询对应的报警信息
    * @param alarmIDs 多个报警ID
    * @return 返回多个报警信息
    */
    std::vector<AlarmInfo> getAlarmsInfoByIDs(const std::vector<int>& alarmIDs) const;
 
private:
    AlarmManager();
    ~AlarmManager();
 
    // 禁止拷贝和赋值
    AlarmManager(const AlarmManager&) = delete;
    AlarmManager& operator=(const AlarmManager&) = delete;
 
    BL::Database* m_pDB;
    AlarmInfoMap m_mapAlarm;
    AlarmDataMap m_mapCache;
    static std::mutex m_mutex;
};
 
#endif // ALARM_MANAGER_H