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 
24 using namespace OHOS::EDM;
25 
Init(napi_env env,napi_value exports)26 napi_value AccountManagerAddon::Init(napi_env env, napi_value exports)
27 {
28     napi_property_descriptor property[] = {
29         DECLARE_NAPI_FUNCTION("disallowAddLocalAccount", DisallowAddLocalAccount),
30         DECLARE_NAPI_FUNCTION("disallowAddOsAccountByUser", DisallowAddOsAccountByUser),
31         DECLARE_NAPI_FUNCTION("isAddOsAccountByUserDisallowed", IsAddOsAccountByUserDisallowed),
32         DECLARE_NAPI_FUNCTION("addOsAccount", AddOsAccount),
33         DECLARE_NAPI_FUNCTION("disallowOsAccountAddition", DisallowAddOsAccount),
34         DECLARE_NAPI_FUNCTION("isOsAccountAdditionDisallowed", IsAddOsAccountDisallowed),
35         DECLARE_NAPI_FUNCTION("addOsAccountAsync", AddOsAccountAsync),
36     };
37     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
38     return exports;
39 }
40 
DisallowAddLocalAccount(napi_env env,napi_callback_info info)41 napi_value AccountManagerAddon::DisallowAddLocalAccount(napi_env env, napi_callback_info info)
42 {
43     EDMLOGI("NAPI_DisallowAddLocalAccount called");
44     size_t argc = ARGS_SIZE_THREE;
45     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
46     napi_value thisArg = nullptr;
47     void *data = nullptr;
48     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
49     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
50     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
51         MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean);
52     if (argc > ARGS_SIZE_TWO) {
53         matchFlag = matchFlag && MatchValueType(env, argv[ARR_INDEX_TWO], napi_function);
54     }
55     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
56     auto asyncCallbackInfo = new (std::nothrow) AsyncDisallowAddLocalAccountCallbackInfo();
57     if (asyncCallbackInfo == nullptr) {
58         return nullptr;
59     }
60     std::unique_ptr<AsyncDisallowAddLocalAccountCallbackInfo> callbackPtr {asyncCallbackInfo};
61     bool ret = ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]);
62     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "element name param error");
63     EDMLOGD("DisallowAddLocalAccount: asyncCallbackInfo->elementName.bundlename %{public}s, "
64         "asyncCallbackInfo->abilityname:%{public}s",
65         asyncCallbackInfo->elementName.GetBundleName().c_str(),
66         asyncCallbackInfo->elementName.GetAbilityName().c_str());
67     ret = ParseBool(env, asyncCallbackInfo->isDisallow, argv[ARR_INDEX_ONE]);
68     ASSERT_AND_THROW_PARAM_ERROR(env, ret, "isDisallow param error");
69     if (argc > ARGS_SIZE_TWO) {
70         EDMLOGD("NAPI_DisallowAddLocalAccount argc == ARGS_SIZE_THREE");
71         napi_create_reference(env, argv[ARR_INDEX_TWO], NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
72     }
73 
74     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "DisallowAddLocalAccount",
75         NativeDisallowAddLocalAccount, NativeVoidCallbackComplete);
76     callbackPtr.release();
77     return asyncWorkReturn;
78 }
79 
DisallowAddOsAccountByUser(napi_env env,napi_callback_info info)80 napi_value AccountManagerAddon::DisallowAddOsAccountByUser(napi_env env, napi_callback_info info)
81 {
82     EDMLOGI("NAPI_DisallowAddOsAccountByUser called");
83     size_t argc = ARGS_SIZE_THREE;
84     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
85     napi_value thisArg = nullptr;
86     void *data = nullptr;
87     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
88     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
89     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
90     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number), "parameter userid error");
91     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_boolean),
92         "parameter disallow error");
93 
94     OHOS::AppExecFwk::ElementName elementName;
95     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
96         "parameter admin parse error");
97     int32_t userId;
98     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, userId, argv[ARR_INDEX_ONE]), "parameter userid parse error");
99     bool disallow;
100     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, disallow, argv[ARR_INDEX_TWO]), "parameter disallow parse error");
101 
102     auto accountManagerProxy = AccountManagerProxy::GetAccountManagerProxy();
103     if (accountManagerProxy == nullptr) {
104         EDMLOGE("can not get AccountManagerProxy");
105         return nullptr;
106     }
107     int32_t ret = accountManagerProxy->DisallowAddOsAccountByUser(elementName, userId, disallow);
108     if (FAILED(ret)) {
109         napi_throw(env, CreateError(env, ret));
110         EDMLOGE("NAPI_DisallowAddOsAccountByUser failed!");
111     }
112     return nullptr;
113 }
114 
IsAddOsAccountByUserDisallowed(napi_env env,napi_callback_info info)115 napi_value AccountManagerAddon::IsAddOsAccountByUserDisallowed(napi_env env, napi_callback_info info)
116 {
117     EDMLOGI("NAPI_IsAddOsAccountByUserDisallowed called");
118     size_t argc = ARGS_SIZE_TWO;
119     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
120     napi_value thisArg = nullptr;
121     void *data = nullptr;
122     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
123     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
124     bool hasAdmin = false;
125     OHOS::AppExecFwk::ElementName elementName;
126     ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
127         "param admin need be null or want");
128     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number), "parameter userid error");
129     int32_t userId;
130     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, userId, argv[ARR_INDEX_ONE]), "parameter userid parse error");
131     bool isDisabled = false;
132     int32_t ret = ERR_OK;
133     if (hasAdmin) {
134         ret = AccountManagerProxy::GetAccountManagerProxy()->IsAddOsAccountByUserDisallowed(&elementName, userId,
135             isDisabled);
136     } else {
137         ret =
138             AccountManagerProxy::GetAccountManagerProxy()->IsAddOsAccountByUserDisallowed(nullptr, userId, isDisabled);
139     }
140     if (FAILED(ret)) {
141         napi_throw(env, CreateError(env, ret));
142         return nullptr;
143     }
144     napi_value result = nullptr;
145     napi_get_boolean(env, isDisabled, &result);
146     return result;
147 }
148 
AddOsAccount(napi_env env,napi_callback_info info)149 napi_value AccountManagerAddon::AddOsAccount(napi_env env, napi_callback_info info)
150 {
151 #ifdef OS_ACCOUNT_EDM_ENABLE
152     EDMLOGI("NAPI_AddOsAccount called");
153     auto asyncCallbackInfo = new (std::nothrow) AsyncAddOsAccountCallbackInfo();
154     if (asyncCallbackInfo == nullptr) {
155         return nullptr;
156     }
157     std::unique_ptr<AsyncAddOsAccountCallbackInfo> callbackPtr{asyncCallbackInfo};
158     napi_value checkRet = AddOsAccountCommon(env, info, asyncCallbackInfo);
159     int32_t errCode = -1;
160     napi_get_value_int32(env, checkRet, &errCode);
161     if (checkRet == nullptr || errCode != ERR_OK) {
162         return nullptr;
163     }
164     auto accountManagerProxy = AccountManagerProxy::GetAccountManagerProxy();
165     if (accountManagerProxy == nullptr) {
166         EDMLOGE("can not get AccountManagerProxy");
167         return nullptr;
168     }
169     OHOS::AccountSA::OsAccountInfo accountInfo;
170     std::string distributedInfoName;
171     std::string distributedInfoId;
172     int32_t ret = accountManagerProxy->AddOsAccount(asyncCallbackInfo->elementName, asyncCallbackInfo->name,
173         asyncCallbackInfo->type, accountInfo, distributedInfoName, distributedInfoId);
174     if (FAILED(ret)) {
175         napi_throw(env, CreateError(env, ret));
176         return nullptr;
177     }
178     return ConvertOsAccountInfoToJs(env, accountInfo, distributedInfoName, distributedInfoId);
179 #else
180     EDMLOGW("AccountManagerAddon::AddOsAccount Unsupported Capabilities.");
181     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
182     return nullptr;
183 #endif
184 }
185 
NativeDisallowAddLocalAccount(napi_env env,void * data)186 void AccountManagerAddon::NativeDisallowAddLocalAccount(napi_env env, void *data)
187 {
188     EDMLOGI("NativeDisallowAddLocalAccount called");
189     if (data == nullptr) {
190         EDMLOGE("data is nullptr");
191         return;
192     }
193     AsyncDisallowAddLocalAccountCallbackInfo *asyncCallbackInfo =
194         static_cast<AsyncDisallowAddLocalAccountCallbackInfo *>(data);
195     auto accountManagerProxy = AccountManagerProxy::GetAccountManagerProxy();
196     if (accountManagerProxy == nullptr) {
197         EDMLOGE("can not get AccountManagerProxy");
198         return;
199     }
200     asyncCallbackInfo->ret = accountManagerProxy->DisallowAddLocalAccount(asyncCallbackInfo->elementName,
201         asyncCallbackInfo->isDisallow);
202 }
203 
204 #ifdef OS_ACCOUNT_EDM_ENABLE
AddOsAccountCommon(napi_env env,napi_callback_info info,AsyncAddOsAccountCallbackInfo * callbackInfo)205 napi_value AccountManagerAddon::AddOsAccountCommon(napi_env env, napi_callback_info info,
206     AsyncAddOsAccountCallbackInfo* callbackInfo)
207 {
208     size_t argc = ARGS_SIZE_THREE;
209     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
210     napi_value thisArg = nullptr;
211     void *data = nullptr;
212     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
213     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "parameter count error");
214     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
215     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "parameter name error");
216     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_number), "parameter type error");
217     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, callbackInfo->elementName, argv[ARR_INDEX_ZERO]),
218         "parameter admin parse error");
219     EDMLOGD("AddOsAccountCommon: callbackInfo->elementName.bundleName %{public}s, callbackInfo->abilityName:%{public}s",
220         callbackInfo->elementName.GetBundleName().c_str(), callbackInfo->elementName.GetAbilityName().c_str());
221     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, callbackInfo->name, argv[ARR_INDEX_ONE]),
222         "parameter name parse error");
223     ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, callbackInfo->type, argv[ARR_INDEX_TWO]),
224         "parameter type parse error");
225     ASSERT_AND_THROW_PARAM_ERROR(env, !callbackInfo->name.empty(), "parameter name is empty");
226     ASSERT_AND_THROW_PARAM_ERROR(env, CheckOsAccountType(callbackInfo->type), "parameter type unknown");
227 
228     napi_value ret;
229     napi_create_int32(env, ERR_OK, &ret);
230     return ret;
231 }
232 
CheckOsAccountType(int32_t type)233 bool AccountManagerAddon::CheckOsAccountType(int32_t type)
234 {
235     if (type >= static_cast<int32_t>(OHOS::AccountSA::OsAccountType::ADMIN)
236         && type < static_cast<int32_t>(OHOS::AccountSA::OsAccountType::END)) {
237         return true;
238     }
239     return false;
240 }
241 
ConvertOsAccountInfoToJs(napi_env env,OHOS::AccountSA::OsAccountInfo & info,std::string distributedInfoName,std::string distributedInfoId)242 napi_value AccountManagerAddon::ConvertOsAccountInfoToJs(napi_env env, OHOS::AccountSA::OsAccountInfo &info,
243     std::string distributedInfoName, std::string distributedInfoId)
244 {
245     napi_value result = nullptr;
246     NAPI_CALL(env, napi_create_object(env, &result));
247 
248     // localId
249     napi_value idToJs = nullptr;
250     NAPI_CALL(env, napi_create_int32(env, info.GetLocalId(), &idToJs));
251     NAPI_CALL(env, napi_set_named_property(env, result, "localId", idToJs));
252 
253     // localName
254     napi_value nameToJs = nullptr;
255     NAPI_CALL(env, napi_create_string_utf8(env, info.GetLocalName().c_str(), NAPI_AUTO_LENGTH, &nameToJs));
256     NAPI_CALL(env, napi_set_named_property(env, result, "localName", nameToJs));
257 
258     // type
259     napi_value typeToJsObj = nullptr;
260     NAPI_CALL(env, napi_create_int32(env, static_cast<int>(info.GetType()), &typeToJsObj));
261     NAPI_CALL(env, napi_set_named_property(env, result, "type", typeToJsObj));
262 
263     // constraints
264     napi_value constraintsToJs = nullptr;
265     NAPI_CALL(env, napi_create_array(env, &constraintsToJs));
266     MakeArrayToJs(env, info.GetConstraints(), constraintsToJs);
267     NAPI_CALL(env, napi_set_named_property(env, result, "constraints", constraintsToJs));
268 
269     // isVerified
270     napi_value isVerifiedToJs = nullptr;
271     NAPI_CALL(env, napi_get_boolean(env, info.GetIsVerified(), &isVerifiedToJs));
272     NAPI_CALL(env, napi_set_named_property(env, result, "isVerified", isVerifiedToJs));
273 
274     // photo
275     napi_value photoToJs = nullptr;
276     NAPI_CALL(env, napi_create_string_utf8(env, info.GetPhoto().c_str(), NAPI_AUTO_LENGTH, &photoToJs));
277     NAPI_CALL(env, napi_set_named_property(env, result, "photo", photoToJs));
278 
279     // createTime
280     napi_value createTimeToJs = nullptr;
281     NAPI_CALL(env, napi_create_int64(env, info.GetCreateTime(), &createTimeToJs));
282     NAPI_CALL(env, napi_set_named_property(env, result, "createTime", createTimeToJs));
283 
284     // lastLoginTime
285     napi_value lastLoginTimeToJs = nullptr;
286     NAPI_CALL(env, napi_create_int64(env, info.GetLastLoginTime(), &lastLoginTimeToJs));
287     NAPI_CALL(env, napi_set_named_property(env, result, "lastLoginTime", lastLoginTimeToJs));
288 
289     // serialNumber
290     napi_value serialNumberToJs = nullptr;
291     NAPI_CALL(env, napi_create_int64(env, info.GetSerialNumber(), &serialNumberToJs));
292     NAPI_CALL(env, napi_set_named_property(env, result, "serialNumber", serialNumberToJs));
293 
294     // isActived
295     napi_value isActivedToJs = nullptr;
296     NAPI_CALL(env, napi_get_boolean(env, info.GetIsActived(), &isActivedToJs));
297     NAPI_CALL(env, napi_set_named_property(env, result, "isActived", isActivedToJs));
298 
299     // isCreateCompleted
300     napi_value isCreateCompletedToJs = nullptr;
301     NAPI_CALL(env, napi_get_boolean(env, info.GetIsCreateCompleted(), &isCreateCompletedToJs));
302     NAPI_CALL(env, napi_set_named_property(env, result, "isCreateCompleted", isCreateCompletedToJs));
303 
304     // distributedInfo: distributedAccount.DistributedInfo
305     napi_value dbInfoToJs = nullptr;
306     CreateJsDistributedInfo(env, distributedInfoName, distributedInfoId, dbInfoToJs);
307     NAPI_CALL(env, napi_set_named_property(env, result, "distributedInfo", dbInfoToJs));
308 
309     // domainInfo: domainInfo.DomainAccountInfo
310     OHOS::AccountSA::DomainAccountInfo domainInfo;
311     info.GetDomainInfo(domainInfo);
312     CreateJsDomainInfo(env, domainInfo, dbInfoToJs);
313     NAPI_CALL(env, napi_set_named_property(env, result, "domainInfo", dbInfoToJs));
314 
315     return result;
316 }
317 
MakeArrayToJs(napi_env env,const std::vector<std::string> & constraints,napi_value jsArray)318 napi_value AccountManagerAddon::MakeArrayToJs(napi_env env, const std::vector<std::string> &constraints,
319     napi_value jsArray)
320 {
321     uint32_t index = 0;
322     for (const auto &item : constraints) {
323         napi_value constraint = nullptr;
324         NAPI_CALL(env, napi_create_string_utf8(env, item.c_str(), NAPI_AUTO_LENGTH, &constraint));
325         NAPI_CALL(env, napi_set_element(env, jsArray, index, constraint));
326         index++;
327     }
328     return jsArray;
329 }
330 
CreateJsDistributedInfo(napi_env env,const std::string distributedInfoName,const std::string distributedInfoId,napi_value & result)331 napi_value AccountManagerAddon::CreateJsDistributedInfo(napi_env env, const std::string distributedInfoName,
332     const std::string distributedInfoId, napi_value &result)
333 {
334     napi_create_object(env, &result);
335     napi_value value = nullptr;
336     // name
337     NAPI_CALL(env, napi_create_string_utf8(env, distributedInfoName.c_str(), NAPI_AUTO_LENGTH, &value));
338     NAPI_CALL(env, napi_set_named_property(env, result, "name", value));
339 
340     // id
341     NAPI_CALL(env, napi_create_string_utf8(env, distributedInfoId.c_str(), NAPI_AUTO_LENGTH, &value));
342     NAPI_CALL(env, napi_set_named_property(env, result, "id", value));
343 
344     // event
345     NAPI_CALL(env, napi_create_string_utf8(env, "", 0, &value));
346     NAPI_CALL(env, napi_set_named_property(env, result, "event", value));
347 
348     // scalableData
349     napi_value scalable = nullptr;
350     NAPI_CALL(env, napi_create_object(env, &scalable));
351     NAPI_CALL(env, napi_set_named_property(env, result, "scalableData", scalable));
352 
353     return result;
354 }
355 
CreateJsDomainInfo(napi_env env,const OHOS::AccountSA::DomainAccountInfo & info,napi_value & result)356 napi_value AccountManagerAddon::CreateJsDomainInfo(napi_env env, const OHOS::AccountSA::DomainAccountInfo &info,
357     napi_value &result)
358 {
359     napi_create_object(env, &result);
360     napi_value value = nullptr;
361     // domain
362     NAPI_CALL(env, napi_create_string_utf8(env, info.domain_.c_str(), info.domain_.size(), &value));
363     NAPI_CALL(env, napi_set_named_property(env, result, "domain", value));
364 
365     // domain accountName
366     NAPI_CALL(env, napi_create_string_utf8(env, info.accountName_.c_str(), info.accountName_.size(), &value));
367     NAPI_CALL(env, napi_set_named_property(env, result, "accountName", value));
368 
369     // domain accountId
370     NAPI_CALL(env, napi_create_string_utf8(env, info.accountId_.c_str(), info.accountId_.size(), &value));
371     NAPI_CALL(env, napi_set_named_property(env, result, "accountId", value));
372 
373     // domain isAuthenticated
374     if ((info.status_ == OHOS::AccountSA::DomainAccountStatus::LOGOUT) ||
375         (info.status_ >= OHOS::AccountSA::DomainAccountStatus::LOG_END)) {
376         NAPI_CALL(env, napi_get_boolean(env, false, &value));
377     } else {
378         NAPI_CALL(env, napi_get_boolean(env, true, &value));
379     }
380     NAPI_CALL(env, napi_set_named_property(env, result, "isAuthenticated", value));
381     return result;
382 }
383 #endif
384 
DisallowAddOsAccount(napi_env env,napi_callback_info info)385 napi_value AccountManagerAddon::DisallowAddOsAccount(napi_env env, napi_callback_info info)
386 {
387     EDMLOGI("NAPI_DisallowAddOsAccount called");
388     size_t argc = ARGS_SIZE_THREE;
389     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
390     napi_value thisArg = nullptr;
391     void *data = nullptr;
392     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
393     bool hasAccountId = (argc == ARGS_SIZE_THREE);
394     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "parameter count error");
395     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "parameter admin error");
396     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_boolean),
397         "parameter disallow error");
398     OHOS::AppExecFwk::ElementName elementName;
399     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, elementName, argv[ARR_INDEX_ZERO]),
400         "parameter admin parse error");
401     bool disallow;
402     ASSERT_AND_THROW_PARAM_ERROR(env, ParseBool(env, disallow, argv[ARR_INDEX_ONE]), "parameter disallow parse error");
403 
404     int32_t accountId = 0;
405     if (hasAccountId) {
406         ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_number),
407             "parameter accountId error");
408         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_TWO]),
409             "parameter accountId parse error");
410     }
411 
412     auto accountManagerProxy = AccountManagerProxy::GetAccountManagerProxy();
413     if (accountManagerProxy == nullptr) {
414         EDMLOGE("can not get AccountManagerProxy");
415         return nullptr;
416     }
417     int32_t ret = ERR_OK;
418     if (hasAccountId) {
419         ret = accountManagerProxy->DisallowAddOsAccountByUser(elementName, accountId, disallow);
420     } else {
421         ret = accountManagerProxy->DisallowAddLocalAccount(elementName, disallow);
422     }
423     if (FAILED(ret)) {
424         napi_throw(env, CreateError(env, ret));
425         EDMLOGE("NAPI_DisallowAddOsAccount failed!");
426     }
427     return nullptr;
428 }
429 
IsAddOsAccountDisallowed(napi_env env,napi_callback_info info)430 napi_value AccountManagerAddon::IsAddOsAccountDisallowed(napi_env env, napi_callback_info info)
431 {
432     EDMLOGI("NAPI_IsAddOsAccountDisallowed called");
433     size_t argc = ARGS_SIZE_TWO;
434     napi_value argv[ARGS_SIZE_TWO] = {nullptr};
435     napi_value thisArg = nullptr;
436     void *data = nullptr;
437     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
438     bool hasAccountId = (argc == ARGS_SIZE_TWO);
439     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_ONE, "parameter count error");
440     bool hasAdmin = false;
441     OHOS::AppExecFwk::ElementName elementName;
442     ASSERT_AND_THROW_PARAM_ERROR(env, CheckGetPolicyAdminParam(env, argv[ARR_INDEX_ZERO], hasAdmin, elementName),
443         "param admin need be null or want");
444 
445     bool isDisabled = false;
446     int32_t ret = ERR_OK;
447     if (hasAccountId) {
448         ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_number),
449             "parameter accountId error");
450         int32_t accountId;
451         ASSERT_AND_THROW_PARAM_ERROR(env, ParseInt(env, accountId, argv[ARR_INDEX_ONE]),
452             "parameter accountId parse error");
453         if (hasAdmin) {
454             ret = AccountManagerProxy::GetAccountManagerProxy()->IsAddOsAccountByUserDisallowed(&elementName,
455                 accountId, isDisabled);
456         } else {
457             ret = AccountManagerProxy::GetAccountManagerProxy()->IsAddOsAccountByUserDisallowed(nullptr,
458                 accountId, isDisabled);
459         }
460     } else {
461         if (hasAdmin) {
462             ret = AccountManagerProxy::GetAccountManagerProxy()->IsAddLocalAccountDisallowed(&elementName, isDisabled);
463         } else {
464             ret = AccountManagerProxy::GetAccountManagerProxy()->IsAddLocalAccountDisallowed(nullptr, isDisabled);
465         }
466     }
467     if (FAILED(ret)) {
468         napi_throw(env, CreateError(env, ret));
469         return nullptr;
470     }
471     napi_value result = nullptr;
472     napi_get_boolean(env, isDisabled, &result);
473     return result;
474 }
475 
AddOsAccountAsync(napi_env env,napi_callback_info info)476 napi_value AccountManagerAddon::AddOsAccountAsync(napi_env env, napi_callback_info info)
477 {
478 #ifdef OS_ACCOUNT_EDM_ENABLE
479     EDMLOGI("NAPI_AddOsAccountAsync called");
480     auto asyncCallbackInfo = new (std::nothrow) AsyncAddOsAccountCallbackInfo();
481     if (asyncCallbackInfo == nullptr) {
482         return nullptr;
483     }
484     std::unique_ptr<AsyncAddOsAccountCallbackInfo> callbackPtr{asyncCallbackInfo};
485     napi_value checkRet = AddOsAccountCommon(env, info, asyncCallbackInfo);
486     int32_t errCode = -1;
487     napi_get_value_int32(env, checkRet, &errCode);
488     if (checkRet == nullptr || errCode != ERR_OK) {
489         return nullptr;
490     }
491     napi_value asyncWorkReturn = HandleAsyncWork(env, asyncCallbackInfo, "AddOsAccountAsync",
492         NativeAddOsAccount, NativeAddOsAccountCallbackComplete);
493     callbackPtr.release();
494     return asyncWorkReturn;
495 #else
496     EDMLOGW("AccountManagerAddon::AddOsAccountAsync Unsupported Capabilities.");
497     napi_throw(env, CreateError(env, EdmReturnErrCode::INTERFACE_UNSUPPORTED));
498     return nullptr;
499 #endif
500 }
501 
502 #ifdef OS_ACCOUNT_EDM_ENABLE
NativeAddOsAccount(napi_env env,void * data)503 void AccountManagerAddon::NativeAddOsAccount(napi_env env, void *data)
504 {
505     EDMLOGI("NativeAddOsAccount called");
506     if (data == nullptr) {
507         EDMLOGE("data is nullptr");
508         return;
509     }
510     AsyncAddOsAccountCallbackInfo *asyncCallbackInfo =
511         static_cast<AsyncAddOsAccountCallbackInfo *>(data);
512     auto accountManagerProxy = AccountManagerProxy::GetAccountManagerProxy();
513     if (accountManagerProxy == nullptr) {
514         EDMLOGE("can not get AccountManagerProxy");
515         return;
516     }
517     asyncCallbackInfo->ret = accountManagerProxy->AddOsAccount(asyncCallbackInfo->elementName,
518         asyncCallbackInfo->name, asyncCallbackInfo->type, asyncCallbackInfo->accountInfo,
519         asyncCallbackInfo->distributedInfoName, asyncCallbackInfo->distributedInfoId);
520 }
521 
NativeAddOsAccountCallbackComplete(napi_env env,napi_status status,void * data)522 void AccountManagerAddon::NativeAddOsAccountCallbackComplete(napi_env env, napi_status status, void *data)
523 {
524     if (data == nullptr) {
525         EDMLOGE("data is nullptr");
526         return;
527     }
528     auto *asyncCallbackInfo = static_cast<AsyncAddOsAccountCallbackInfo *>(data);
529     if (asyncCallbackInfo->deferred != nullptr) {
530         EDMLOGD("asyncCallbackInfo->deferred != nullptr");
531         if (asyncCallbackInfo->ret == ERR_OK) {
532             napi_value accountValue = ConvertOsAccountInfoToJs(env, asyncCallbackInfo->accountInfo,
533                 asyncCallbackInfo->distributedInfoName, asyncCallbackInfo->distributedInfoId);
534             napi_resolve_deferred(env, asyncCallbackInfo->deferred, accountValue);
535         } else {
536             napi_reject_deferred(env, asyncCallbackInfo->deferred, CreateError(env, asyncCallbackInfo->ret));
537         }
538     }
539     napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
540     delete asyncCallbackInfo;
541 }
542 #endif
543 
544 static napi_module g_accountManagerModule = {
545     .nm_version = 1,
546     .nm_flags = 0,
547     .nm_filename = nullptr,
548     .nm_register_func = AccountManagerAddon::Init,
549     .nm_modname = "enterprise.accountManager",
550     .nm_priv = ((void *)0),
551     .reserved = { 0 },
552 };
553 
AccountManagerRegister()554 extern "C" __attribute__((constructor)) void AccountManagerRegister()
555 {
556     napi_module_register(&g_accountManagerModule);
557 }