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 "admin_policies_storage_rdb.h"
17 
18 #include "edm_constants.h"
19 #include "edm_log.h"
20 #include "edm_rdb_filed_const.h"
21 
22 namespace OHOS {
23 namespace EDM {
24 std::shared_ptr<AdminPoliciesStorageRdb> AdminPoliciesStorageRdb::instance_ = nullptr;
25 std::mutex AdminPoliciesStorageRdb::mutexLock_;
26 
AdminPoliciesStorageRdb()27 AdminPoliciesStorageRdb::AdminPoliciesStorageRdb()
28 {
29     EDMLOGD("AdminPoliciesStorageRdb::create database.");
30     std::string createTableSql = "CREATE TABLE IF NOT EXISTS ";
31     createTableSql.append(EdmRdbFiledConst::ADMIN_POLICIES_RDB_TABLE_NAME + " (")
32         .append(EdmRdbFiledConst::FILED_ID + " INTEGER PRIMARY KEY AUTOINCREMENT,")
33         .append(EdmRdbFiledConst::FILED_USER_ID + " INTEGER NOT NULL,")
34         .append(EdmRdbFiledConst::FILED_ADMIN_TYPE + " INTEGER NOT NULL,")
35         .append(EdmRdbFiledConst::FILED_PACKAGE_NAME + " TEXT NOT NULL,")
36         .append(EdmRdbFiledConst::FILED_CLASS_NAME + " TEXT NOT NULL,")
37         .append(EdmRdbFiledConst::FILED_ENT_NAME + " TEXT,")
38         .append(EdmRdbFiledConst::FILED_ENT_DESC + " TEXT,")
39         .append(EdmRdbFiledConst::FILED_PERMISSIONS + " TEXT,")
40         .append(EdmRdbFiledConst::FILED_SUBSCRIBE_EVENTS + " TEXT,")
41         .append(EdmRdbFiledConst::FILED_PARENT_ADMIN + " TEXT,")
42         .append(EdmRdbFiledConst::FILED_IS_DEBUG + " INTEGER,")
43         .append(EdmRdbFiledConst::FILED_ACCESSIBLE_POLICIES + " TEXT);");
44     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
45     if (edmRdbDataManager != nullptr) {
46         edmRdbDataManager->CreateTable(createTableSql);
47     } else {
48         EDMLOGE("AdminPoliciesStorageRdb::create database admin_policies failed.");
49     }
50 }
51 
GetInstance()52 std::shared_ptr<AdminPoliciesStorageRdb> AdminPoliciesStorageRdb::GetInstance()
53 {
54     if (instance_ == nullptr) {
55         std::lock_guard<std::mutex> lock(mutexLock_);
56         if (instance_ == nullptr) {
57             instance_ = std::make_shared<AdminPoliciesStorageRdb>();
58         }
59     }
60     return instance_;
61 }
62 
InsertAdmin(int32_t userId,const Admin & admin)63 bool AdminPoliciesStorageRdb::InsertAdmin(int32_t userId, const Admin &admin)
64 {
65     EDMLOGD("AdminPoliciesStorageRdb::Insert data start.");
66     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
67     if (edmRdbDataManager == nullptr) {
68         EDMLOGE("AdminPoliciesStorageRdb::InsertAdmin get edmRdbDataManager failed.");
69         return false;
70     }
71     // insert into admin_policies(user_id, admin_type, package_name, class_name, ent_name, ent_desc, permissions,
72     //     parent_admin, is_debug, accessible_policies) values(?, ?, ?, ?, ?, ?, ?, ?, ?)
73     return edmRdbDataManager->Insert(EdmRdbFiledConst::ADMIN_POLICIES_RDB_TABLE_NAME,
74         CreateInsertValuesBucket(userId, admin));
75 }
76 
UpdateAdmin(int32_t userId,const Admin & admin)77 bool AdminPoliciesStorageRdb::UpdateAdmin(int32_t userId, const Admin &admin)
78 {
79     EDMLOGD("AdminPoliciesStorageRdb::Insert data start.");
80     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
81     if (edmRdbDataManager == nullptr) {
82         EDMLOGE("AdminPoliciesStorageRdb::UpdateAdmin get edmRdbDataManager failed.");
83         return false;
84     }
85     // update admin_policies set admin_type=?, ent_name=?, ent_desc=?, permissions=?, accessible_policies=?
86     //     where user_id=? and package_name=?
87     NativeRdb::AbsRdbPredicates predicates(EdmRdbFiledConst::ADMIN_POLICIES_RDB_TABLE_NAME);
88     predicates.EqualTo(EdmRdbFiledConst::FILED_USER_ID, std::to_string(userId));
89     predicates.EqualTo(EdmRdbFiledConst::FILED_PACKAGE_NAME, admin.adminInfo_.packageName_);
90     NativeRdb::ValuesBucket valuesBucket;
91     CreateUpdateValuesBucket(userId, admin, valuesBucket);
92     return edmRdbDataManager->Update(valuesBucket, predicates);
93 }
94 
CreateInsertValuesBucket(int32_t userId,const Admin & admin)95 NativeRdb::ValuesBucket AdminPoliciesStorageRdb::CreateInsertValuesBucket(int32_t userId, const Admin &admin)
96 {
97     NativeRdb::ValuesBucket valuesBucket;
98     CreateUpdateValuesBucket(userId, admin, valuesBucket);
99     valuesBucket.PutInt(EdmRdbFiledConst::FILED_USER_ID, userId);
100     valuesBucket.PutString(EdmRdbFiledConst::FILED_PACKAGE_NAME, admin.adminInfo_.packageName_);
101     valuesBucket.PutString(EdmRdbFiledConst::FILED_CLASS_NAME, admin.adminInfo_.className_);
102     valuesBucket.PutString(EdmRdbFiledConst::FILED_PARENT_ADMIN, admin.adminInfo_.parentAdminName_);
103     valuesBucket.PutBool(EdmRdbFiledConst::FILED_IS_DEBUG, admin.adminInfo_.isDebug_);
104     return valuesBucket;
105 }
106 
CreateUpdateValuesBucket(int32_t userId,const Admin & admin,NativeRdb::ValuesBucket & valuesBucket)107 void AdminPoliciesStorageRdb::CreateUpdateValuesBucket(int32_t userId, const Admin &admin,
108     NativeRdb::ValuesBucket &valuesBucket)
109 {
110     valuesBucket.PutInt(EdmRdbFiledConst::FILED_ADMIN_TYPE, static_cast<int>(admin.adminInfo_.adminType_));
111     if (!admin.adminInfo_.entInfo_.enterpriseName.empty()) {
112         valuesBucket.PutString(EdmRdbFiledConst::FILED_ENT_NAME, admin.adminInfo_.entInfo_.enterpriseName);
113     }
114     if (!admin.adminInfo_.entInfo_.description.empty()) {
115         valuesBucket.PutString(EdmRdbFiledConst::FILED_ENT_DESC, admin.adminInfo_.entInfo_.description);
116     }
117     Json::StreamWriterBuilder builder;
118     builder.settings_["indentation"] = "";
119     Json::Value permissionJson;
120     for (const auto &permission : admin.adminInfo_.permission_) {
121         permissionJson.append(permission);
122     }
123     valuesBucket.PutString(EdmRdbFiledConst::FILED_PERMISSIONS, Json::writeString(builder, permissionJson));
124     if (admin.adminInfo_.adminType_ == AdminType::VIRTUAL_ADMIN) {
125         Json::Value policiesJson;
126         for (const auto &policy : admin.adminInfo_.accessiblePolicies_) {
127             policiesJson.append(policy);
128         }
129         valuesBucket.PutString(EdmRdbFiledConst::FILED_ACCESSIBLE_POLICIES, Json::writeString(builder, policiesJson));
130     }
131 }
132 
DeleteAdmin(int32_t userId,const std::string & packageName)133 bool AdminPoliciesStorageRdb::DeleteAdmin(int32_t userId, const std::string &packageName)
134 {
135     EDMLOGD("AdminPoliciesStorageRdb::DeleteAdmin.");
136     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
137     if (edmRdbDataManager == nullptr) {
138         EDMLOGE("AdminPoliciesStorageRdb::DeleteAdmin get edmRdbDataManager failed.");
139         return false;
140     }
141     // delete from admin_policies where user_id=? and package_name=?
142     NativeRdb::AbsRdbPredicates predicates(EdmRdbFiledConst::ADMIN_POLICIES_RDB_TABLE_NAME);
143     predicates.EqualTo(EdmRdbFiledConst::FILED_USER_ID, std::to_string(userId));
144     predicates.EqualTo(EdmRdbFiledConst::FILED_PACKAGE_NAME, packageName);
145     return edmRdbDataManager->Delete(predicates);
146 }
147 
UpdateEntInfo(int32_t userId,const std::string & packageName,const EntInfo & entInfo)148 bool AdminPoliciesStorageRdb::UpdateEntInfo(int32_t userId, const std::string &packageName, const EntInfo &entInfo)
149 {
150     EDMLOGD("AdminPoliciesStorageRdb::UpdateEntInfo.");
151     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
152     if (edmRdbDataManager == nullptr) {
153         EDMLOGE("AdminPoliciesStorageRdb::UpdateEntInfo get edmRdbDataManager failed.");
154         return false;
155     }
156     // update admin_policies set ent_name=?, ent_desc=? where user_id=? and package_name=?
157     NativeRdb::ValuesBucket valuesBucket;
158     valuesBucket.PutString(EdmRdbFiledConst::FILED_ENT_NAME, entInfo.enterpriseName);
159     valuesBucket.PutString(EdmRdbFiledConst::FILED_ENT_DESC, entInfo.description);
160 
161     NativeRdb::AbsRdbPredicates predicates(EdmRdbFiledConst::ADMIN_POLICIES_RDB_TABLE_NAME);
162     predicates.EqualTo(EdmRdbFiledConst::FILED_USER_ID, std::to_string(userId));
163     predicates.EqualTo(EdmRdbFiledConst::FILED_PACKAGE_NAME, packageName);
164     return edmRdbDataManager->Update(valuesBucket, predicates);
165 }
166 
UpdateManagedEvents(int32_t userId,const std::string & packageName,const std::vector<ManagedEvent> & managedEvents)167 bool AdminPoliciesStorageRdb::UpdateManagedEvents(int32_t userId, const std::string &packageName,
168     const std::vector<ManagedEvent> &managedEvents)
169 {
170     EDMLOGD("AdminPoliciesStorageRdb::UpdateManagedEvents.");
171     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
172     if (edmRdbDataManager == nullptr) {
173         EDMLOGE("AdminPoliciesStorageRdb::UpdateManagedEvents get edmRdbDataManager failed.");
174         return false;
175     }
176     // update admin_policies set subscribe_events=? where user_id=? and package_name=?
177     NativeRdb::ValuesBucket valuesBucket;
178     Json::StreamWriterBuilder builder;
179     builder.settings_["indentation"] = "";
180     Json::Value managedEventsJson;
181     for (const auto &it : managedEvents) {
182         managedEventsJson.append(static_cast<uint32_t>(it));
183     }
184     valuesBucket.PutString(EdmRdbFiledConst::FILED_SUBSCRIBE_EVENTS, Json::writeString(builder, managedEventsJson));
185 
186     NativeRdb::AbsRdbPredicates predicates(EdmRdbFiledConst::ADMIN_POLICIES_RDB_TABLE_NAME);
187     predicates.EqualTo(EdmRdbFiledConst::FILED_USER_ID, std::to_string(userId));
188     predicates.EqualTo(EdmRdbFiledConst::FILED_PACKAGE_NAME, packageName);
189     return edmRdbDataManager->Update(valuesBucket, predicates);
190 }
191 
QueryAllAdmin()192 std::unordered_map<int32_t, std::vector<std::shared_ptr<Admin>>> AdminPoliciesStorageRdb::QueryAllAdmin()
193 {
194     EDMLOGD("AdminPoliciesStorageRdb::QueryAllAdmin.");
195     auto edmRdbDataManager = EdmRdbDataManager::GetInstance();
196     std::unordered_map<int32_t, std::vector<std::shared_ptr<Admin>>> admins;
197     if (edmRdbDataManager == nullptr) {
198         EDMLOGE("AdminPoliciesStorageRdb::QueryAllAdmin get edmRdbDataManager failed.");
199         return admins;
200     }
201     // select * from admin_policies
202     NativeRdb::AbsRdbPredicates predicates(EdmRdbFiledConst::ADMIN_POLICIES_RDB_TABLE_NAME);
203     auto resultSet = edmRdbDataManager->Query(predicates, std::vector<std::string>());
204     if (resultSet == nullptr) {
205         return admins;
206     }
207     int resultSetNum = resultSet->GoToFirstRow();
208     while (resultSetNum == NativeRdb::E_OK) {
209         std::shared_ptr<Admin> item = std::make_shared<Admin>();
210         int32_t userId = 0;
211         resultSet->GetInt(EdmRdbFiledConst::FILED_COLUMN_INDEX_ONE, userId);
212         SetAdminItems(resultSet, item);
213         if (admins.find(userId) != admins.end()) {
214             admins[userId].push_back(item);
215         } else {
216             std::vector<std::shared_ptr<Admin>> adminItems{item};
217             admins[userId] = adminItems;
218         }
219         resultSetNum = resultSet->GoToNextRow();
220     }
221     resultSet->Close();
222     return admins;
223 }
224 
SetAdminItems(std::shared_ptr<NativeRdb::ResultSet> resultSet,std::shared_ptr<Admin> item)225 void AdminPoliciesStorageRdb::SetAdminItems(std::shared_ptr<NativeRdb::ResultSet> resultSet,
226     std::shared_ptr<Admin> item)
227 {
228     if (item == nullptr) {
229         EDMLOGE("AdminPoliciesStorageRdb::SetAdminItems failed.");
230         return;
231     }
232     int32_t adminType = 0;
233     resultSet->GetInt(EdmRdbFiledConst::FILED_COLUMN_INDEX_TWO, adminType);
234     item->adminInfo_.adminType_ = static_cast<AdminType>(adminType);
235     resultSet->GetString(EdmRdbFiledConst::FILED_COLUMN_INDEX_THREE, item->adminInfo_.packageName_);
236     resultSet->GetString(EdmRdbFiledConst::FILED_COLUMN_INDEX_FOUR, item->adminInfo_.className_);
237     resultSet->GetString(EdmRdbFiledConst::FILED_COLUMN_INDEX_FIVE, item->adminInfo_.entInfo_.enterpriseName);
238     resultSet->GetString(EdmRdbFiledConst::FILED_COLUMN_INDEX_SIX, item->adminInfo_.entInfo_.description);
239     std::string permissionStr;
240     resultSet->GetString(EdmRdbFiledConst::FILED_COLUMN_INDEX_SEVEN, permissionStr);
241     if (!permissionStr.empty() && permissionStr != "null") {
242         Json::Value permissionJson;
243         ConvertStrToJson(permissionStr, permissionJson);
244         for (uint32_t i = 0; i < permissionJson.size(); i++) {
245             if (permissionJson[i].isString()) {
246                 item->adminInfo_.permission_.push_back(permissionJson[i].asString());
247             }
248         }
249     }
250     std::string managedEventsStr;
251     resultSet->GetString(EdmRdbFiledConst::FILED_COLUMN_INDEX_EIGHT, managedEventsStr);
252     if (!managedEventsStr.empty() && managedEventsStr != "null") {
253         Json::Value managedEventsJson;
254         ConvertStrToJson(managedEventsStr, managedEventsJson);
255         for (uint32_t i = 0; i < managedEventsJson.size(); i++) {
256             if (managedEventsJson[i].isUInt()) {
257                 item->adminInfo_.managedEvents_.push_back(static_cast<ManagedEvent>(managedEventsJson[i].asUInt()));
258             }
259         }
260     }
261     resultSet->GetString(EdmRdbFiledConst::FILED_COLUMN_INDEX_NINE, item->adminInfo_.parentAdminName_);
262     int isDebug = 0;
263     resultSet->GetInt(EdmRdbFiledConst::FILED_COLUMN_INDEX_TEN, isDebug);
264     item->adminInfo_.isDebug_ = isDebug != 0;
265     std::string policiesStr;
266     resultSet->GetString(EdmRdbFiledConst::FILED_COLUMN_INDEX_ELEVEN, policiesStr);
267     if (!policiesStr.empty() && policiesStr != "null") {
268         Json::Value policiesJson;
269         ConvertStrToJson(policiesStr, policiesJson);
270         for (uint32_t i = 0; i < policiesJson.size(); i++) {
271             if (policiesJson[i].isString()) {
272                 item->adminInfo_.accessiblePolicies_.emplace_back(policiesJson[i].asString());
273             }
274         }
275     }
276 }
277 
ConvertStrToJson(const std::string & str,Json::Value & json)278 void AdminPoliciesStorageRdb::ConvertStrToJson(const std::string &str, Json::Value &json)
279 {
280     Json::String err;
281     Json::CharReaderBuilder builder;
282     std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
283     reader->parse(str.c_str(), str.c_str() + str.length(), &json, &err);
284 }
285 } // namespace EDM
286 } // namespace OHOS