1 /*
2  * Copyright (c) 2021-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 "os_account_file_operator.h"
17 
18 #include "account_log_wrapper.h"
19 #include "os_account_constants.h"
20 
21 namespace OHOS {
22 namespace AccountSA {
OsAccountFileOperator()23 OsAccountFileOperator::OsAccountFileOperator()
24 {
25     accountFileOperator_ = std::make_shared<AccountFileOperator>();
26     isAlreadyInit_ = false;
27     constraintsConfig_.clear();
28     baseOsAccountConstraintsConfig_.clear();
29     globalOsAccountConstraintsConfig_.clear();
30     specificOsAccountConstraintsConfig_.clear();
31     constraintList_.clear();
32 }
~OsAccountFileOperator()33 OsAccountFileOperator::~OsAccountFileOperator()
34 {}
Init()35 void OsAccountFileOperator::Init()
36 {
37     if (accountFileOperator_->IsExistFile(Constants::OSACCOUNT_CONSTRAINTS_JSON_PATH)) {
38         std::string constraintsConfigStr;
39         accountFileOperator_->GetFileContentByPath(Constants::OSACCOUNT_CONSTRAINTS_JSON_PATH, constraintsConfigStr);
40         constraintsConfig_ = Json::parse(constraintsConfigStr, nullptr, false);
41         if (constraintsConfig_.is_discarded()) {
42             return;
43         }
44         isAlreadyInit_ = true;
45     }
46 
47     if (accountFileOperator_->IsExistFile(Constants::CONSTRAINTS_LIST_JSON_PATH)) {
48         std::string constraintListCollectingStr;
49         accountFileOperator_->GetFileContentByPath(Constants::CONSTRAINTS_LIST_JSON_PATH, constraintListCollectingStr);
50         Json constraintListCollecting = Json::parse(constraintListCollectingStr, nullptr, false);
51         if (constraintListCollecting.is_discarded()) {
52             return;
53         }
54         OHOS::AccountSA::GetDataByType<std::vector<std::string>>(constraintListCollecting,
55             constraintListCollecting.end(),
56             Constants::CONSTRAINTS_LIST,
57             constraintList_,
58             OHOS::AccountSA::JsonType::ARRAY);
59     }
60 }
61 
GetConstraintsByType(const int type,std::vector<std::string> & constraints)62 ErrCode OsAccountFileOperator::GetConstraintsByType(const int type, std::vector<std::string> &constraints)
63 {
64     ACCOUNT_LOGD("start");
65     if (!isAlreadyInit_) {
66         return ERR_OSACCOUNT_SERVICE_OS_FILE_GET_CONFIG_ERROR;
67     }
68     std::vector<std::string> typeList;
69     OHOS::AccountSA::GetDataByType<std::vector<std::string>>(
70         constraintsConfig_, constraintsConfig_.end(), Constants::TYPE_LIST, typeList, OHOS::AccountSA::JsonType::ARRAY);
71     if (std::find(typeList.begin(), typeList.end(), std::to_string(type)) == typeList.end()) {
72         ACCOUNT_LOGE("GetConstraintsByType get type error");
73         return ERR_OSACCOUNT_SERVICE_CONTROL_GET_TYPE_ERROR;
74     }
75     Json typeJson;
76     OHOS::AccountSA::GetDataByType<Json>(constraintsConfig_,
77         constraintsConfig_.end(),
78         Constants::USER_CONSTRAINTS_TEMPLATE,
79         typeJson,
80         OHOS::AccountSA::JsonType::OBJECT);
81     constraints.clear();
82     OHOS::AccountSA::GetDataByType<std::vector<std::string>>(
83         typeJson, typeJson.end(), std::to_string(type), constraints, OHOS::AccountSA::JsonType::ARRAY);
84     ACCOUNT_LOGD("end");
85     return ERR_OK;
86 }
87 
GetBaseOAConstraintsList(const int id,std::vector<std::string> & constraints)88 ErrCode OsAccountFileOperator::GetBaseOAConstraintsList(const int id, std::vector<std::string> &constraints)
89 {
90     if (accountFileOperator_->IsExistFile(Constants::BASE_OSACCOUNT_CONSTRAINTS_JSON_PATH)) {
91         std::string baseUserConstraintsConfigStr;
92         accountFileOperator_->GetFileContentByPath(
93             Constants::BASE_OSACCOUNT_CONSTRAINTS_JSON_PATH, baseUserConstraintsConfigStr);
94         baseOsAccountConstraintsConfig_ = Json::parse(baseUserConstraintsConfigStr, nullptr, false);
95         if (baseOsAccountConstraintsConfig_.is_discarded()) {
96             return ERR_OSACCOUNT_SERVICE_GET_DATA_FROM_BASE_CONSTRAINTS_FILE_EMPTY;
97         }
98     }
99     if (baseOsAccountConstraintsConfig_.size() == 0) {
100         ACCOUNT_LOGE("baseOsAccountConstraints data is empty");
101         return ERR_OSACCOUNT_SERVICE_GET_DATA_FROM_BASE_CONSTRAINTS_FILE_EMPTY;
102     }
103     OHOS::AccountSA::GetDataByType<std::vector<std::string>>(baseOsAccountConstraintsConfig_,
104         baseOsAccountConstraintsConfig_.end(),
105         std::to_string(id),
106         constraints,
107         OHOS::AccountSA::JsonType::ARRAY);
108     return ERR_OK;
109 }
110 
GetGlobalOAConstraintsList(std::vector<std::string> & constraints)111 ErrCode OsAccountFileOperator::GetGlobalOAConstraintsList(std::vector<std::string> &constraints)
112 {
113     if (accountFileOperator_->IsExistFile(Constants::GLOBAL_OSACCOUNT_CONSTRAINTS_JSON_PATH)) {
114         std::string globalOsAccountConstraintsConfigStr;
115         accountFileOperator_->GetFileContentByPath(
116             Constants::GLOBAL_OSACCOUNT_CONSTRAINTS_JSON_PATH, globalOsAccountConstraintsConfigStr);
117         globalOsAccountConstraintsConfig_ = Json::parse(globalOsAccountConstraintsConfigStr, nullptr, false);
118         if (globalOsAccountConstraintsConfig_.is_discarded()) {
119             return ERR_OSACCOUNT_SERVICE_GET_DATA_FROM_GLOBAL_CONSTRAINTS_FILE_EMPTY;
120         }
121     }
122 
123     if (globalOsAccountConstraintsConfig_.size() == 0) {
124         ACCOUNT_LOGE("globalOsAccountConstraints data is empty");
125         return ERR_OSACCOUNT_SERVICE_GET_DATA_FROM_GLOBAL_CONSTRAINTS_FILE_EMPTY;
126     }
127     OHOS::AccountSA::GetDataByType<std::vector<std::string>>(globalOsAccountConstraintsConfig_,
128         globalOsAccountConstraintsConfig_.end(),
129         Constants::ALL_GLOBAL_CONSTRAINTS,
130         constraints,
131         OHOS::AccountSA::JsonType::ARRAY);
132     return ERR_OK;
133 }
134 
GetSpecificOAConstraintsList(const int id,std::vector<std::string> & constraints)135 ErrCode OsAccountFileOperator::GetSpecificOAConstraintsList(const int id, std::vector<std::string> &constraints)
136 {
137     if (accountFileOperator_->IsExistFile(Constants::SPECIFIC_OSACCOUNT_CONSTRAINTS_JSON_PATH)) {
138         std::string specificOsAccountConstraintsConfigStr;
139         accountFileOperator_->GetFileContentByPath(
140             Constants::SPECIFIC_OSACCOUNT_CONSTRAINTS_JSON_PATH, specificOsAccountConstraintsConfigStr);
141         specificOsAccountConstraintsConfig_ = Json::parse(specificOsAccountConstraintsConfigStr, nullptr, false);
142         if (specificOsAccountConstraintsConfig_.is_discarded()) {
143             return ERR_OSACCOUNT_SERVICE_GET_DATA_FROM_SPECIFIC_CONSTRAINTS_FILE_EMPTY;
144         }
145     }
146 
147     if (specificOsAccountConstraintsConfig_.size() == 0) {
148         ACCOUNT_LOGE("globalOsAccountConstraints data is empty");
149         return ERR_OSACCOUNT_SERVICE_GET_DATA_FROM_SPECIFIC_CONSTRAINTS_FILE_EMPTY;
150     }
151     Json SpecificOAConstraintsData;
152     OHOS::AccountSA::GetDataByType<Json>(specificOsAccountConstraintsConfig_,
153         specificOsAccountConstraintsConfig_.end(),
154         std::to_string(id),
155         SpecificOAConstraintsData,
156         OHOS::AccountSA::JsonType::OBJECT);
157     OHOS::AccountSA::GetDataByType<std::vector<std::string>>(SpecificOAConstraintsData,
158         SpecificOAConstraintsData.end(),
159         Constants::ALL_SPECIFIC_CONSTRAINTS,
160         constraints,
161         OHOS::AccountSA::JsonType::ARRAY);
162     return ERR_OK;
163 }
164 
GetIsMultiOsAccountEnable(bool & isMultiOsAccountEnable)165 ErrCode OsAccountFileOperator::GetIsMultiOsAccountEnable(bool &isMultiOsAccountEnable)
166 {
167     if (!isAlreadyInit_) {
168         ACCOUNT_LOGE("GetIsMultiOsAccountEnable not init error");
169         return ERR_OSACCOUNT_SERVICE_OS_FILE_GET_CONFIG_ERROR;
170     }
171     OHOS::AccountSA::GetDataByType<Json>(constraintsConfig_,
172         constraintsConfig_.end(),
173         Constants::IS_MULTI_OS_ACCOUNT_ENABLE,
174         isMultiOsAccountEnable,
175         OHOS::AccountSA::JsonType::BOOLEAN);
176     return ERR_OK;
177 }
178 
IsAllowedCreateAdmin(bool & isAllowedCreateAdmin)179 ErrCode OsAccountFileOperator::IsAllowedCreateAdmin(bool &isAllowedCreateAdmin)
180 {
181     if (!isAlreadyInit_) {
182         ACCOUNT_LOGE("IsAllowedCreateAdmin not init error");
183         return ERR_OSACCOUNT_SERVICE_OS_FILE_GET_CONFIG_ERROR;
184     }
185     OHOS::AccountSA::GetDataByType<Json>(constraintsConfig_,
186         constraintsConfig_.end(),
187         Constants::IS_ALLOWED_CREATE_ADMIN,
188         isAllowedCreateAdmin,
189         OHOS::AccountSA::JsonType::BOOLEAN);
190     return ERR_OK;
191 }
192 
CheckConstraintsList(const std::vector<std::string> & constraints,bool & isExists,bool & isOverSize)193 ErrCode OsAccountFileOperator::CheckConstraintsList(const std::vector<std::string> &constraints,
194     bool &isExists, bool &isOverSize)
195 {
196     isOverSize = false;
197     isExists = true;
198     if (constraintList_.size() == 0) {
199         ACCOUNT_LOGE("constraintList_ zero error!");
200         return ERR_OSACCOUNT_SERVICE_OS_FILE_GET_CONSTRAINTS_LITS_ERROR;
201     }
202 
203     if (constraints.size() > constraintList_.size()) {
204         ACCOUNT_LOGE("input constraints list size %{public}zu is larger than %{public}zu.",
205             constraints.size(), constraintList_.size());
206         isOverSize = true;
207         return ERR_OK;
208     }
209 
210     for (auto it = constraints.begin(); it != constraints.end(); it++) {
211         if (std::find(constraintList_.begin(), constraintList_.end(), *it) == constraintList_.end()) {
212             isExists = false;
213             return ERR_OK;
214         }
215     }
216     return ERR_OK;
217 }
218 }  // namespace AccountSA
219 }  // namespace OHOS