1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "net_stats_database_helper.h"
17
18 #include <cstdlib>
19 #include <filesystem>
20
21 #include "net_manager_constants.h"
22 #include "net_mgr_log_wrapper.h"
23 #include "net_stats_constants.h"
24 #include "net_stats_database_defines.h"
25 #include "net_stats_info.h"
26 #include "net_stats_rdb.h"
27
28 namespace OHOS {
29 namespace NetManagerStandard {
30 using namespace NetStatsDatabaseDefines;
31 namespace {
32 [[maybe_unused]] const int32_t RDB_VERSION_0 = 0;
33 const int32_t RDB_VERSION_1 = 1;
34 const int32_t RDB_VERSION_2 = 2;
35 const std::string DATABASE_NAME = "/data/service/el1/public/netmanager/net_stats_notice_freq.db";
36 const std::string NETMANAGER_DB_SIMID_STATS_TABLE = "uid_stats_infos";
37 const std::string SQL_TABLE_COLUMS = std::string(
38 "simId INTEGER NOT NULL PRIMARY KEY, "
39 "monthWarningdate INTEGER NOT NULL, dayNontificationdate INTEGER NOT NULL, monthNontificationdate "
40 "INTEGER NOT NULL, monthWarningState INTEGER NOT NULL, dayNontificationState "
41 "INTEGER NOT NULL, monNontificationState INTEGER NOT NULL"
42 );
43 } // namespace
44
OnCreate(NativeRdb::RdbStore & rdbStore)45 int NetStatsRDB::RdbDataOpenCallback::OnCreate(NativeRdb::RdbStore &rdbStore)
46 {
47 return NETMANAGER_SUCCESS;
48 }
49
50
OnUpgrade(NativeRdb::RdbStore & store,int oldVersion,int newVersion)51 int NetStatsRDB::RdbDataOpenCallback::OnUpgrade(NativeRdb::RdbStore &store, int oldVersion, int newVersion)
52 {
53 NETMGR_LOG_I("OnUpgrade, oldVersion: %{public}d, newVersion: %{public}d", oldVersion, newVersion);
54 while (oldVersion < newVersion) {
55 UpgradeDbVersionTo(store, ++oldVersion);
56 }
57 return NETMANAGER_SUCCESS;
58 }
59
60 /* 这里删除了AddIsBreaker */
UpgradeDbVersionTo(NativeRdb::RdbStore & store,int newVersion)61 void NetStatsRDB::RdbDataOpenCallback::UpgradeDbVersionTo(NativeRdb::RdbStore &store, int newVersion)
62 {
63 switch (newVersion) {
64 case RDB_VERSION_1:
65 // When upgrading the rdb version to 1, the is_broker field was added, but some users failed the upgrade.
66 case RDB_VERSION_2:
67 break;
68 default:
69 NETMGR_LOG_E("no such newVersion: %{public}d", newVersion);
70 }
71 }
72
GetRdbStore()73 int32_t NetStatsRDB::GetRdbStore()
74 {
75 if (rdbStore_ != nullptr) {
76 return NETMANAGER_SUCCESS;
77 }
78
79 int errCode = NETMANAGER_SUCCESS;
80 NativeRdb::RdbStoreConfig config(DATABASE_NAME);
81 NetStatsRDB::RdbDataOpenCallback helper;
82 rdbStore_ = NativeRdb::RdbHelper::GetRdbStore(config, RDB_VERSION_2, helper, errCode);
83 if (rdbStore_ == nullptr) {
84 NETMGR_LOG_E("RDB create failed, errCode: %{public}d", errCode);
85 return NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL;
86 }
87
88 return NETMANAGER_SUCCESS;
89 }
90
InitRdbStore()91 int32_t NetStatsRDB::InitRdbStore()
92 {
93 int32_t ret = GetRdbStore();
94 if (ret != NETMANAGER_SUCCESS) {
95 return ret;
96 }
97
98 std::string createTable =
99 "CREATE TABLE IF NOT EXISTS " + NETMANAGER_DB_SIMID_STATS_TABLE + " (" + SQL_TABLE_COLUMS + ")";
100 int ret0 = rdbStore_->ExecuteSql(createTable);
101
102 NETMGR_LOG_I("InitRdbStore ret = %{public}d", ret0);
103 return NETMANAGER_SUCCESS;
104 }
105
InsertData(NetStatsData state)106 int32_t NetStatsRDB::InsertData(NetStatsData state)
107 {
108 NETMGR_LOG_I("InsertData");
109 int32_t ret = GetRdbStore();
110 if (ret != NETMANAGER_SUCCESS) {
111 NETMGR_LOG_E("error: rdbStore_ is nullptr");
112 return NETMANAGER_ERROR;
113 }
114
115 NativeRdb::ValuesBucket statsValues;
116 /*simIDd*/
117 statsValues.PutInt(NetStatsRdbFiledConst::FILED_SIMID, state.simId);
118 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_W, state.monWarningDate);
119 statsValues.PutInt(NetStatsRdbFiledConst::FILED_DAY_N, state.dayNoticeDate);
120 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_N, state.monNoticeDate);
121 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_W_S, state.monWarningState);
122 statsValues.PutInt(NetStatsRdbFiledConst::FILED_DAY_N_S, state.dayNoticeState);
123 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_N_S, state.monNoticeState);
124 int64_t id = 0;
125 ret = rdbStore_->Insert(id, NETMANAGER_DB_SIMID_STATS_TABLE, statsValues);
126 if (ret != NativeRdb::E_OK) {
127 ret = UpdateBySimId(state.simId, state);
128 if (ret != NETMANAGER_SUCCESS) {
129 NETMGR_LOG_E("Update operation failed, result is %{public}d", ret);
130 return NETMANAGER_ERROR;
131 }
132 }
133
134 return NETMANAGER_SUCCESS;
135 }
136
DeleteBySimId(int32_t simId)137 int32_t NetStatsRDB::DeleteBySimId(int32_t simId)
138 {
139 NETMGR_LOG_I("DeleteBySimId");
140 int32_t ret = GetRdbStore();
141 if (ret != NETMANAGER_SUCCESS) {
142 NETMGR_LOG_E("error: rdbStore_ is nullptr");
143 return NETMANAGER_ERROR;
144 }
145
146 int32_t deletedRows = -1;
147 std::vector<std::string> whereArgs;
148 NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_SIMID_STATS_TABLE};
149 rdbPredicate.EqualTo(NetStatsRdbFiledConst::FILED_SIMID, std::to_string(simId));
150 int32_t result = rdbStore_->Delete(deletedRows, rdbPredicate);
151 if (result != NativeRdb::E_OK) {
152 NETMGR_LOG_E("delete operation failed, result is %{public}d", result);
153 return result;
154 }
155
156 return deletedRows;
157 }
158
UpdateBySimId(int32_t simId,NetStatsData state)159 int32_t NetStatsRDB::UpdateBySimId(int32_t simId, NetStatsData state)
160 {
161 NETMGR_LOG_I("UpdateBySimId, simId:%{public}d", simId);
162 int32_t ret = GetRdbStore();
163 if (ret != NETMANAGER_SUCCESS) {
164 NETMGR_LOG_E("error: rdbStore_ is nullptr");
165 return NETMANAGER_ERROR;
166 }
167
168 NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_SIMID_STATS_TABLE};
169 NETMGR_LOG_I("begin EqualTo");
170 rdbPredicate.EqualTo(NetStatsRdbFiledConst::FILED_SIMID, std::to_string(simId));
171 NETMGR_LOG_I("end EqualTo");
172
173 NativeRdb::ValuesBucket statsValues;
174 statsValues.PutInt(NetStatsRdbFiledConst::FILED_SIMID, simId);
175 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_W, state.monWarningDate);
176 statsValues.PutInt(NetStatsRdbFiledConst::FILED_DAY_N, state.dayNoticeDate);
177 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_N, state.monNoticeDate);
178 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_W_S, state.monWarningState);
179 statsValues.PutInt(NetStatsRdbFiledConst::FILED_DAY_N_S, state.dayNoticeState);
180 statsValues.PutInt(NetStatsRdbFiledConst::FILED_MON_N_S, state.monNoticeState);
181
182 int32_t rowId = -1;
183 int32_t result = rdbStore_->Update(rowId, statsValues, rdbPredicate);
184 if (result != NativeRdb::E_OK) {
185 NETMGR_LOG_E("Update operation failed. Result %{public}d", result);
186 return result;
187 }
188
189 return NETMANAGER_SUCCESS;
190 }
191
QueryAll()192 std::vector<NetStatsData> NetStatsRDB::QueryAll()
193 {
194 NETMGR_LOG_I("QueryAll");
195 std::vector<NetStatsData> result;
196 int32_t ret = GetRdbStore();
197 if (ret != NETMANAGER_SUCCESS) {
198 NETMGR_LOG_E("error: rdbStore_ is nullptr");
199 return result;
200 }
201
202 NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_SIMID_STATS_TABLE};
203 std::vector<std::string> whereArgs;
204 auto queryResultSet = rdbStore_->Query(rdbPredicate, whereArgs);
205 if (queryResultSet == nullptr) {
206 return result;
207 }
208
209 bool isAtLastRow = false;
210 queryResultSet->IsAtLastRow(isAtLastRow);
211 while (!queryResultSet->GoToNextRow()) {
212 NetStatsData stats;
213 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_ZERO, stats.simId);
214 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_ONE, stats.monWarningDate);
215 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_TWO, stats.dayNoticeDate);
216 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_THR, stats.monNoticeDate);
217 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_FUR, stats.monWarningState);
218 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_FW, stats.dayNoticeState);
219 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_SIX, stats.monNoticeState);
220 result.emplace_back(stats);
221 }
222 return result;
223 }
224
QueryBySimId(int simId,NetStatsData & simStats)225 int32_t NetStatsRDB::QueryBySimId(int simId, NetStatsData& simStats)
226 {
227 NETMGR_LOG_I("QueryBySimId simId:%{public}d", simId);
228 int32_t ret = GetRdbStore();
229 if (ret != NETMANAGER_SUCCESS) {
230 NETMGR_LOG_E("error: rdbStore_ is nullptr");
231 return NETMANAGER_ERROR;
232 }
233
234 NativeRdb::RdbPredicates rdbPredicate{NETMANAGER_DB_SIMID_STATS_TABLE};
235 rdbPredicate.EqualTo(NetStatsRdbFiledConst::FILED_SIMID, simId);
236
237 std::vector<std::string> whereArgs;
238 auto queryResultSet = rdbStore_->Query(rdbPredicate, whereArgs);
239 if (queryResultSet == nullptr) {
240 NETMGR_LOG_E("QueryBySimId error");
241 return NETMANAGER_ERROR;
242 }
243
244 int32_t rowCount = 0;
245 ret = queryResultSet->GetRowCount(rowCount);
246 if (ret != OHOS::NativeRdb::E_OK) {
247 NETMGR_LOG_E("query setting failed, get row count failed, name:%{public}d, ret:%{public}d", simId, ret);
248 return ret;
249 }
250 if (rowCount == 0) {
251 NETMGR_LOG_E("query setting name:%{public}d, num is 0", simId);
252 return NETMANAGER_ERROR;
253 }
254
255 while (!queryResultSet->GoToNextRow()) {
256 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_ONE, simStats.monWarningDate);
257 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_TWO, simStats.dayNoticeDate);
258 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_THR, simStats.monNoticeDate);
259 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_FUR, simStats.monWarningState);
260 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_FW, simStats.dayNoticeState);
261 queryResultSet->GetInt(NetStatsRdbFiledConst::FILED_COLUMN_INDEX_SIX, simStats.monNoticeState);
262 if (simStats.simId == simId) {
263 return NETMANAGER_SUCCESS;
264 }
265 }
266
267 return NETMANAGER_ERROR;
268 }
269
270 } // namespace NetManagerStandard
271 } // namespace OHOS
272