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 "device_policies_storage_rdb.h"
17 #include "edm_log.h"
18 #include "edm_rdb_filed_const.h"
19 
20 namespace OHOS {
21 namespace EDM {
22 std::shared_ptr<DevicePoliciesStorageRdb> DevicePoliciesStorageRdb::instance_ = nullptr;
23 std::mutex DevicePoliciesStorageRdb::mutexLock_;
24 
DevicePoliciesStorageRdb()25 DevicePoliciesStorageRdb::DevicePoliciesStorageRdb()
26 {
27     CreateDeviceAdminPoliciesTable();
28     CreateDeviceCombinedPoliciesTable();
29 }
30 
CreateDeviceAdminPoliciesTable()31 void DevicePoliciesStorageRdb::CreateDeviceAdminPoliciesTable()
32 {
33     EDMLOGI("DevicePoliciesStorageRdb::CreateDeviceAdminPoliciesTable.");
34     std::string createTableSql = "CREATE TABLE IF NOT EXISTS ";
35     createTableSql.append(EdmRdbFiledConst::DEVICE_ADMIN_POLICIES_RDB_TABLE_NAME + " (")
36         .append(EdmRdbFiledConst::FILED_ID + " INTEGER PRIMARY KEY AUTOINCREMENT,")
37         .append(EdmRdbFiledConst::FILED_USER_ID + " INTEGER NOT NULL,")
38         .append(EdmRdbFiledConst::FILED_ADMIN_NAME + " TEXT NOT NULL,")
39         .append(EdmRdbFiledConst::FILED_POLICY_NAME + " TEXT,")
40         .append(EdmRdbFiledConst::FILED_POLICY_VALUE + " TEXT);");
41     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
42     if (edmRdbDataManager != nullptr) {
43         edmRdbDataManager->CreateTable(createTableSql);
44     } else {
45         EDMLOGE("DevicePoliciesStorageRdb::create database device_admin_policies failed.");
46     }
47 }
48 
CreateDeviceCombinedPoliciesTable()49 void DevicePoliciesStorageRdb::CreateDeviceCombinedPoliciesTable()
50 {
51     EDMLOGI("DevicePoliciesStorageRdb::CreateDeviceCombinedPoliciesTable.");
52     std::string createTableSql = "CREATE TABLE IF NOT EXISTS ";
53     createTableSql.append(EdmRdbFiledConst::DEVICE_COMBINED_POLICIES_RDB_TABLE_NAME + " (")
54         .append(EdmRdbFiledConst::FILED_ID + " INTEGER PRIMARY KEY AUTOINCREMENT,")
55         .append(EdmRdbFiledConst::FILED_USER_ID + " INTEGER NOT NULL,")
56         .append(EdmRdbFiledConst::FILED_POLICY_NAME + " TEXT,")
57         .append(EdmRdbFiledConst::FILED_POLICY_VALUE + " TEXT);");
58     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
59     if (edmRdbDataManager != nullptr) {
60         edmRdbDataManager->CreateTable(createTableSql);
61     } else {
62         EDMLOGE("DevicePoliciesStorageRdb::create database device_combined_policies failed.");
63     }
64 }
65 
GetInstance()66 std::shared_ptr<DevicePoliciesStorageRdb> DevicePoliciesStorageRdb::GetInstance()
67 {
68     if (instance_ == nullptr) {
69         std::lock_guard<std::mutex> lock(mutexLock_);
70         if (instance_ == nullptr) {
71             instance_ = std::make_shared<DevicePoliciesStorageRdb>();
72         }
73     }
74     return instance_;
75 }
76 
InsertAdminPolicy(int32_t userId,const std::string & adminName,const std::string & policyName,const std::string & policyValue)77 bool DevicePoliciesStorageRdb::InsertAdminPolicy(int32_t userId, const std::string &adminName,
78     const std::string &policyName, const std::string &policyValue)
79 {
80     EDMLOGD("DevicePoliciesStorageRdb::InsertAdminPolicy.");
81     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
82     if (edmRdbDataManager == nullptr) {
83         EDMLOGE("DevicePoliciesStorageRdb::InsertAdminPolicy get edmRdbDataManager failed.");
84         return false;
85     }
86     // insert into device_admin_policies(user_id, admin_name, policy_name, policy_value) values(?, ?, ?, ?)
87     NativeRdb::ValuesBucket valuesBucket;
88     valuesBucket.PutInt(EdmRdbFiledConst::FILED_USER_ID, userId);
89     valuesBucket.PutString(EdmRdbFiledConst::FILED_ADMIN_NAME, adminName);
90     valuesBucket.PutString(EdmRdbFiledConst::FILED_POLICY_NAME, policyName);
91     valuesBucket.PutString(EdmRdbFiledConst::FILED_POLICY_VALUE, policyValue);
92     return edmRdbDataManager->Insert(EdmRdbFiledConst::DEVICE_ADMIN_POLICIES_RDB_TABLE_NAME, valuesBucket);
93 }
94 
UpdateAdminPolicy(int32_t userId,const std::string & adminName,const std::string & policyName,const std::string & policyValue)95 bool DevicePoliciesStorageRdb::UpdateAdminPolicy(int32_t userId, const std::string &adminName,
96     const std::string &policyName, const std::string &policyValue)
97 {
98     EDMLOGD("DevicePoliciesStorageRdb::UpdateAdminPolicy.");
99     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
100     if (edmRdbDataManager == nullptr) {
101         EDMLOGE("DevicePoliciesStorageRdb::UpdateAdminPolicy get edmRdbDataManager failed.");
102         return false;
103     }
104     // update device_admin_policies set policy_value=? where user_id=? and admin_name=? and policy_name=?
105     NativeRdb::ValuesBucket valuesBucket;
106     valuesBucket.PutString(EdmRdbFiledConst::FILED_POLICY_VALUE, policyValue);
107     NativeRdb::AbsRdbPredicates predicates(EdmRdbFiledConst::DEVICE_ADMIN_POLICIES_RDB_TABLE_NAME);
108     predicates.EqualTo(EdmRdbFiledConst::FILED_USER_ID, std::to_string(userId));
109     predicates.EqualTo(EdmRdbFiledConst::FILED_ADMIN_NAME, adminName);
110     predicates.EqualTo(EdmRdbFiledConst::FILED_POLICY_NAME, policyName);
111     return edmRdbDataManager->Update(valuesBucket, predicates);
112 }
113 
DeleteAdminPolicy(int32_t userId,const std::string & adminName,const std::string & policyName)114 bool DevicePoliciesStorageRdb::DeleteAdminPolicy(int32_t userId, const std::string &adminName,
115     const std::string &policyName)
116 {
117     EDMLOGD("AdminPoliciesStorageRdb::DeleteAdminPolicy.");
118     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
119     if (edmRdbDataManager == nullptr) {
120         EDMLOGE("DevicePoliciesStorageRdb::DeleteAdminPolicy get edmRdbDataManager failed.");
121         return false;
122     }
123     // delete from device_admin_policies where user_id=? and admin_name=? and policy_name=?
124     NativeRdb::AbsRdbPredicates predicates(EdmRdbFiledConst::DEVICE_ADMIN_POLICIES_RDB_TABLE_NAME);
125     predicates.EqualTo(EdmRdbFiledConst::FILED_USER_ID, std::to_string(userId));
126     predicates.EqualTo(EdmRdbFiledConst::FILED_ADMIN_NAME, adminName);
127     predicates.EqualTo(EdmRdbFiledConst::FILED_POLICY_NAME, policyName);
128     return edmRdbDataManager->Delete(predicates);
129 }
130 
QueryAdminPolicy(int32_t userId,std::unordered_map<std::string,PolicyItemsMap> & adminPolicies,std::unordered_map<std::string,AdminValueItemsMap> & policyAdmins)131 bool DevicePoliciesStorageRdb::QueryAdminPolicy(int32_t userId, std::unordered_map<std::string,
132     PolicyItemsMap> &adminPolicies, std::unordered_map<std::string, AdminValueItemsMap> &policyAdmins)
133 {
134     EDMLOGD("DevicePoliciesStorageRdb::QueryAdminPolicy.");
135     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
136     if (edmRdbDataManager == nullptr) {
137         EDMLOGE("DevicePoliciesStorageRdb::QueryAdminPolicy get edmRdbDataManager failed.");
138         return false;
139     }
140     // select * from device_admin_policies
141     NativeRdb::AbsRdbPredicates predicates(EdmRdbFiledConst::DEVICE_ADMIN_POLICIES_RDB_TABLE_NAME);
142     predicates.EqualTo(EdmRdbFiledConst::FILED_USER_ID, std::to_string(userId));
143     auto resultSet = edmRdbDataManager->Query(predicates, std::vector<std::string>());
144     if (resultSet == nullptr) {
145         EDMLOGD("DevicePoliciesStorageRdb::QueryAdminPolicy failed.");
146         return false;
147     }
148     int resultSetNum = resultSet->GoToFirstRow();
149     while (resultSetNum == NativeRdb::E_OK) {
150         std::string adminName;
151         std::string policyName;
152         std::string policyValue;
153         resultSet->GetString(EdmRdbFiledConst::FILED_COLUMN_INDEX_TWO, adminName);
154         resultSet->GetString(EdmRdbFiledConst::FILED_COLUMN_INDEX_THREE, policyName);
155         resultSet->GetString(EdmRdbFiledConst::FILED_COLUMN_INDEX_FOUR, policyValue);
156         PraseAdminPolicies(adminName, policyName, policyValue, adminPolicies);
157         PrasePolicyAdmins(adminName, policyName, policyValue, policyAdmins);
158         resultSetNum = resultSet->GoToNextRow();
159     };
160     resultSet->Close();
161     return true;
162 }
163 
PraseAdminPolicies(const std::string & adminName,const std::string & policyName,const std::string & policyValue,std::unordered_map<std::string,PolicyItemsMap> & adminPolicies)164 void DevicePoliciesStorageRdb::PraseAdminPolicies(const std::string &adminName, const std::string &policyName,
165     const std::string &policyValue, std::unordered_map<std::string, PolicyItemsMap> &adminPolicies)
166 {
167     auto iter = adminPolicies.find(adminName);
168     if (iter == adminPolicies.end()) {
169         PolicyItemsMap itemMap;
170         itemMap.insert(std::pair<std::string, std::string>(policyName, policyValue));
171         adminPolicies.insert(std::pair<std::string, PolicyItemsMap>(adminName, itemMap));
172         return;
173     }
174     iter->second.insert(std::pair<std::string, std::string>(policyName, policyValue));
175 }
176 
PrasePolicyAdmins(const std::string & adminName,const std::string & policyName,const std::string & policyValue,std::unordered_map<std::string,AdminValueItemsMap> & policyAdmins)177 void DevicePoliciesStorageRdb::PrasePolicyAdmins(const std::string &adminName, const std::string &policyName,
178     const std::string &policyValue, std::unordered_map<std::string, AdminValueItemsMap> &policyAdmins)
179 {
180     auto iter = policyAdmins.find(policyName);
181     if (iter == policyAdmins.end()) {
182         AdminValueItemsMap adminValueItem;
183         adminValueItem.insert(std::pair<std::string, std::string>(adminName, policyValue));
184         policyAdmins.insert(std::pair<std::string, AdminValueItemsMap>(policyName, adminValueItem));
185         return;
186     }
187     iter->second.insert(std::pair<std::string, std::string>(adminName, policyValue));
188 }
189 
InsertCombinedPolicy(int32_t userId,const std::string & policyName,const std::string & policyValue)190 bool DevicePoliciesStorageRdb::InsertCombinedPolicy(int32_t userId, const std::string &policyName,
191     const std::string &policyValue)
192 {
193     EDMLOGD("DevicePoliciesStorageRdb::InsertCombinedPolicy.");
194     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
195     if (edmRdbDataManager == nullptr) {
196         EDMLOGE("DevicePoliciesStorageRdb::InsertCombinedPolicy get edmRdbDataManager failed.");
197         return false;
198     }
199     // insert into device_combined_policies(user_id, policy_name, policy_value) values(?, ?, ?)
200     NativeRdb::ValuesBucket valuesBucket;
201     valuesBucket.PutInt(EdmRdbFiledConst::FILED_USER_ID, userId);
202     valuesBucket.PutString(EdmRdbFiledConst::FILED_POLICY_NAME, policyName);
203     valuesBucket.PutString(EdmRdbFiledConst::FILED_POLICY_VALUE, policyValue);
204     return edmRdbDataManager->Insert(EdmRdbFiledConst::DEVICE_COMBINED_POLICIES_RDB_TABLE_NAME,
205         valuesBucket);
206 }
207 
UpdateCombinedPolicy(int32_t userId,const std::string & policyName,const std::string & policyValue)208 bool DevicePoliciesStorageRdb::UpdateCombinedPolicy(int32_t userId, const std::string &policyName,
209     const std::string &policyValue)
210 {
211     EDMLOGD("DevicePoliciesStorageRdb::UpdateCombinedPolicy.");
212     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
213     if (edmRdbDataManager == nullptr) {
214         EDMLOGE("DevicePoliciesStorageRdb::UpdateCombinedPolicy get edmRdbDataManager failed.");
215         return false;
216     }
217     // update device_combined_policies set policy_value=? where user_id=? and policy_name=?
218     NativeRdb::ValuesBucket valuesBucket;
219     valuesBucket.PutString(EdmRdbFiledConst::FILED_POLICY_VALUE, policyValue);
220     NativeRdb::AbsRdbPredicates predicates(EdmRdbFiledConst::DEVICE_COMBINED_POLICIES_RDB_TABLE_NAME);
221     predicates.EqualTo(EdmRdbFiledConst::FILED_USER_ID, std::to_string(userId));
222     predicates.EqualTo(EdmRdbFiledConst::FILED_POLICY_NAME, policyName);
223     return edmRdbDataManager->Update(valuesBucket, predicates);
224 }
225 
DeleteCombinedPolicy(int32_t userId,const std::string & policyName)226 bool DevicePoliciesStorageRdb::DeleteCombinedPolicy(int32_t userId, const std::string &policyName)
227 {
228     EDMLOGD("DevicePoliciesStorageRdb::DeleteCombinedPolicy.");
229     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
230     if (edmRdbDataManager == nullptr) {
231         EDMLOGE("DevicePoliciesStorageRdb::DeleteCombinedPolicy get edmRdbDataManager failed.");
232         return false;
233     }
234     // delete from device_combined_policies where user_id=? and policy_name=?
235     NativeRdb::AbsRdbPredicates predicates(EdmRdbFiledConst::DEVICE_COMBINED_POLICIES_RDB_TABLE_NAME);
236     predicates.EqualTo(EdmRdbFiledConst::FILED_USER_ID, std::to_string(userId));
237     predicates.EqualTo(EdmRdbFiledConst::FILED_POLICY_NAME, policyName);
238     return edmRdbDataManager->Delete(predicates);
239 }
240 
QueryCombinedPolicy(int32_t userId,PolicyItemsMap & itemsMap)241 bool DevicePoliciesStorageRdb::QueryCombinedPolicy(int32_t userId, PolicyItemsMap &itemsMap)
242 {
243     EDMLOGD("DevicePoliciesStorageRdb::QueryCombinedPolicy.");
244     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
245     if (edmRdbDataManager == nullptr) {
246         EDMLOGE("DevicePoliciesStorageRdb::QueryCombinedPolicy get edmRdbDataManager failed.");
247         return false;
248     }
249     // select * from device_combined_policies
250     NativeRdb::AbsRdbPredicates predicates(EdmRdbFiledConst::DEVICE_COMBINED_POLICIES_RDB_TABLE_NAME);
251     predicates.EqualTo(EdmRdbFiledConst::FILED_USER_ID, std::to_string(userId));
252     auto resultSet = edmRdbDataManager->Query(predicates, std::vector<std::string>());
253     if (resultSet == nullptr) {
254         EDMLOGD("DevicePoliciesStorageRdb::QueryCombinedPolicy failed.");
255         return false;
256     }
257     int resultSetNum = resultSet->GoToFirstRow();
258     while (resultSetNum == NativeRdb::E_OK) {
259         std::string policyName;
260         std::string policyValue;
261         resultSet->GetString(EdmRdbFiledConst::FILED_COLUMN_INDEX_TWO, policyName);
262         resultSet->GetString(EdmRdbFiledConst::FILED_COLUMN_INDEX_THREE, policyValue);
263         itemsMap.insert(std::pair<std::string, std::string>(policyName, policyValue));
264         resultSetNum = resultSet->GoToNextRow();
265     };
266     resultSet->Close();
267     return true;
268 }
269 
QueryAllUserId(std::vector<int32_t> & userIds)270 bool DevicePoliciesStorageRdb::QueryAllUserId(std::vector<int32_t> &userIds)
271 {
272     EDMLOGD("DevicePoliciesStorageRdb::QueryAllUserId.");
273     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
274     if (edmRdbDataManager == nullptr) {
275         EDMLOGE("DevicePoliciesStorageRdb::QueryAllUserId get edmRdbDataManager failed.");
276         return false;
277     }
278     // select user_id from device_admin_policies
279     NativeRdb::AbsRdbPredicates predicates(EdmRdbFiledConst::DEVICE_ADMIN_POLICIES_RDB_TABLE_NAME);
280     predicates.Distinct();
281     std::vector<std::string> queryColumns = { EdmRdbFiledConst::FILED_USER_ID };
282     auto resultSet = edmRdbDataManager->Query(predicates, queryColumns);
283     if (resultSet == nullptr) {
284         EDMLOGD("DevicePoliciesStorageRdb::QueryAllUserId failed.");
285         return false;
286     }
287     int resultSetNum = resultSet->GoToFirstRow();
288     while (resultSetNum == NativeRdb::E_OK) {
289         int32_t userId = 0;
290         resultSet->GetInt(EdmRdbFiledConst::FILED_COLUMN_INDEX_ZERO, userId);
291         userIds.push_back(userId);
292         resultSetNum = resultSet->GoToNextRow();
293     };
294     resultSet->Close();
295     return true;
296 }
297 } // namespace EDM
298 } // namespace OHOS