1 /*
2 * Copyright (c) 2023-2024 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 #include "account_manager_addon.h"
16 #ifdef OS_ACCOUNT_EDM_ENABLE
17 #include "account_info.h"
18 #include "os_account_info.h"
19 #include "domain_account_common.h"
20 #include "ohos_account_kits.h"
21 #endif
22 #include "edm_log.h"
23 #include "napi_edm_adapter.h"
24
25 using namespace OHOS::EDM;
26
Init(napi_env env,napi_value exports)27 napi_value AccountManagerAddon::Init(napi_env env, napi_value exports)
28 {
29 napi_property_descriptor property[] = {
30 DECLARE_NAPI_FUNCTION("disallowAddLocalAccount", DisallowAddLocalAccount),
31 DECLARE_NAPI_FUNCTION("disallowAddOsAccountByUser", DisallowAddOsAccountByUser),
32 DECLARE_NAPI_FUNCTION("isAddOsAccountByUserDisallowed", IsAddOsAccountByUserDisallowed),
33 DECLARE_NAPI_FUNCTION("addOsAccount", AddOsAccount),
34 DECLARE_NAPI_FUNCTION("disallowOsAccountAddition", DisallowAddOsAccount),
35 DECLARE_NAPI_FUNCTION("isOsAccountAdditionDisallowed", IsAddOsAccountDisallowed),
36 DECLARE_NAPI_FUNCTION("addOsAccountAsync", AddOsAccountAsync),
37 DECLARE_NAPI_FUNCTION("setDomainAccountPolicy", SetDomainAccountPolicy),
38 DECLARE_NAPI_FUNCTION("getDomainAccountPolicy", GetDomainAccountPolicy),
39 };
40 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
41 return exports;
42 }
43
DisallowAddLocalAccount(napi_env env,napi_callback_info info)44 napi_value AccountManagerAddon::DisallowAddLocalAccount(napi_env env, napi_callback_info info)
45 {
46 AddonMethodSign addonMethodSign;
47 addonMethodSign.name = "DisallowAddLocalAccount";
48 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::BOOLEAN};
49 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
50 return AddonMethodAdapter(env, info, addonMethodSign, NativeDisallowAddLocalAccount, NativeVoidCallbackComplete);
51 }
52
DisallowAddOsAccountByUser(napi_env env,napi_callback_info info)53 napi_value AccountManagerAddon::DisallowAddOsAccountByUser(napi_env env, napi_callback_info info)
54 {
55 auto convertUserId2Data = [](napi_env env, napi_value argv, MessageParcel &data,
56 const AddonMethodSign &methodSign) {
57 int32_t userId = 0;
58 bool isUint = ParseInt(env, userId, argv);
59 if (!isUint) {
60 return false;
61 }
62 std::vector<std::string> key {std::to_string(userId)};
63 data.WriteStringVector(key);
64 return true;
65 };
66 auto convertBool2Data = [](napi_env env, napi_value argv, MessageParcel &data,
67 const AddonMethodSign &methodSign) {
68 bool isDisallow = false;
69 bool isBool = ParseBool(env, isDisallow, argv);
70 if (!isBool) {
71 return false;
72 }
73 std::vector<std::string> value {isDisallow ? "true" : "false"};
74 data.WriteStringVector(value);
75 return true;
76 };
77
78 AddonMethodSign addonMethodSign;
79 addonMethodSign.name = "DisallowAddOsAccountByUser";
80 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::INT32, EdmAddonCommonType::BOOLEAN};
81 addonMethodSign.argsConvert = {nullptr, convertUserId2Data, convertBool2Data};
82 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
83 AdapterAddonData adapterAddonData{};
84 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
85 if (result == nullptr) {
86 return nullptr;
87 }
88
89 int32_t ret = AccountManagerProxy::GetAccountManagerProxy()->DisallowAddOsAccountByUser(adapterAddonData.data);
90 if (FAILED(ret)) {
91 napi_throw(env, CreateError(env, ret));
92 EDMLOGE("NAPI_DisallowAddOsAccountByUser failed!");
93 }
94 return nullptr;
95 }
96
IsAddOsAccountByUserDisallowed(napi_env env,napi_callback_info info)97 napi_value AccountManagerAddon::IsAddOsAccountByUserDisallowed(napi_env env, napi_callback_info info)
98 {
99 AddonMethodSign addonMethodSign;
100 addonMethodSign.name = "IsAddOsAccountByUserDisallowed";
101 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT_NULL, EdmAddonCommonType::INT32};
102 AdapterAddonData adapterAddonData{};
103 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
104 if (result == nullptr) {
105 return nullptr;
106 }
107 int32_t ret = AccountManagerProxy::GetAccountManagerProxy()->IsAddOsAccountByUserDisallowed(adapterAddonData.data,
108 adapterAddonData.boolRet);
109 if (FAILED(ret)) {
110 napi_throw(env, CreateError(env, ret));
111 return nullptr;
112 }
113 napi_value res = nullptr;
114 NAPI_CALL(env, napi_get_boolean(env, adapterAddonData.boolRet, &res));
115 return res;
116 }
117
AddOsAccount(napi_env env,napi_callback_info info)118 napi_value AccountManagerAddon::AddOsAccount(napi_env env, napi_callback_info info)
119 {
120 #ifdef OS_ACCOUNT_EDM_ENABLE
121 EDMLOGI("NAPI_AddOsAccount called");
122 auto asyncCallbackInfo = new (std::nothrow) AsyncAddOsAccountCallbackInfo();
123 if (asyncCallbackInfo == nullptr) {
124 return nullptr;
125 }
126 std::unique_ptr<AsyncAddOsAccountCallbackInfo> callbackPtr{asyncCallbackInfo};
127 napi_value checkRet = AddOsAccountCommon(env, info, asyncCallbackInfo);
128 int32_t errCode = -1;
129 NAPI_CALL(env, napi_get_value_int32(env, checkRet, &errCode));
130 if (checkRet == nullptr || errCode != ERR_OK) {
131 return nullptr;
132 }
133 auto accountManagerProxy = AccountManagerProxy::GetAccountManagerProxy();
134 if (accountManagerProxy == nullptr) {
135 EDMLOGE("can not get AccountManagerProxy");
136 return nullptr;
137 }
138 OHOS::AccountSA::OsAccountInfo accountInfo;
139 int32_t ret = accountManagerProxy->AddOsAccount(asyncCallbackInfo->elementName, asyncCallbackInfo->name,
140 asyncCallbackInfo->type, accountInfo);
141 if (FAILED(ret)) {
142 napi_throw(env, CreateError(env, ret));
143 return nullptr;
144 }
145 return ConvertOsAccountInfoToJs(env, accountInfo);
146 #else
147 EDMLOGW("AccountManagerAddon::AddOsAccount Unsupported Capabilities.");
148 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
149 return nullptr;
150 #endif
151 }
152
NativeDisallowAddLocalAccount(napi_env env,void * data)153 void AccountManagerAddon::NativeDisallowAddLocalAccount(napi_env env, void *data)
154 {
155 EDMLOGI("NativeDisallowAddLocalAccount called");
156 if (data == nullptr) {
157 EDMLOGE("data is nullptr");
158 return;
159 }
160 AdapterAddonData *asyncCallbackInfo =
161 static_cast<AdapterAddonData *>(data);
162 auto accountManagerProxy = AccountManagerProxy::GetAccountManagerProxy();
163 if (accountManagerProxy == nullptr) {
164 EDMLOGE("can not get AccountManagerProxy");
165 return;
166 }
167 asyncCallbackInfo->ret = accountManagerProxy->DisallowAddLocalAccount(asyncCallbackInfo->data);
168 }
169
170 #ifdef OS_ACCOUNT_EDM_ENABLE
AddOsAccountCommon(napi_env env,napi_callback_info info,AsyncAddOsAccountCallbackInfo * callbackInfo)171 napi_value AccountManagerAddon::AddOsAccountCommon(napi_env env, napi_callback_info info,
172 AsyncAddOsAccountCallbackInfo* callbackInfo)
173 {
174 size_t argc = ARGS_SIZE_THREE;
175 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
176 napi_value thisArg = nullptr;
177 void *data = nullptr;
178 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
179 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
180 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
181 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter name error");
182 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_number), "parameter type error");
183 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, callbackInfo->elementName, argv[ARR_INDEX_ZERO]),
184 "parameter admin parse error");
185 EDMLOGD("AddOsAccountCommon: callbackInfo->elementName.bundleName %{public}s, callbackInfo->abilityName:%{public}s",
186 callbackInfo->elementName.GetBundleName().c_str(), callbackInfo->elementName.GetAbilityName().c_str());
187 ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, callbackInfo->name, argv[ARR_INDEX_ONE]),
188 "parameter name parse error");
189 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, callbackInfo->type, argv[ARR_INDEX_TWO]),
190 "parameter type parse error");
191 ASSERT_AND_THROW_PARAM_ERROR(env, !callbackInfo->name.empty(), "parameter name is empty");
192 ASSERT_AND_THROW_PARAM_ERROR(env, CheckOsAccountType(callbackInfo->type), "parameter type unknown");
193
194 napi_value ret;
195 NAPI_CALL(env, napi_create_int32(env, ERR_OK, &ret));
196 return ret;
197 }
198
CheckOsAccountType(int32_t type)199 bool AccountManagerAddon::CheckOsAccountType(int32_t type)
200 {
201 if (type >= static_cast<int32_t>(OHOS::AccountSA::OsAccountType::ADMIN)
202 && type < static_cast<int32_t>(OHOS::AccountSA::OsAccountType::END)) {
203 return true;
204 }
205 return false;
206 }
207
ConvertOsAccountInfoToJs(napi_env env,OHOS::AccountSA::OsAccountInfo & info)208 napi_value AccountManagerAddon::ConvertOsAccountInfoToJs(napi_env env, OHOS::AccountSA::OsAccountInfo &info)
209 {
210 napi_value result = nullptr;
211 NAPI_CALL(env, napi_create_object(env, &result));
212
213 // localId
214 napi_value idToJs = nullptr;
215 NAPI_CALL(env, napi_create_int32(env, info.GetLocalId(), &idToJs));
216 NAPI_CALL(env, napi_set_named_property(env, result, "localId", idToJs));
217
218 // localName
219 napi_value nameToJs = nullptr;
220 NAPI_CALL(env, napi_create_string_utf8(env, info.GetLocalName().c_str(), NAPI_AUTO_LENGTH, &nameToJs));
221 NAPI_CALL(env, napi_set_named_property(env, result, "localName", nameToJs));
222
223 // type
224 napi_value typeToJsObj = nullptr;
225 NAPI_CALL(env, napi_create_int32(env, static_cast<int>(info.GetType()), &typeToJsObj));
226 NAPI_CALL(env, napi_set_named_property(env, result, "type", typeToJsObj));
227
228 // constraints
229 napi_value constraintsToJs = nullptr;
230 NAPI_CALL(env, napi_create_array(env, &constraintsToJs));
231 MakeArrayToJs(env, info.GetConstraints(), constraintsToJs);
232 NAPI_CALL(env, napi_set_named_property(env, result, "constraints", constraintsToJs));
233
234 // isVerified
235 napi_value isVerifiedToJs = nullptr;
236 NAPI_CALL(env, napi_get_boolean(env, info.GetIsVerified(), &isVerifiedToJs));
237 NAPI_CALL(env, napi_set_named_property(env, result, "isVerified", isVerifiedToJs));
238 NAPI_CALL(env, napi_set_named_property(env, result, "isUnlocked", isVerifiedToJs));
239
240 // photo
241 napi_value photoToJs = nullptr;
242 NAPI_CALL(env, napi_create_string_utf8(env, info.GetPhoto().c_str(), NAPI_AUTO_LENGTH, &photoToJs));
243 NAPI_CALL(env, napi_set_named_property(env, result, "photo", photoToJs));
244
245 // createTime
246 napi_value createTimeToJs = nullptr;
247 NAPI_CALL(env, napi_create_int64(env, info.GetCreateTime(), &createTimeToJs));
248 NAPI_CALL(env, napi_set_named_property(env, result, "createTime", createTimeToJs));
249
250 // lastLoginTime
251 napi_value lastLoginTimeToJs = nullptr;
252 NAPI_CALL(env, napi_create_int64(env, info.GetLastLoginTime(), &lastLoginTimeToJs));
253 NAPI_CALL(env, napi_set_named_property(env, result, "lastLoginTime", lastLoginTimeToJs));
254
255 // serialNumber
256 napi_value serialNumberToJs = nullptr;
257 NAPI_CALL(env, napi_create_int64(env, info.GetSerialNumber(), &serialNumberToJs));
258 NAPI_CALL(env, napi_set_named_property(env, result, "serialNumber", serialNumberToJs));
259
260 // isActived
261 napi_value isActivedToJs = nullptr;
262 NAPI_CALL(env, napi_get_boolean(env, info.GetIsActived(), &isActivedToJs));
263 NAPI_CALL(env, napi_set_named_property(env, result, "isActived", isActivedToJs));
264 NAPI_CALL(env, napi_set_named_property(env, result, "isActivated", isActivedToJs));
265
266 // isCreateCompleted
267 napi_value isCreateCompletedToJs = nullptr;
268 NAPI_CALL(env, napi_get_boolean(env, info.GetIsCreateCompleted(), &isCreateCompletedToJs));
269 NAPI_CALL(env, napi_set_named_property(env, result, "isCreateCompleted", isCreateCompletedToJs));
270
271 // distributedInfo: distributedAccount.DistributedInfo
272 napi_value dbInfoToJs = nullptr;
273 NAPI_CALL(env, napi_get_undefined(env, &dbInfoToJs));
274 NAPI_CALL(env, napi_set_named_property(env, result, "distributedInfo", dbInfoToJs));
275
276 // domainInfo: domainInfo.DomainAccountInfo
277 OHOS::AccountSA::DomainAccountInfo domainInfo;
278 info.GetDomainInfo(domainInfo);
279 CreateJsDomainInfo(env, domainInfo, dbInfoToJs);
280 NAPI_CALL(env, napi_set_named_property(env, result, "domainInfo", dbInfoToJs));
281
282 return result;
283 }
284
MakeArrayToJs(napi_env env,const std::vector<std::string> & constraints,napi_value jsArray)285 napi_value AccountManagerAddon::MakeArrayToJs(napi_env env, const std::vector<std::string> &constraints,
286 napi_value jsArray)
287 {
288 uint32_t index = 0;
289 for (const auto &item : constraints) {
290 napi_value constraint = nullptr;
291 NAPI_CALL(env, napi_create_string_utf8(env, item.c_str(), NAPI_AUTO_LENGTH, &constraint));
292 NAPI_CALL(env, napi_set_element(env, jsArray, index, constraint));
293 index++;
294 }
295 return jsArray;
296 }
297
CreateJsDomainInfo(napi_env env,const OHOS::AccountSA::DomainAccountInfo & info,napi_value & result)298 napi_value AccountManagerAddon::CreateJsDomainInfo(napi_env env, const OHOS::AccountSA::DomainAccountInfo &info,
299 napi_value &result)
300 {
301 napi_create_object(env, &result);
302 napi_value value = nullptr;
303 // domain
304 NAPI_CALL(env, napi_create_string_utf8(env, info.domain_.c_str(), info.domain_.size(), &value));
305 NAPI_CALL(env, napi_set_named_property(env, result, "domain", value));
306
307 // domain accountName
308 NAPI_CALL(env, napi_create_string_utf8(env, info.accountName_.c_str(), info.accountName_.size(), &value));
309 NAPI_CALL(env, napi_set_named_property(env, result, "accountName", value));
310
311 // domain accountId
312 NAPI_CALL(env, napi_create_string_utf8(env, info.accountId_.c_str(), info.accountId_.size(), &value));
313 NAPI_CALL(env, napi_set_named_property(env, result, "accountId", value));
314
315 // domain isAuthenticated
316 if ((info.status_ == OHOS::AccountSA::DomainAccountStatus::LOGOUT) ||
317 (info.status_ >= OHOS::AccountSA::DomainAccountStatus::LOG_END)) {
318 NAPI_CALL(env, napi_get_boolean(env, false, &value));
319 } else {
320 NAPI_CALL(env, napi_get_boolean(env, true, &value));
321 }
322 NAPI_CALL(env, napi_set_named_property(env, result, "isAuthenticated", value));
323 return result;
324 }
325 #endif
326
DisallowAddOsAccount(napi_env env,napi_callback_info info)327 napi_value AccountManagerAddon::DisallowAddOsAccount(napi_env env, napi_callback_info info)
328 {
329 EDMLOGI("NAPI_DisallowAddOsAccount called");
330 size_t argc = ARGS_SIZE_THREE;
331 napi_value argv[ARGS_SIZE_THREE] = {nullptr};
332 napi_value thisArg = nullptr;
333 void *data = nullptr;
334 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
335 bool hasAccountId = (argc == ARGS_SIZE_THREE);
336 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
337 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
338 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean),
339 "parameter disallow error");
340 OHOS::AppExecFwk::ElementName elementName;
341 ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
342 "parameter admin parse error");
343 bool disallow;
344 ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, disallow, argv[ARR_INDEX_ONE]), "parameter disallow parse error");
345
346 int32_t accountId = 0;
347 if (hasAccountId) {
348 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_number),
349 "parameter accountId error");
350 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_TWO]),
351 "parameter accountId parse error");
352 }
353
354 auto accountManagerProxy = AccountManagerProxy::GetAccountManagerProxy();
355 if (accountManagerProxy == nullptr) {
356 EDMLOGE("can not get AccountManagerProxy");
357 return nullptr;
358 }
359 int32_t ret = ERR_OK;
360 if (hasAccountId) {
361 ret = accountManagerProxy->DisallowAddOsAccountByUser(elementName, accountId, disallow);
362 } else {
363 ret = accountManagerProxy->DisallowAddLocalAccount(elementName, disallow);
364 }
365 if (FAILED(ret)) {
366 napi_throw(env, CreateError(env, ret));
367 EDMLOGE("NAPI_DisallowAddOsAccount failed!");
368 }
369 return nullptr;
370 }
371
IsAddOsAccountDisallowed(napi_env env,napi_callback_info info)372 napi_value AccountManagerAddon::IsAddOsAccountDisallowed(napi_env env, napi_callback_info info)
373 {
374 EDMLOGI("NAPI_IsAddOsAccountDisallowed called");
375 size_t argc = ARGS_SIZE_TWO;
376 napi_value argv[ARGS_SIZE_TWO] = {nullptr};
377 napi_value thisArg = nullptr;
378 void *data = nullptr;
379 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
380 bool hasAccountId = (argc == ARGS_SIZE_TWO);
381 ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
382 bool hasAdmin = false;
383 OHOS::AppExecFwk::ElementName elementName;
384 ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
385 "param admin need be null or want");
386
387 bool isDisabled = false;
388 int32_t ret = ERR_OK;
389 if (hasAccountId) {
390 ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number),
391 "parameter accountId error");
392 int32_t accountId;
393 ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_ONE]),
394 "parameter accountId parse error");
395 if (hasAdmin) {
396 ret = AccountManagerProxy::GetAccountManagerProxy()->IsAddOsAccountByUserDisallowed(&elementName,
397 accountId, isDisabled);
398 } else {
399 ret = AccountManagerProxy::GetAccountManagerProxy()->IsAddOsAccountByUserDisallowed(nullptr,
400 accountId, isDisabled);
401 }
402 } else {
403 if (hasAdmin) {
404 ret = AccountManagerProxy::GetAccountManagerProxy()->IsAddLocalAccountDisallowed(&elementName, isDisabled);
405 } else {
406 ret = AccountManagerProxy::GetAccountManagerProxy()->IsAddLocalAccountDisallowed(nullptr, isDisabled);
407 }
408 }
409 if (FAILED(ret)) {
410 napi_throw(env, CreateError(env, ret));
411 return nullptr;
412 }
413 napi_value result = nullptr;
414 NAPI_CALL(env, napi_get_boolean(env, isDisabled, &result));
415 return result;
416 }
417
AddOsAccountAsync(napi_env env,napi_callback_info info)418 napi_value AccountManagerAddon::AddOsAccountAsync(napi_env env, napi_callback_info info)
419 {
420 #ifdef OS_ACCOUNT_EDM_ENABLE
421 EDMLOGI("NAPI_AddOsAccountAsync called");
422 auto asyncCallbackInfo = new (std::nothrow) AsyncAddOsAccountCallbackInfo();
423 if (asyncCallbackInfo == nullptr) {
424 return nullptr;
425 }
426 std::unique_ptr<AsyncAddOsAccountCallbackInfo> callbackPtr{asyncCallbackInfo};
427 napi_value checkRet = AddOsAccountCommon(env, info, asyncCallbackInfo);
428 int32_t errCode = -1;
429 NAPI_CALL(env, napi_get_value_int32(env, checkRet, &errCode));
430 if (checkRet == nullptr || errCode != ERR_OK) {
431 return nullptr;
432 }
433 napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "AddOsAccountAsync",
434 NativeAddOsAccount, NativeAddOsAccountCallbackComplete);
435 callbackPtr.release();
436 return asyncWorkReturn;
437 #else
438 EDMLOGW("AccountManagerAddon::AddOsAccountAsync Unsupported Capabilities.");
439 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
440 return nullptr;
441 #endif
442 }
443
444 #ifdef OS_ACCOUNT_EDM_ENABLE
NativeAddOsAccount(napi_env env,void * data)445 void AccountManagerAddon::NativeAddOsAccount(napi_env env, void *data)
446 {
447 EDMLOGI("NativeAddOsAccount called");
448 if (data == nullptr) {
449 EDMLOGE("data is nullptr");
450 return;
451 }
452 AsyncAddOsAccountCallbackInfo *asyncCallbackInfo =
453 static_cast<AsyncAddOsAccountCallbackInfo *>(data);
454 auto accountManagerProxy = AccountManagerProxy::GetAccountManagerProxy();
455 if (accountManagerProxy == nullptr) {
456 EDMLOGE("can not get AccountManagerProxy");
457 return;
458 }
459 asyncCallbackInfo->ret = accountManagerProxy->AddOsAccount(asyncCallbackInfo->elementName,
460 asyncCallbackInfo->name, asyncCallbackInfo->type, asyncCallbackInfo->accountInfo);
461 }
462
NativeAddOsAccountCallbackComplete(napi_env env,napi_status status,void * data)463 void AccountManagerAddon::NativeAddOsAccountCallbackComplete(napi_env env, napi_status status, void *data)
464 {
465 if (data == nullptr) {
466 EDMLOGE("data is nullptr");
467 return;
468 }
469 auto *asyncCallbackInfo = static_cast<AsyncAddOsAccountCallbackInfo *>(data);
470 if (asyncCallbackInfo->deferred != nullptr) {
471 EDMLOGD("asyncCallbackInfo->deferred != nullptr");
472 if (asyncCallbackInfo->ret == ERR_OK) {
473 napi_value accountValue = ConvertOsAccountInfoToJs(env, asyncCallbackInfo->accountInfo);
474 napi_resolve_deferred(env, asyncCallbackInfo->deferred, accountValue);
475 } else {
476 napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret));
477 }
478 }
479 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
480 delete asyncCallbackInfo;
481 }
482 #endif
483
SetDomainAccountPolicy(napi_env env,napi_callback_info info)484 napi_value AccountManagerAddon::SetDomainAccountPolicy(napi_env env, napi_callback_info info)
485 {
486 #if defined(FEATURE_PC_ONLY) && defined(OS_ACCOUNT_EDM_ENABLE)
487 EDMLOGI("NAPI_SetDomainAccountPolicy called");
488 auto convertDomainAccountInfo2Data = [](napi_env env, napi_value argv, MessageParcel &data,
489 const AddonMethodSign &methodSign) {
490 OHOS::AccountSA::DomainAccountInfo domainAccountInfo;
491 bool isDomainAccountInfo = ParseDomainAccountInfo(env, domainAccountInfo, argv);
492 if (!isDomainAccountInfo) {
493 return false;
494 }
495 domainAccountInfo.Marshalling(data);
496 return true;
497 };
498 auto convertDomainAccountPolicy2Data = [](napi_env env, napi_value argv, MessageParcel &data,
499 const AddonMethodSign &methodSign) {
500 DomainAccountPolicy domainAccountPolicy;
501 bool isDomainAccountPolicy = ParseDomainAccountPolicy(env, domainAccountPolicy, argv);
502 if (!isDomainAccountPolicy) {
503 return false;
504 }
505 domainAccountPolicy.Marshalling(data);
506 return true;
507 };
508
509 AddonMethodSign addonMethodSign;
510 addonMethodSign.name = "SetDomainAccountPolicy";
511 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM, EdmAddonCommonType::CUSTOM};
512 addonMethodSign.argsConvert = {nullptr, convertDomainAccountInfo2Data, convertDomainAccountPolicy2Data};
513 addonMethodSign.methodAttribute = MethodAttribute::HANDLE;
514 AdapterAddonData adapterAddonData{};
515 napi_value result = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
516 if (result == nullptr) {
517 return nullptr;
518 }
519
520 int32_t ret = AccountManagerProxy::GetAccountManagerProxy()->SetDomainAccountPolicy(adapterAddonData.data);
521 if (FAILED(ret)) {
522 napi_throw(env, CreateError(env, ret));
523 EDMLOGE("NAPI_SetDomainAccountPolicy failed!");
524 }
525 return nullptr;
526 #else
527 EDMLOGW("AccountManagerAddon::SetDomainAccountPolicy Unsupported Capabilities.");
528 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
529 return nullptr;
530 #endif
531 }
532
GetDomainAccountPolicy(napi_env env,napi_callback_info info)533 napi_value AccountManagerAddon::GetDomainAccountPolicy(napi_env env, napi_callback_info info)
534 {
535 #if defined(FEATURE_PC_ONLY) && defined(OS_ACCOUNT_EDM_ENABLE)
536 EDMLOGI("NAPI_GetDomainAccountPolicy called");
537 auto convertDomainAccountInfo2Data = [](napi_env env, napi_value argv, MessageParcel &data,
538 const AddonMethodSign &methodSign) {
539 OHOS::AccountSA::DomainAccountInfo domainAccountInfo;
540 bool isDomainAccountInfo = ParseDomainAccountInfo(env, domainAccountInfo, argv);
541 if (!isDomainAccountInfo) {
542 return false;
543 }
544 domainAccountInfo.Marshalling(data);
545 return true;
546 };
547
548 AddonMethodSign addonMethodSign;
549 addonMethodSign.name = "GetDomainAccountPolicy";
550 addonMethodSign.argsType = {EdmAddonCommonType::ELEMENT, EdmAddonCommonType::CUSTOM};
551 addonMethodSign.argsConvert = {nullptr, convertDomainAccountInfo2Data};
552 addonMethodSign.methodAttribute = MethodAttribute::GET;
553 AdapterAddonData adapterAddonData{};
554 napi_value jsObjectToData = JsObjectToData(env, info, addonMethodSign, &adapterAddonData);
555 if (jsObjectToData == nullptr) {
556 return nullptr;
557 }
558
559 DomainAccountPolicy domainAccountPolicy;
560 int32_t ret = AccountManagerProxy::GetAccountManagerProxy()->GetDomainAccountPolicy(adapterAddonData.data,
561 domainAccountPolicy);
562 if (FAILED(ret)) {
563 napi_throw(env, CreateError(env, ret));
564 EDMLOGE("NAPI_GetDomainAccountPolicy failed!");
565 return nullptr;
566 }
567 return ConvertDomainAccountPolicyToJs(env, domainAccountPolicy);
568 #else
569 EDMLOGW("AccountManagerAddon::GetDomainAccountPolicy Unsupported Capabilities.");
570 napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
571 return nullptr;
572 #endif
573 }
574
ConvertDomainAccountPolicyToJs(napi_env env,DomainAccountPolicy & domainAccountPolicy)575 napi_value AccountManagerAddon::ConvertDomainAccountPolicyToJs(napi_env env,
576 DomainAccountPolicy &domainAccountPolicy)
577 {
578 napi_value result = nullptr;
579 napi_create_object(env, &result);
580 napi_value value = nullptr;
581
582 NAPI_CALL(env, napi_create_int32(env, domainAccountPolicy.authenticationValidityPeriod, &value));
583 NAPI_CALL(env, napi_set_named_property(env, result, "authenticationValidityPeriod", value));
584 NAPI_CALL(env, napi_create_int32(env, domainAccountPolicy.passwordValidityPeriod, &value));
585 NAPI_CALL(env, napi_set_named_property(env, result, "passwordValidityPeriod", value));
586 NAPI_CALL(env, napi_create_int32(env, domainAccountPolicy.passwordExpirationNotification, &value));
587 NAPI_CALL(env, napi_set_named_property(env, result, "passwordExpirationNotification", value));
588 return result;
589 }
590
ParseDomainAccountPolicy(napi_env env,DomainAccountPolicy & domainAccountPolicy,napi_value args)591 bool AccountManagerAddon::ParseDomainAccountPolicy(napi_env env, DomainAccountPolicy &domainAccountPolicy,
592 napi_value args)
593 {
594 napi_valuetype valueType;
595 if (napi_typeof(env, args, &valueType) != napi_ok || valueType != napi_object) {
596 EDMLOGE("Parse DomainAccountPolicy error");
597 return false;
598 }
599
600 int32_t authenticationValidityPeriod = -1;
601 int32_t passwordValidityPeriod = -1;
602 int32_t passwordExpirationNotification = 0;
603 if (!JsObjectToInt(env, args, "authenticationValidityPeriod", false, authenticationValidityPeriod) ||
604 !JsObjectToInt(env, args, "passwordValidityPeriod", false, passwordValidityPeriod) ||
605 !JsObjectToInt(env, args, "passwordExpirationNotification", false, passwordExpirationNotification)) {
606 EDMLOGE("AccountManagerAddon::ParseDomainAccountPolicy param error");
607 return false;
608 }
609 domainAccountPolicy.authenticationValidityPeriod = authenticationValidityPeriod;
610 domainAccountPolicy.passwordValidityPeriod = passwordValidityPeriod;
611 domainAccountPolicy.passwordExpirationNotification = passwordExpirationNotification;
612 return true;
613 }
614
615 #if defined(FEATURE_PC_ONLY) && defined(OS_ACCOUNT_EDM_ENABLE)
ParseDomainAccountInfo(napi_env env,OHOS::AccountSA::DomainAccountInfo & domainAccountInfo,napi_value args)616 bool AccountManagerAddon::ParseDomainAccountInfo(napi_env env, OHOS::AccountSA::DomainAccountInfo &domainAccountInfo,
617 napi_value args)
618 {
619 napi_valuetype valueType;
620 if (napi_typeof(env, args, &valueType) != napi_ok || valueType != napi_object) {
621 EDMLOGE("Parse DomainAccountInfo error");
622 return false;
623 }
624 std::string accountId;
625 std::string accountName;
626 std::string domain;
627 std::string serverConfigId;
628 if (!JsObjectToString(env, args, "accountId", false, accountId) ||
629 !JsObjectToString(env, args, "accountName", true, accountName) ||
630 !JsObjectToString(env, args, "domain", true, domain) ||
631 !JsObjectToString(env, args, "serverConfigId", false, serverConfigId)) {
632 EDMLOGE("AccountManagerAddon::ParseDomainAccountInfo param error");
633 return false;
634 }
635 domainAccountInfo.accountId_ = accountId;
636 domainAccountInfo.accountName_ = accountName;
637 domainAccountInfo.domain_ = domain;
638 domainAccountInfo.serverConfigId_ = serverConfigId;
639 return true;
640 }
641 #endif
642
643 static napi_module g_accountManagerModule = {
644 .nm_version = 1,
645 .nm_flags = 0,
646 .nm_filename = nullptr,
647 .nm_register_func = AccountManagerAddon::Init,
648 .nm_modname = "enterprise.accountManager",
649 .nm_priv = ((void *)0),
650 .reserved = { 0 },
651 };
652
AccountManagerRegister()653 extern "C" __attribute__((constructor)) void AccountManagerRegister()
654 {
655 napi_module_register(&g_accountManagerModule);
656 }