• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "contacts_api.h"
17 
18 #include <mutex>
19 
20 #include "datashare_predicates.h"
21 #include "rdb_errno.h"
22 #include "rdb_helper.h"
23 #include "rdb_open_callback.h"
24 #include "rdb_predicates.h"
25 #include "rdb_store.h"
26 #include "result_set.h"
27 #include "securec.h"
28 
29 #include "contacts_control.h"
30 #include "contacts_napi_common.h"
31 #include "contacts_napi_utils.h"
32 #include "hilog_wrapper_api.h"
33 #include "result_convert.h"
34 
35 namespace OHOS {
36 namespace ContactsApi {
37 namespace {
38 std::mutex g_mutex;
39 }
40 /**
41  * @brief Initialize NAPI object
42  *
43  * @param env Conditions for initialize operation
44  * @param object Conditions for initialize operation
45  * @param hold Attribute of object
46  * @param attr Attribute of object
47  * @param contact Attribute of object
48  */
ObjectInit(napi_env env,napi_value object,napi_value & hold,napi_value & attr,napi_value & contact)49 void ObjectInit(napi_env env, napi_value object, napi_value &hold, napi_value &attr, napi_value &contact)
50 {
51     int type = GetType(env, object);
52     switch (type) {
53         case TYPE_HOLDER:
54             hold = object;
55             break;
56         case TYPE_ATTR:
57             attr = object;
58             break;
59         case TYPE_CONTACT:
60             contact = object;
61             break;
62         default:
63             break;
64     }
65 }
66 
67 /**
68  * @brief Initialize NAPI number object
69  *
70  * @param env Conditions for initialize operation
71  * @param object Conditions for initialize operation
72  * @param id Number object
73  */
ObjectInitId(napi_env env,napi_value object,napi_value & id)74 void ObjectInitId(napi_env env, napi_value object, napi_value &id)
75 {
76     int type = GetType(env, object);
77     switch (type) {
78         case TYPE_NAPI_NUMBER:
79             id = object;
80             break;
81         default:
82             break;
83     }
84 }
85 
86 /**
87  * @brief Initialize NAPI string object
88  *
89  * @param env Conditions for initialize operation
90  * @param object Conditions for initialize operation
91  * @param key String object
92  */
ObjectInitString(napi_env env,napi_value object,napi_value & key)93 void ObjectInitString(napi_env env, napi_value object, napi_value &key)
94 {
95     int type = GetType(env, object);
96     switch (type) {
97         case TYPE_NAPI_STRING:
98             key = object;
99             break;
100         default:
101             break;
102     }
103 }
104 
105 /**
106  * @brief Get NAPI object type
107  *
108  * @param env Conditions for get type operation
109  * @param value Conditions for get type operation
110  *
111  * @return The result returned by get type operation
112  */
GetType(napi_env env,napi_value value)113 int GetType(napi_env env, napi_value value)
114 {
115     napi_valuetype valueType;
116     napi_typeof(env, value, &valueType);
117     bool result = false;
118     switch (valueType) {
119         case napi_number:
120             return TYPE_NAPI_NUMBER;
121             break;
122         case napi_string:
123             return TYPE_NAPI_STRING;
124             break;
125         case napi_object:
126             napi_value key;
127             napi_create_string_utf8(env, "bundleName", NAPI_AUTO_LENGTH, &key);
128             napi_has_property(env, value, key, &result);
129             if (result) {
130                 return TYPE_HOLDER;
131             }
132             napi_create_string_utf8(env, "attributes", NAPI_AUTO_LENGTH, &key);
133             napi_has_property(env, value, key, &result);
134             if (result) {
135                 return TYPE_ATTR;
136             }
137             return TYPE_CONTACT;
138             break;
139         default:
140             return TYPE_NAPI_ERROR;
141             break;
142     }
143 }
144 
145 /**
146  * @brief Get dataShareHelper
147  *
148  * @param env Conditions for get dataShareHelper operation
149  *
150  * @return The result returned by get dataShareHelper
151  */
GetDataShareHelper(napi_env env,napi_callback_info info)152 std::shared_ptr<DataShare::DataShareHelper> GetDataShareHelper(napi_env env, napi_callback_info info)
153 {
154     napi_value global;
155     napi_status status = napi_get_global(env, &global);
156     if (status != napi_ok) {
157         HILOG_ERROR("GetDataShareHelper napi_get_global != napi_ok");
158     }
159     napi_value globalThis;
160     status = napi_get_named_property(env, global, "globalThis", &globalThis);
161     if (status != napi_ok) {
162         HILOG_ERROR("GetDataShareHelper napi_get_globalThis != napi_ok");
163     }
164     napi_value abilityContext = nullptr;
165     status = napi_get_named_property(env, globalThis, "abilityContext", &abilityContext);
166     if (status != napi_ok) {
167         HILOG_ERROR("GetDataShareHelper napi_get_abilityContext != napi_ok");
168     }
169 
170     std::shared_ptr<DataShare::DataShareHelper> dataShareHelper = nullptr;
171     bool isStageMode = false;
172     status = OHOS::AbilityRuntime::IsStageContext(env, abilityContext, isStageMode);
173     if (status != napi_ok || !isStageMode) {
174         HILOG_INFO("GetFAModeContext");
175         auto ability = OHOS::AbilityRuntime::GetCurrentAbility(env);
176         if (ability == nullptr) {
177             HILOG_ERROR("Failed to get native ability instance");
178             return nullptr;
179         }
180         auto context = ability->GetContext();
181         if (context == nullptr) {
182             HILOG_ERROR("Failed to get native context instance");
183             return nullptr;
184         }
185         dataShareHelper = DataShare::DataShareHelper::Creator(context, CONTACTS_DATA_URI);
186     } else {
187         HILOG_INFO("GetStageModeContext");
188         auto context = OHOS::AbilityRuntime::GetStageModeContext(env, abilityContext);
189         if (context == nullptr) {
190             HILOG_ERROR("Failed to get native stage context instance");
191             return nullptr;
192         }
193         dataShareHelper = DataShare::DataShareHelper::Creator(context->GetToken(), CONTACTS_DATA_URI);
194     }
195     return dataShareHelper;
196 }
197 
198 /**
199  * @brief Establish predicates condition by holder object
200  *
201  * @param holder Conditions for establish predicates operation
202  * @param predicates Conditions for establish predicates operation
203  */
HolderPredicates(Holder & holder,DataShare::DataSharePredicates & predicates)204 void HolderPredicates(Holder &holder, DataShare::DataSharePredicates &predicates)
205 {
206     if (!holder.bundleName.empty()) {
207         predicates.And();
208         predicates.EqualTo("account_type", holder.bundleName);
209     }
210     if (!holder.displayName.empty()) {
211         predicates.And();
212         predicates.EqualTo("account_name", holder.displayName);
213     }
214     if (holder.holderId > 0) {
215         predicates.And();
216         predicates.EqualTo("account_id", std::to_string(holder.holderId));
217     }
218 }
219 
220 /**
221  * @brief Establish predicates condition by attributes object
222  *
223  * @param attrs Conditions for establish predicates operation
224  * @param predicates Conditions for establish predicates operation
225  */
AttributesPredicates(bool isBegin,ContactAttributes & attrs,DataShare::DataSharePredicates & predicates)226 void AttributesPredicates(bool isBegin, ContactAttributes &attrs, DataShare::DataSharePredicates &predicates)
227 {
228     unsigned int size = attrs.attributes.size();
229     if (size > 0) {
230         if (!isBegin) {
231             predicates.And();
232         }
233         predicates.BeginWrap();
234     }
235     for (unsigned int i = 0; i < size; ++i) {
236         predicates.EqualTo("type_id", std::to_string(attrs.attributes[i]));
237         if (i != size - 1) {
238             predicates.Or();
239         }
240     }
241     if (size > 0) {
242         predicates.EndWrap();
243     }
244 }
245 
CheckAttributes(ContactAttributes & attrs)246 void CheckAttributes(ContactAttributes &attrs)
247 {
248     unsigned int size = attrs.attributes.size();
249     if (size == 0) {
250         HILOG_INFO("attributes not exist, it means all attribute");
251         attrs.attributes.push_back(EMAIL);
252         attrs.attributes.push_back(IM);
253         attrs.attributes.push_back(NICKNAME);
254         attrs.attributes.push_back(ORGANIZATION);
255         attrs.attributes.push_back(PHONE);
256         attrs.attributes.push_back(NAME);
257         attrs.attributes.push_back(POSTAL_ADDRESS);
258         attrs.attributes.push_back(PHOTO);
259         attrs.attributes.push_back(GROUP_MEMBERSHIP);
260         attrs.attributes.push_back(NOTE);
261         attrs.attributes.push_back(CONTACT_EVENT);
262         attrs.attributes.push_back(WEBSITE);
263         attrs.attributes.push_back(RELATION);
264         attrs.attributes.push_back(SIP_ADDRESS);
265     }
266 }
267 
268 /**
269  * @brief Resolve object interface in DELETE_CONTACT case
270  *
271  * @param env Conditions for resolve object interface operation
272  * @param info Conditions for resolve object interface operation
273  */
BuildDeleteContactPredicates(napi_env env,ExecuteHelper * executeHelper)274 DataShare::DataSharePredicates BuildDeleteContactPredicates(napi_env env, ExecuteHelper *executeHelper)
275 {
276     DataShare::DataSharePredicates predicates;
277     ContactsBuild contactsBuild;
278     std::string keyValue = contactsBuild.NapiGetValueString(env, executeHelper->argv[0]);
279     if (!keyValue.empty()) {
280         predicates.EqualTo("is_deleted", "0");
281         predicates.And();
282         predicates.EqualTo("quick_search_key", keyValue);
283     }
284     return predicates;
285 }
286 
287 /**
288  * @brief Resolve object interface in QUERY_CONTACT case
289  *
290  * @param env Conditions for resolve object interface operation
291  * @param key Conditions for resolve object interface operation
292  * @param hold Conditions for resolve object interface operation
293  * @param attr Conditions for resolve object interface operation
294  */
BuildQueryContactPredicates(napi_env env,napi_value key,napi_value hold,napi_value attr)295 DataShare::DataSharePredicates BuildQueryContactPredicates(
296     napi_env env, napi_value key, napi_value hold, napi_value attr)
297 {
298     ContactsBuild contactsBuild;
299     std::string keyValue = contactsBuild.NapiGetValueString(env, key);
300     Holder holder = contactsBuild.GetHolder(env, hold);
301     ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attr);
302     DataShare::DataSharePredicates predicates;
303     if (!keyValue.empty()) {
304         predicates.EqualTo("is_deleted", "0");
305         predicates.And();
306         predicates.EqualTo("quick_search_key", keyValue);
307         HolderPredicates(holder, predicates);
308         AttributesPredicates(false, attrs, predicates);
309     }
310     return predicates;
311 }
312 
HoldersStructure(std::map<std::string,std::string> & holders,Holder & holder)313 void HoldersStructure(std::map<std::string, std::string> &holders, Holder &holder)
314 {
315     if (!holder.bundleName.empty()) {
316         holders["account_type"] = holder.bundleName;
317     }
318     if (!holder.displayName.empty()) {
319         holders["account_name"] = holder.displayName;
320     }
321     if (holder.holderId > 0) {
322         holders["account_id"] = std::to_string(holder.holderId);
323     }
324 }
325 
326 /**
327  * @brief Resolve object interface in QUERY_CONTACTS case
328  *
329  * @param env Conditions for resolve object interface operation
330  * @param hold Conditions for resolve object interface operation
331  * @param attr Conditions for resolve object interface operation
332  */
BuildQueryContactsPredicates(napi_env env,napi_value hold,napi_value attr)333 DataShare::DataSharePredicates BuildQueryContactsPredicates(napi_env env, napi_value hold, napi_value attr)
334 {
335     ContactsBuild contactsBuild;
336     Holder holder = contactsBuild.GetHolder(env, hold);
337     ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attr);
338     DataShare::DataSharePredicates predicates;
339     std::map<std::string, std::string> holders;
340     HoldersStructure(holders, holder);
341     unsigned int size = attrs.attributes.size();
342     unsigned int mapSize = holders.size();
343     std::map<std::string, std::string>::iterator it;
344     for (it = holders.begin(); it != holders.end(); ++it) {
345         predicates.EqualTo(it->first, it->second);
346         if (it != --holders.end()) {
347             predicates.And();
348         }
349     }
350     if (mapSize > 0) {
351         predicates.And();
352     }
353     if (size > 0) {
354         predicates.BeginWrap();
355     }
356     for (unsigned int i = 0; i < size; ++i) {
357         predicates.EqualTo("type_id", std::to_string(attrs.attributes[i]));
358         if (i != size - 1) {
359             predicates.Or();
360         }
361     }
362     if (size > 0) {
363         predicates.EndWrap();
364     }
365     if (size > 0 || mapSize > 0) {
366         predicates.And();
367     }
368     predicates.EqualTo("is_deleted", "0");
369     return predicates;
370 }
371 
372 /**
373  * @brief Resolve object interface in QUERY_CONTACTS_BY_EMAIL case
374  *
375  * @param env Conditions for resolve object interface operation
376  * @param emailobject Conditions for resolve object interface operation
377  * @param hold Conditions for resolve object interface operation
378  * @param attr Conditions for resolve object interface operation
379  */
BuildQueryContactsByEmailPredicates(napi_env env,napi_value emailobject,napi_value hold,napi_value attr)380 DataShare::DataSharePredicates BuildQueryContactsByEmailPredicates(
381     napi_env env, napi_value emailobject, napi_value hold, napi_value attr)
382 {
383     ContactsBuild contactsBuild;
384     std::string email = contactsBuild.NapiGetValueString(env, emailobject);
385     Holder holder = contactsBuild.GetHolder(env, hold);
386     ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attr);
387     DataShare::DataSharePredicates predicates;
388     if (!email.empty() || email != "") {
389         predicates.EqualTo("is_deleted", "0");
390         predicates.And();
391         predicates.EqualTo("detail_info", email);
392         predicates.And();
393         predicates.EqualTo("content_type", "email");
394         HolderPredicates(holder, predicates);
395         AttributesPredicates(false, attrs, predicates);
396     }
397     return predicates;
398 }
399 
400 /**
401  * @brief Resolve object interface in QUERY_CONTACTS_BY_PHONE_NUMBER case
402  *
403  * @param env Conditions for resolve object interface operation
404  * @param number Conditions for resolve object interface operation
405  * @param hold Conditions for resolve object interface operation
406  * @param attr Conditions for resolve object interface operation
407  */
BuildQueryContactsByPhoneNumberPredicates(napi_env env,napi_value number,napi_value hold,napi_value attr)408 DataShare::DataSharePredicates BuildQueryContactsByPhoneNumberPredicates(
409     napi_env env, napi_value number, napi_value hold, napi_value attr)
410 {
411     ContactsBuild contactsBuild;
412     std::string phoneNumber = contactsBuild.NapiGetValueString(env, number);
413     Holder holder = contactsBuild.GetHolder(env, hold);
414     ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attr);
415     DataShare::DataSharePredicates predicates;
416     if (!phoneNumber.empty() || phoneNumber != "") {
417         predicates.EqualTo("is_deleted", "0");
418         predicates.And();
419         predicates.EqualTo("detail_info", phoneNumber);
420         predicates.And();
421         predicates.EqualTo("content_type", "phone");
422         HolderPredicates(holder, predicates);
423         AttributesPredicates(false, attrs, predicates);
424     }
425     return predicates;
426 }
427 
428 /**
429  * @brief Resolve object interface in QUERY_GROUPS case
430  *
431  * @param env Conditions for resolve object interface operation
432  * @param hold Conditions for resolve object interface operation
433  */
BuildQueryGroupsPredicates(napi_env env,napi_value hold)434 DataShare::DataSharePredicates BuildQueryGroupsPredicates(napi_env env, napi_value hold)
435 {
436     ContactsBuild contactsBuild;
437     Holder holder = contactsBuild.GetHolder(env, hold);
438     DataShare::DataSharePredicates predicates;
439     std::map<std::string, std::string> holders;
440     HoldersStructure(holders, holder);
441     predicates.EqualTo("is_deleted", "0");
442     unsigned int size = holders.size();
443     if (size > 0) {
444         predicates.And();
445     }
446     std::map<std::string, std::string>::iterator it;
447     for (it = holders.begin(); it != holders.end(); ++it) {
448         predicates.EqualTo(it->first, it->second);
449         if (it != --holders.end()) {
450             predicates.And();
451         }
452     }
453     return predicates;
454 }
455 
456 /**
457  * @brief Resolve object interface in QUERY_KEY case
458  *
459  * @param env Conditions for resolve object interface operation
460  * @param id Conditions for resolve object interface operation
461  * @param hold Conditions for resolve object interface operation
462  */
BuildQueryKeyPredicates(napi_env env,napi_value id,napi_value hold)463 DataShare::DataSharePredicates BuildQueryKeyPredicates(napi_env env, napi_value id, napi_value hold)
464 {
465     ContactsBuild contactsBuild;
466     int value = contactsBuild.GetInt(env, id);
467     Holder holder = contactsBuild.GetHolder(env, hold);
468     DataShare::DataSharePredicates predicates;
469     if (value != 0) {
470         predicates.EqualTo("is_deleted", "0");
471         predicates.And();
472         predicates.EqualTo("contact_id", std::to_string(value));
473         HolderPredicates(holder, predicates);
474     }
475     return predicates;
476 }
477 
478 /**
479  * @brief Resolve object interface in QUERY_MY_CARD case
480  *
481  * @param env Conditions for resolve object interface operation
482  * @param attr Conditions for resolve object interface operation
483  */
BuildQueryMyCardPredicates(napi_env env,napi_value attr)484 DataShare::DataSharePredicates BuildQueryMyCardPredicates(napi_env env, napi_value attr)
485 {
486     ContactsBuild contactsBuild;
487     ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attr);
488     DataShare::DataSharePredicates predicates;
489     unsigned int size = attrs.attributes.size();
490     predicates.EqualTo("is_deleted", "0");
491     if (size > 0) {
492         predicates.And();
493     }
494     for (unsigned int i = 0; i < size; ++i) {
495         predicates.EqualTo("type_id", std::to_string(attrs.attributes[i]));
496         if (i != size - 1) {
497             predicates.Or();
498         }
499     }
500     return predicates;
501 }
502 
BuildQueryContactData(napi_env env,napi_value & contactObject,napi_value & attrObject,std::vector<DataShare::DataShareValuesBucket> & valueContactData)503 DataShare::DataSharePredicates BuildQueryContactData(napi_env env, napi_value &contactObject, napi_value &attrObject,
504     std::vector<DataShare::DataShareValuesBucket> &valueContactData)
505 {
506     ContactsBuild contactsBuild;
507     Contacts contact;
508     contactsBuild.GetContactDataByObject(env, contactObject, contact);
509     ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attrObject);
510     CheckAttributes(attrs);
511     DataShare::DataSharePredicates predicates;
512     std::vector<std::string> fields;
513     fields.push_back("raw_contact_id");
514     if (contact.id != 0) {
515         predicates.EqualTo("is_deleted", "0");
516         predicates.And();
517         predicates.EqualTo("contact_id", std::to_string(contact.id));
518         predicates.GroupBy(fields);
519     }
520     unsigned int size = attrs.attributes.size();
521     for (unsigned int i = 0; i < size; i++) {
522         contactsBuild.BuildValueContactDataByType(contact, attrs.attributes[i], valueContactData);
523     }
524     return predicates;
525 }
526 
BuildUpdateContactColumns()527 std::vector<std::string> BuildUpdateContactColumns()
528 {
529     std::vector<std::string> columns;
530     columns.push_back("raw_contact_id");
531     return columns;
532 }
533 
GetRawIdByResultSet(const std::shared_ptr<DataShare::DataShareResultSet> & resultSet)534 int GetRawIdByResultSet(const std::shared_ptr<DataShare::DataShareResultSet> &resultSet)
535 {
536     if (resultSet == nullptr) {
537         return -1;
538     }
539     int resultSetNum = resultSet->GoToFirstRow();
540     int intValue = 0;
541     while (resultSetNum == OHOS::NativeRdb::E_OK) {
542         resultSet->GetInt(0, intValue);
543         resultSetNum = resultSet->GoToNextRow();
544     }
545     resultSet->Close();
546     return intValue;
547 }
548 
BuildUpdateContactConvertParams(napi_env env,napi_value & contact,napi_value & attr,ExecuteHelper * executeHelper)549 DataShare::DataSharePredicates BuildUpdateContactConvertParams(napi_env env, napi_value &contact,
550     napi_value &attr, ExecuteHelper *executeHelper)
551 {
552     executeHelper->valueContactData.clear();
553     DataShare::DataSharePredicates predicates =
554         BuildQueryContactData(env, contact, attr, executeHelper->valueContactData);
555     executeHelper->columns = BuildUpdateContactColumns();
556     executeHelper->deletePredicates = BuildDeleteContactDataPredicates(env, attr);
557     return predicates;
558 }
559 
BuildDeleteContactDataPredicates(napi_env env,napi_value attr)560 DataShare::DataSharePredicates BuildDeleteContactDataPredicates(napi_env env, napi_value attr)
561 {
562     ContactsBuild contactsBuild;
563     ContactAttributes attrs = contactsBuild.GetContactAttributes(env, attr);
564     CheckAttributes(attrs);
565     DataShare::DataSharePredicates predicates;
566     AttributesPredicates(true, attrs, predicates);
567     return predicates;
568 }
569 
570 /**
571  * @brief Resolve object interface in IS_LOCAL_CONTACT case
572  *
573  * @param env Conditions for resolve object interface operation
574  * @param id Conditions for resolve object interface operation
575  */
BuildIsLocalContactPredicates(napi_env env,napi_value id)576 DataShare::DataSharePredicates BuildIsLocalContactPredicates(napi_env env, napi_value id)
577 {
578     ContactsBuild contactsBuild;
579     int value = contactsBuild.GetInt(env, id);
580     DataShare::DataSharePredicates predicates;
581     if (value != 0) {
582         predicates.EqualTo("is_deleted", "0");
583         predicates.And();
584         predicates.EqualTo("contact_id", std::to_string(value));
585         predicates.And();
586         predicates.EqualTo("account_type", "com.ohos.contacts");
587         predicates.And();
588         predicates.EqualTo("account_name", "phone");
589     }
590     return predicates;
591 }
592 
593 /**
594  * @brief Resolve object interface in IS_MY_CARD case
595  *
596  * @param env Conditions for resolve object interface operation
597  * @param id Conditions for resolve object interface operation
598  */
BuildIsMyCardPredicates(napi_env env,napi_value id)599 DataShare::DataSharePredicates BuildIsMyCardPredicates(napi_env env, napi_value id)
600 {
601     ContactsBuild contactsBuild;
602     int value = contactsBuild.GetInt(env, id);
603     DataShare::DataSharePredicates predicates;
604     if (value != 0) {
605         predicates.EqualTo("is_deleted", "0");
606         predicates.And();
607         predicates.EqualTo("contact_id", std::to_string(value));
608     }
609     return predicates;
610 }
611 
ExecuteDone(napi_env env,napi_status status,void * data)612 void ExecuteDone(napi_env env, napi_status status, void *data)
613 {
614     ExecuteHelper *executeHelper = reinterpret_cast<ExecuteHelper *>(data);
615     HILOG_INFO("ExecuteDone workName: %{public}d", executeHelper->actionCode);
616     napi_value result = nullptr;
617     HandleExecuteResult(env, executeHelper, result);
618     napi_deferred deferred = executeHelper->deferred;
619     executeHelper->deferred = nullptr;
620     NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, deferred, result));
621     NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, executeHelper->work));
622     if (executeHelper->dataShareHelper != nullptr) {
623         executeHelper->dataShareHelper->Release();
624         executeHelper->dataShareHelper = nullptr;
625     }
626     delete executeHelper;
627     executeHelper = nullptr;
628 }
629 
ExecuteSyncDone(napi_env env,napi_status status,void * data)630 void ExecuteSyncDone(napi_env env, napi_status status, void *data)
631 {
632     if (status != napi_ok) {
633         HILOG_ERROR("ExecuteSyncDone status is not ok===>");
634         return;
635     }
636     if (data != nullptr) {
637         ExecuteHelper *executeHelper = reinterpret_cast<ExecuteHelper *>(data);
638         HILOG_INFO("ExecuteSyncDone workName: %{public}d", executeHelper->actionCode);
639         napi_value global;
640         napi_get_global(env, &global);
641         napi_value resultData[RESULT_DATA_SIZE];
642         if (executeHelper->resultData < 0) {
643             HandleExecuteResult(env, executeHelper, resultData[0]);
644             napi_get_undefined(env, &resultData[1]);
645         } else {
646             napi_get_undefined(env, &resultData[0]);
647             HandleExecuteResult(env, executeHelper, resultData[1]);
648         }
649         napi_value result;
650         napi_value callBack;
651         napi_get_reference_value(env, executeHelper->callBack, &callBack);
652         napi_valuetype valuetype = napi_undefined;
653         napi_typeof(env, callBack, &valuetype);
654         if (valuetype != napi_function) {
655             HILOG_ERROR("contactApi params not is function");
656             return;
657         }
658         napi_call_function(env, global, callBack, RESULT_DATA_SIZE, resultData, &result);
659         if (executeHelper->work != nullptr) {
660             napi_delete_async_work(env, executeHelper->work);
661         }
662         executeHelper->work = nullptr;
663         executeHelper->deferred = nullptr;
664         if (executeHelper->dataShareHelper != nullptr) {
665             executeHelper->dataShareHelper->Release();
666             executeHelper->dataShareHelper = nullptr;
667         }
668         delete executeHelper;
669     }
670     HILOG_INFO("contactApi ExecuteSyncDone done===>");
671 }
672 
HandleExecuteResult(napi_env env,ExecuteHelper * executeHelper,napi_value & result)673 void HandleExecuteResult(napi_env env, ExecuteHelper *executeHelper, napi_value &result)
674 {
675     ResultConvert resultConvert;
676     napi_value results = nullptr;
677     switch (executeHelper->actionCode) {
678         case ADD_CONTACT:
679         case DELETE_CONTACT:
680         case UPDATE_CONTACT:
681         case SELECT_CONTACT:
682             napi_create_int64(env, executeHelper->resultData, &result);
683             break;
684         case IS_LOCAL_CONTACT:
685         case IS_MY_CARD:
686             napi_get_boolean(env, executeHelper->resultData != 0, &result);
687             break;
688         case QUERY_CONTACT:
689         case QUERY_MY_CARD:
690             results = resultConvert.ResultSetToObject(env, executeHelper->resultSet);
691             if (results != nullptr) {
692                 napi_get_element(env, results, 0, &result);
693             }
694             break;
695         case QUERY_KEY:
696             results = resultConvert.ResultSetToObject(env, executeHelper->resultSet);
697             if (results != nullptr) {
698                 napi_get_element(env, results, 0, &result);
699             }
700             napi_get_named_property(env, result, "key", &result);
701             break;
702         case QUERY_CONTACTS:
703         case QUERY_CONTACTS_BY_EMAIL:
704         case QUERY_CONTACTS_BY_PHONE_NUMBER:
705             result = resultConvert.ResultSetToObject(env, executeHelper->resultSet);
706             break;
707         case QUERY_GROUPS:
708             result = resultConvert.ResultSetToGroup(env, executeHelper->resultSet);
709             break;
710         case QUERY_HOLDERS:
711             result = resultConvert.ResultSetToHolder(env, executeHelper->resultSet);
712             break;
713         default:
714             break;
715     }
716 }
717 
LocalExecuteAddContact(napi_env env,ExecuteHelper * executeHelper)718 void LocalExecuteAddContact(napi_env env, ExecuteHelper *executeHelper)
719 {
720     ContactsControl contactsControl;
721     int rawId = contactsControl.RawContactInsert(
722         executeHelper->dataShareHelper, (executeHelper->valueContact)[0]);
723     std::vector<DataShare::DataShareValuesBucket> value = executeHelper->valueContactData;
724     unsigned int size = value.size();
725     for (unsigned int i = 0; i < size; ++i) {
726         (executeHelper->valueContactData)[i].Put("raw_contact_id", rawId);
727     }
728     int code = contactsControl.ContactDataInsert(executeHelper->dataShareHelper, executeHelper->valueContactData);
729     if (code == 0) {
730         executeHelper->resultData = rawId;
731     } else {
732         executeHelper->resultData = code;
733     }
734 }
735 
LocalExecuteDeleteContact(napi_env env,ExecuteHelper * executeHelper)736 void LocalExecuteDeleteContact(napi_env env, ExecuteHelper *executeHelper)
737 {
738     ContactsControl contactsControl;
739     int ret = contactsControl.ContactDelete(executeHelper->dataShareHelper, executeHelper->predicates);
740     HILOG_INFO("LocalExecuteDeleteContact contact ret = %{public}d", ret);
741     executeHelper->resultData = ret;
742 }
743 
LocalExecuteQueryContact(napi_env env,ExecuteHelper * executeHelper)744 void LocalExecuteQueryContact(napi_env env, ExecuteHelper *executeHelper)
745 {
746     ContactsControl contactsControl;
747     executeHelper->resultSet = contactsControl.ContactQuery(
748         executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
749     executeHelper->resultData = SUCCESS;
750 }
751 
LocalExecuteQueryContactsOrKey(napi_env env,ExecuteHelper * executeHelper)752 void LocalExecuteQueryContactsOrKey(napi_env env, ExecuteHelper *executeHelper)
753 {
754     ContactsControl contactsControl;
755     executeHelper->resultSet = contactsControl.ContactQuery(
756         executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
757     executeHelper->resultData = SUCCESS;
758 }
759 
LocalExecuteQueryContactsByData(napi_env env,ExecuteHelper * executeHelper)760 void LocalExecuteQueryContactsByData(napi_env env, ExecuteHelper *executeHelper)
761 {
762     ContactsControl contactsControl;
763     executeHelper->resultSet = contactsControl.ContactDataQuery(
764         executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
765     executeHelper->resultData = SUCCESS;
766 }
767 
LocalExecuteQueryGroup(napi_env env,ExecuteHelper * executeHelper)768 void LocalExecuteQueryGroup(napi_env env, ExecuteHelper *executeHelper)
769 {
770     ContactsControl contactsControl;
771     executeHelper->resultSet = contactsControl.GroupsQuery(
772         executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
773     executeHelper->resultData = SUCCESS;
774 }
775 
LocalExecuteQueryHolders(napi_env env,ExecuteHelper * executeHelper)776 void LocalExecuteQueryHolders(napi_env env, ExecuteHelper *executeHelper)
777 {
778     ContactsControl contactsControl;
779     executeHelper->resultSet = contactsControl.HolderQuery(
780         executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
781     executeHelper->resultData = SUCCESS;
782 }
783 
LocalExecuteQueryMyCard(napi_env env,ExecuteHelper * executeHelper)784 void LocalExecuteQueryMyCard(napi_env env, ExecuteHelper *executeHelper)
785 {
786     ContactsControl contactsControl;
787     executeHelper->resultSet = contactsControl.MyCardQuery(
788         executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
789     executeHelper->resultData = SUCCESS;
790 }
791 
LocalExecuteUpdateContact(napi_env env,ExecuteHelper * executeHelper)792 void LocalExecuteUpdateContact(napi_env env, ExecuteHelper *executeHelper)
793 {
794     ContactsControl contactsControl;
795     // query raw_contact_id
796     std::shared_ptr<DataShare::DataShareResultSet> resultSet = contactsControl.ContactDataQuery(
797         executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
798     int rawId = GetRawIdByResultSet(resultSet);
799     if (rawId == 0) {
800         HILOG_ERROR("LocalExecuteUpdateContact contact rawId equals 0");
801         executeHelper->resultData = ERROR;
802         return;
803     }
804     std::vector<DataShare::DataShareValuesBucket> value = executeHelper->valueContactData;
805     unsigned int size = value.size();
806     for (unsigned int i = 0; i < size; ++i) {
807         (executeHelper->valueContactData)[i].Put("raw_contact_id", rawId);
808     }
809     executeHelper->deletePredicates.And();
810     executeHelper->deletePredicates.EqualTo("raw_contact_id", std::to_string(rawId));
811     int resultCode = contactsControl.ContactDataDelete(
812         executeHelper->dataShareHelper, executeHelper->deletePredicates);
813     if (resultCode >= 0) {
814         resultCode = contactsControl.ContactDataInsert(
815             executeHelper->dataShareHelper, executeHelper->valueContactData);
816     }
817     executeHelper->resultData = resultCode;
818 }
819 
LocalExecuteIsLocalContact(napi_env env,ExecuteHelper * executeHelper)820 void LocalExecuteIsLocalContact(napi_env env, ExecuteHelper *executeHelper)
821 {
822     int64_t isLocal = 0;
823     ContactsControl contactsControl;
824     std::shared_ptr<DataShare::DataShareResultSet> resultSet = contactsControl.ContactQuery(
825         executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
826     if (resultSet == nullptr) {
827         executeHelper->resultData = isLocal;
828         return;
829     }
830     int resultSetNum = resultSet->GoToFirstRow();
831     if (resultSetNum == OHOS::NativeRdb::E_OK) {
832         isLocal = 1;
833     }
834     executeHelper->resultData = isLocal;
835     resultSet->Close();
836 }
837 
LocalExecuteIsMyCard(napi_env env,ExecuteHelper * executeHelper)838 void LocalExecuteIsMyCard(napi_env env, ExecuteHelper *executeHelper)
839 {
840     int64_t isMyCard = 0;
841     ContactsControl contactsControl;
842     std::shared_ptr<DataShare::DataShareResultSet> resultSet = contactsControl.MyCardQuery(
843         executeHelper->dataShareHelper, executeHelper->columns, executeHelper->predicates);
844     if (resultSet == nullptr) {
845         executeHelper->resultData = isMyCard;
846         return;
847     }
848     int rowCount = 0;
849     resultSet->GetRowCount(rowCount);
850     int resultSetNum = resultSet->GoToFirstRow();
851     if (resultSetNum == OHOS::NativeRdb::E_OK) {
852         isMyCard = 1;
853     }
854     executeHelper->resultData = isMyCard;
855     resultSet->Close();
856 }
857 
LocalExecute(napi_env env,ExecuteHelper * executeHelper)858 void LocalExecute(napi_env env, ExecuteHelper *executeHelper)
859 {
860     if (executeHelper->dataShareHelper == nullptr) {
861         HILOG_ERROR("create dataShareHelper is null, please check your permission");
862         executeHelper->resultData = ERROR;
863         return;
864     }
865     switch (executeHelper->actionCode) {
866         case ADD_CONTACT:
867             LocalExecuteAddContact(env, executeHelper);
868             break;
869         case DELETE_CONTACT:
870             LocalExecuteDeleteContact(env, executeHelper);
871             break;
872         case QUERY_CONTACT:
873             LocalExecuteQueryContact(env, executeHelper);
874             break;
875         case QUERY_CONTACTS:
876             LocalExecuteQueryContactsOrKey(env, executeHelper);
877             break;
878         case QUERY_CONTACTS_BY_EMAIL:
879         case QUERY_CONTACTS_BY_PHONE_NUMBER:
880             LocalExecuteQueryContactsByData(env, executeHelper);
881             break;
882         case QUERY_GROUPS:
883             LocalExecuteQueryGroup(env, executeHelper);
884             break;
885         case QUERY_HOLDERS:
886             LocalExecuteQueryHolders(env, executeHelper);
887             break;
888         case QUERY_KEY:
889             LocalExecuteQueryContactsOrKey(env, executeHelper);
890             break;
891         case QUERY_MY_CARD:
892             LocalExecuteQueryMyCard(env, executeHelper);
893             break;
894         case UPDATE_CONTACT:
895             LocalExecuteUpdateContact(env, executeHelper);
896             break;
897         case IS_LOCAL_CONTACT:
898             LocalExecuteIsLocalContact(env, executeHelper);
899             break;
900         case IS_MY_CARD:
901             LocalExecuteIsMyCard(env, executeHelper);
902             break;
903         default:
904             HILOG_INFO("LocalExecute case error===>");
905             break;
906     }
907 }
908 
Execute(napi_env env,void * data)909 void Execute(napi_env env, void *data)
910 {
911     ExecuteHelper *executeHelper = static_cast<ExecuteHelper *>(data);
912     HILOG_INFO("Execute start workName: %{public}d", executeHelper->actionCode);
913     LocalExecute(env, executeHelper);
914 }
915 
CreateAsyncWork(napi_env env,ExecuteHelper * executeHelper)916 napi_value CreateAsyncWork(napi_env env, ExecuteHelper *executeHelper)
917 {
918     napi_value workName;
919     napi_value result = nullptr;
920     if (executeHelper->sync == NAPI_CALL_TYPE_CALLBACK) {
921         napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &workName);
922         napi_create_reference(env, executeHelper->argv[executeHelper->argc - 1], 1, &executeHelper->callBack);
923         napi_create_async_work(env, nullptr, workName, Execute, ExecuteSyncDone,
924             reinterpret_cast<void *>(executeHelper), &(executeHelper->work));
925         napi_get_null(env, &result);
926     } else {
927         napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &workName);
928         napi_create_promise(env, &(executeHelper->deferred), &result);
929         napi_create_async_work(env, nullptr, workName, Execute, ExecuteDone,
930             reinterpret_cast<void *>(executeHelper), &(executeHelper->work));
931     }
932     napi_queue_async_work(env, executeHelper->work);
933     executeHelper->promise = result;
934     return result;
935 }
936 
ConvertParamsSwitchSplit(int code,napi_env env,const napi_value & key,const napi_value & hold,const napi_value & attr)937 DataShare::DataSharePredicates ConvertParamsSwitchSplit(
938     int code, napi_env env, const napi_value &key, const napi_value &hold, const napi_value &attr)
939 {
940     DataShare::DataSharePredicates predicates;
941     switch (code) {
942         case QUERY_CONTACT:
943             predicates = BuildQueryContactPredicates(env, key, hold, attr);
944             break;
945         case QUERY_CONTACTS:
946             predicates = BuildQueryContactsPredicates(env, hold, attr);
947             break;
948         case QUERY_CONTACTS_BY_EMAIL:
949             predicates = BuildQueryContactsByEmailPredicates(env, key, hold, attr);
950             break;
951         case QUERY_CONTACTS_BY_PHONE_NUMBER:
952             predicates = BuildQueryContactsByPhoneNumberPredicates(env, key, hold, attr);
953             break;
954         case QUERY_GROUPS:
955             predicates = BuildQueryGroupsPredicates(env, hold);
956             break;
957         case QUERY_HOLDERS:
958             break;
959         case QUERY_MY_CARD:
960             predicates = BuildQueryMyCardPredicates(env, attr);
961             break;
962         default:
963             HILOG_ERROR("ConvertParamsSwitchSplit code is no match");
964             break;
965     }
966     return predicates;
967 }
968 
SetChildActionCodeAndConvertParams(napi_env env,ExecuteHelper * executeHelper)969 void SetChildActionCodeAndConvertParams(napi_env env, ExecuteHelper *executeHelper)
970 {
971     napi_value id = nullptr;
972     napi_value key = nullptr;
973     napi_value hold = nullptr;
974     napi_value attr = nullptr;
975     napi_value contact = nullptr;
976     unsigned int size = executeHelper->argc;
977     for (unsigned int i = 0; i < size; i++) {
978         ObjectInitId(env, executeHelper->argv[i], id);
979         ObjectInitString(env, executeHelper->argv[i], key);
980         ObjectInit(env, executeHelper->argv[i], hold, attr, contact);
981     }
982     ContactsBuild contactsBuild;
983     switch (executeHelper->actionCode) {
984         case ADD_CONTACT:
985             contactsBuild.GetContactData(
986                 env, executeHelper->argv[0], executeHelper->valueContact, executeHelper->valueContactData);
987             break;
988         case DELETE_CONTACT:
989             executeHelper->predicates = BuildDeleteContactPredicates(env, executeHelper);
990             break;
991         case UPDATE_CONTACT:
992             executeHelper->predicates = BuildUpdateContactConvertParams(env, contact, attr, executeHelper);
993             break;
994         case IS_LOCAL_CONTACT:
995             executeHelper->predicates = BuildIsLocalContactPredicates(env, id);
996             break;
997         case IS_MY_CARD:
998             executeHelper->predicates = BuildIsMyCardPredicates(env, id);
999             break;
1000         case QUERY_KEY:
1001             executeHelper->predicates = BuildQueryKeyPredicates(env, id, hold);
1002             break;
1003         default:
1004             executeHelper->predicates = ConvertParamsSwitchSplit(executeHelper->actionCode, env, key, hold, attr);
1005             break;
1006     }
1007 }
1008 
Scheduling(napi_env env,napi_callback_info info,ExecuteHelper * executeHelper,int actionCode)1009 napi_value Scheduling(napi_env env, napi_callback_info info, ExecuteHelper *executeHelper, int actionCode)
1010 {
1011     size_t argc = MAX_PARAMS;
1012     napi_get_cb_info(env, info, &argc, executeHelper->argv, nullptr, nullptr);
1013     executeHelper->argc = argc;
1014     executeHelper->actionCode = actionCode;
1015 
1016     if (argc > 0) {
1017         napi_valuetype valuetype = napi_undefined;
1018         napi_typeof(env, executeHelper->argv[argc - 1], &valuetype);
1019         // last params is function as callback
1020         if (valuetype == napi_function) {
1021             executeHelper->sync = NAPI_CALL_TYPE_CALLBACK;
1022         } else {
1023             executeHelper->sync = NAPI_CALL_TYPE_PROMISE;
1024         }
1025     }
1026     SetChildActionCodeAndConvertParams(env, executeHelper);
1027     executeHelper->dataShareHelper = GetDataShareHelper(env, info);
1028 
1029     napi_value result = CreateAsyncWork(env, executeHelper);
1030     return result;
1031 }
1032 
1033 /**
1034  * @brief Test interface ADD_CONTACT
1035  *
1036  * @param env Conditions for resolve object interface operation
1037  * @param info Conditions for resolve object interface operation
1038  *
1039  * @return The result returned by test
1040  */
AddContact(napi_env env,napi_callback_info info)1041 napi_value AddContact(napi_env env, napi_callback_info info)
1042 {
1043     ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1044     napi_value result = nullptr;
1045     if (executeHelper != nullptr) {
1046         result = Scheduling(env, info, executeHelper, ADD_CONTACT);
1047         return result;
1048     }
1049     napi_create_int64(env, ERROR, &result);
1050     return result;
1051 }
1052 
1053 /**
1054  * @brief Test interface DELETE_CONTACT
1055  *
1056  * @param env Conditions for resolve object interface operation
1057  * @param info Conditions for resolve object interface operation
1058  *
1059  * @return The result returned by test
1060  */
DeleteContact(napi_env env,napi_callback_info info)1061 napi_value DeleteContact(napi_env env, napi_callback_info info)
1062 {
1063     ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1064     napi_value result = nullptr;
1065     if (executeHelper != nullptr) {
1066         result = Scheduling(env, info, executeHelper, DELETE_CONTACT);
1067         return result;
1068     }
1069     napi_create_int64(env, ERROR, &result);
1070     return result;
1071 }
1072 
1073 /**
1074  * @brief Test interface UPDATE_CONTACT
1075  *
1076  * @param env Conditions for resolve object interface operation
1077  * @param info Conditions for resolve object interface operation
1078  *
1079  * @return The result returned by test
1080  */
UpdateContact(napi_env env,napi_callback_info info)1081 napi_value UpdateContact(napi_env env, napi_callback_info info)
1082 {
1083     ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1084     napi_value result = nullptr;
1085     if (executeHelper != nullptr) {
1086         result = Scheduling(env, info, executeHelper, UPDATE_CONTACT);
1087         return result;
1088     }
1089     napi_create_int64(env, ERROR, &result);
1090     return result;
1091 }
1092 
1093 /**
1094  * @brief Test interface QUERY_CONTACT
1095  *
1096  * @param env Conditions for resolve object interface operation
1097  * @param info Conditions for resolve object interface operation
1098  *
1099  * @return The result returned by test
1100  */
QueryContact(napi_env env,napi_callback_info info)1101 napi_value QueryContact(napi_env env, napi_callback_info info)
1102 {
1103     ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1104     napi_value result = nullptr;
1105     if (executeHelper != nullptr) {
1106         result = Scheduling(env, info, executeHelper, QUERY_CONTACT);
1107         return result;
1108     }
1109     napi_create_int64(env, ERROR, &result);
1110     return result;
1111 }
1112 
1113 /**
1114  * @brief Test interface QUERY_CONTACTS
1115  *
1116  * @param env Conditions for resolve object interface operation
1117  * @param info Conditions for resolve object interface operation
1118  *
1119  * @return The result returned by test
1120  */
QueryContacts(napi_env env,napi_callback_info info)1121 napi_value QueryContacts(napi_env env, napi_callback_info info)
1122 {
1123     ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1124     napi_value result = nullptr;
1125     if (executeHelper != nullptr) {
1126         result = Scheduling(env, info, executeHelper, QUERY_CONTACTS);
1127         return result;
1128     }
1129     napi_create_int64(env, ERROR, &result);
1130     return result;
1131 }
1132 
1133 /**
1134  * @brief Test interface QUERY_CONTACTS_BY_EMAIL
1135  *
1136  * @param env Conditions for resolve object interface operation
1137  * @param info Conditions for resolve object interface operation
1138  *
1139  * @return The result returned by test
1140  */
QueryContactsByEmail(napi_env env,napi_callback_info info)1141 napi_value QueryContactsByEmail(napi_env env, napi_callback_info info)
1142 {
1143     ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1144     napi_value result = nullptr;
1145     if (executeHelper != nullptr) {
1146         result = Scheduling(env, info, executeHelper, QUERY_CONTACTS_BY_EMAIL);
1147         return result;
1148     }
1149     napi_create_int64(env, ERROR, &result);
1150     return result;
1151 }
1152 
1153 /**
1154  * @brief Test interface QUERY_CONTACTS_BY_PHONE_NUMBER
1155  *
1156  * @param env Conditions for resolve object interface operation
1157  * @param info Conditions for resolve object interface operation
1158  *
1159  * @return The result returned by test
1160  */
QueryContactsByPhoneNumber(napi_env env,napi_callback_info info)1161 napi_value QueryContactsByPhoneNumber(napi_env env, napi_callback_info info)
1162 {
1163     ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1164     napi_value result = nullptr;
1165     if (executeHelper != nullptr) {
1166         result = Scheduling(env, info, executeHelper, QUERY_CONTACTS_BY_PHONE_NUMBER);
1167         return result;
1168     }
1169     napi_create_int64(env, ERROR, &result);
1170     return result;
1171 }
1172 
1173 /**
1174  * @brief Test interface QUERY_CONTACTS_BY_PHONE_NUMBER
1175  *
1176  * @param env Conditions for resolve object interface operation
1177  * @param info Conditions for resolve object interface operation
1178  *
1179  * @return The result returned by test
1180  */
QueryGroups(napi_env env,napi_callback_info info)1181 napi_value QueryGroups(napi_env env, napi_callback_info info)
1182 {
1183     ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1184     napi_value result = nullptr;
1185     if (executeHelper != nullptr) {
1186         result = Scheduling(env, info, executeHelper, QUERY_GROUPS);
1187         return result;
1188     }
1189     napi_create_int64(env, ERROR, &result);
1190     return result;
1191 }
1192 
1193 /**
1194  * @brief Test interface QUERY_HOLDERS
1195  *
1196  * @param env Conditions for resolve object interface operation
1197  * @param info Conditions for resolve object interface operation
1198  *
1199  * @return The result returned by test
1200  */
QueryHolders(napi_env env,napi_callback_info info)1201 napi_value QueryHolders(napi_env env, napi_callback_info info)
1202 {
1203     ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1204     napi_value result = nullptr;
1205     if (executeHelper != nullptr) {
1206         result = Scheduling(env, info, executeHelper, QUERY_HOLDERS);
1207         return result;
1208     }
1209     napi_create_int64(env, ERROR, &result);
1210     return result;
1211 }
1212 
1213 /**
1214  * @brief Test interface QUERY_KEY
1215  *
1216  * @param env Conditions for resolve object interface operation
1217  * @param info Conditions for resolve object interface operation
1218  *
1219  * @return The result returned by test
1220  */
QueryKey(napi_env env,napi_callback_info info)1221 napi_value QueryKey(napi_env env, napi_callback_info info)
1222 {
1223     ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1224     napi_value result = nullptr;
1225     if (executeHelper != nullptr) {
1226         result = Scheduling(env, info, executeHelper, QUERY_KEY);
1227         return result;
1228     }
1229     napi_create_int64(env, ERROR, &result);
1230     return result;
1231 }
1232 
1233 /**
1234  * @brief Test interface QUERY_MY_CARD
1235  *
1236  * @param env Conditions for resolve object interface operation
1237  * @param info Conditions for resolve object interface operation
1238  *
1239  * @return The result returned by test
1240  */
QueryMyCard(napi_env env,napi_callback_info info)1241 napi_value QueryMyCard(napi_env env, napi_callback_info info)
1242 {
1243     ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1244     napi_value result = nullptr;
1245     if (executeHelper != nullptr) {
1246         result = Scheduling(env, info, executeHelper, QUERY_MY_CARD);
1247         return result;
1248     }
1249     napi_create_int64(env, ERROR, &result);
1250     return result;
1251 }
1252 
1253 /**
1254  * @brief Test interface IS_MY_CARD
1255  *
1256  * @param env Conditions for resolve object interface operation
1257  * @param info Conditions for resolve object interface operation
1258  *
1259  * @return The result returned by test
1260  */
IsMyCard(napi_env env,napi_callback_info info)1261 napi_value IsMyCard(napi_env env, napi_callback_info info)
1262 {
1263     ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1264     napi_value result = nullptr;
1265     if (executeHelper != nullptr) {
1266         result = Scheduling(env, info, executeHelper, IS_MY_CARD);
1267         return result;
1268     }
1269     napi_create_int64(env, ERROR, &result);
1270     return result;
1271 }
1272 
1273 /**
1274  * @brief Test interface IS_LOCAL_CONTACT
1275  *
1276  * @param env Conditions for resolve object interface operation
1277  * @param info Conditions for resolve object interface operation
1278  *
1279  * @return The result returned by test
1280  */
IsLocalContact(napi_env env,napi_callback_info info)1281 napi_value IsLocalContact(napi_env env, napi_callback_info info)
1282 {
1283     ExecuteHelper *executeHelper = new (std::nothrow) ExecuteHelper();
1284     napi_value result = nullptr;
1285     if (executeHelper != nullptr) {
1286         result = Scheduling(env, info, executeHelper, IS_LOCAL_CONTACT);
1287         return result;
1288     }
1289     napi_create_int64(env, ERROR, &result);
1290     return result;
1291 }
1292 
DeclareContactConst(napi_env env,napi_value exports)1293 napi_value DeclareContactConst(napi_env env, napi_value exports)
1294 {
1295     // Contact
1296     napi_property_descriptor desc[] = {
1297         DECLARE_NAPI_STATIC_PROPERTY("INVALID_CONTACT_ID",
1298             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Contacts::INVALID_CONTACT_ID))),
1299     };
1300     napi_value result = nullptr;
1301     napi_define_class(env, "Contact", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1302         sizeof(desc) / sizeof(*desc), desc, &result);
1303     napi_set_named_property(env, exports, "Contact", result);
1304     return exports;
1305 }
1306 
DeclareEmailConst(napi_env env,napi_value exports)1307 napi_value DeclareEmailConst(napi_env env, napi_value exports)
1308 {
1309     // Email
1310     napi_property_descriptor desc[] = {
1311         DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
1312             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Email::CUSTOM_LABEL))),
1313         DECLARE_NAPI_STATIC_PROPERTY("EMAIL_HOME",
1314             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Email::EMAIL_HOME))),
1315         DECLARE_NAPI_STATIC_PROPERTY("EMAIL_WORK",
1316             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Email::EMAIL_WORK))),
1317         DECLARE_NAPI_STATIC_PROPERTY("EMAIL_OTHER",
1318             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Email::EMAIL_OTHER))),
1319         DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
1320             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Email::INVALID_LABEL_ID))),
1321     };
1322     napi_value result = nullptr;
1323     napi_define_class(env, "Email", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1324         sizeof(desc) / sizeof(*desc), desc, &result);
1325     napi_set_named_property(env, exports, "Email", result);
1326     return exports;
1327 }
1328 
DeclareEventConst(napi_env env,napi_value exports)1329 napi_value DeclareEventConst(napi_env env, napi_value exports)
1330 {
1331     // Event
1332     napi_property_descriptor desc[] = {
1333         DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
1334             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Event::CUSTOM_LABEL))),
1335         DECLARE_NAPI_STATIC_PROPERTY("EVENT_ANNIVERSARY",
1336             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Event::EVENT_ANNIVERSARY))),
1337         DECLARE_NAPI_STATIC_PROPERTY("EVENT_OTHER",
1338             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Event::EVENT_OTHER))),
1339         DECLARE_NAPI_STATIC_PROPERTY("EVENT_BIRTHDAY",
1340             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Event::EVENT_BIRTHDAY))),
1341         DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
1342             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Event::INVALID_LABEL_ID))),
1343     };
1344     napi_value result = nullptr;
1345     napi_define_class(env, "Event", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1346         sizeof(desc) / sizeof(*desc), desc, &result);
1347     napi_set_named_property(env, exports, "Event", result);
1348     return exports;
1349 }
1350 
DeclareImAddressConst(napi_env env,napi_value exports)1351 napi_value DeclareImAddressConst(napi_env env, napi_value exports)
1352 {
1353     // ImAddress
1354     napi_property_descriptor desc[] = {
1355         DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
1356             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::CUSTOM_LABEL))),
1357         DECLARE_NAPI_STATIC_PROPERTY("IM_AIM",
1358             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_AIM))),
1359         DECLARE_NAPI_STATIC_PROPERTY("IM_MSN",
1360             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_MSN))),
1361         DECLARE_NAPI_STATIC_PROPERTY("IM_YAHOO",
1362             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_YAHOO))),
1363         DECLARE_NAPI_STATIC_PROPERTY("IM_SKYPE",
1364             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_SKYPE))),
1365         DECLARE_NAPI_STATIC_PROPERTY("IM_QQ",
1366             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_QQ))),
1367         DECLARE_NAPI_STATIC_PROPERTY("IM_ICQ",
1368             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_ICQ))),
1369         DECLARE_NAPI_STATIC_PROPERTY("IM_JABBER",
1370             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::IM_JABBER))),
1371         DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
1372             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(ImAddress::INVALID_LABEL_ID))),
1373     };
1374     napi_value result = nullptr;
1375     napi_define_class(env, "ImAddress", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1376         sizeof(desc) / sizeof(*desc), desc, &result);
1377     napi_set_named_property(env, exports, "ImAddress", result);
1378     return exports;
1379 }
1380 
DeclarePhoneNumberConst(napi_env env,napi_value exports)1381 napi_value DeclarePhoneNumberConst(napi_env env, napi_value exports)
1382 {
1383     // PhoneNumber
1384     napi_property_descriptor desc[] = {
1385         DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
1386             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::CUSTOM_LABEL))),
1387         DECLARE_NAPI_STATIC_PROPERTY("NUM_HOME",
1388             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_HOME))),
1389         DECLARE_NAPI_STATIC_PROPERTY("NUM_MOBILE",
1390             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_MOBILE))),
1391         DECLARE_NAPI_STATIC_PROPERTY("NUM_WORK",
1392             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_WORK))),
1393         DECLARE_NAPI_STATIC_PROPERTY("NUM_FAX_WORK",
1394             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_FAX_WORK))),
1395         DECLARE_NAPI_STATIC_PROPERTY("NUM_FAX_HOME",
1396             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_FAX_HOME))),
1397         DECLARE_NAPI_STATIC_PROPERTY("NUM_PAGER",
1398             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_PAGER))),
1399         DECLARE_NAPI_STATIC_PROPERTY("NUM_OTHER",
1400             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_OTHER))),
1401         DECLARE_NAPI_STATIC_PROPERTY("NUM_CALLBACK",
1402             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_CALLBACK))),
1403         DECLARE_NAPI_STATIC_PROPERTY("NUM_CAR",
1404             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_CAR))),
1405         DECLARE_NAPI_STATIC_PROPERTY("NUM_COMPANY_MAIN",
1406             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_COMPANY_MAIN))),
1407         DECLARE_NAPI_STATIC_PROPERTY("NUM_ISDN",
1408             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_ISDN))),
1409         DECLARE_NAPI_STATIC_PROPERTY("NUM_MAIN",
1410             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_MAIN))),
1411         DECLARE_NAPI_STATIC_PROPERTY("NUM_OTHER_FAX",
1412             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_OTHER_FAX))),
1413         DECLARE_NAPI_STATIC_PROPERTY("NUM_RADIO",
1414             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_RADIO))),
1415         DECLARE_NAPI_STATIC_PROPERTY("NUM_TELEX",
1416             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_TELEX))),
1417         DECLARE_NAPI_STATIC_PROPERTY("NUM_TTY_TDD",
1418             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_TTY_TDD))),
1419         DECLARE_NAPI_STATIC_PROPERTY("NUM_WORK_MOBILE",
1420             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_WORK_MOBILE))),
1421         DECLARE_NAPI_STATIC_PROPERTY("NUM_WORK_PAGER",
1422             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_WORK_PAGER))),
1423         DECLARE_NAPI_STATIC_PROPERTY("NUM_ASSISTANT",
1424             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_ASSISTANT))),
1425         DECLARE_NAPI_STATIC_PROPERTY("NUM_MMS",
1426             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::NUM_MMS))),
1427         DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
1428             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PhoneNumber::INVALID_LABEL_ID))),
1429     };
1430     napi_value result = nullptr;
1431     napi_define_class(env, "PhoneNumber", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1432         sizeof(desc) / sizeof(*desc), desc, &result);
1433     napi_set_named_property(env, exports, "PhoneNumber", result);
1434     return exports;
1435 }
1436 
DeclarePostalAddressConst(napi_env env,napi_value exports)1437 napi_value DeclarePostalAddressConst(napi_env env, napi_value exports)
1438 {
1439     // PostalAddress
1440     napi_property_descriptor desc[] = {
1441         DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
1442             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PostalAddress::CUSTOM_LABEL))),
1443         DECLARE_NAPI_STATIC_PROPERTY("ADDR_HOME",
1444             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PostalAddress::ADDR_HOME))),
1445         DECLARE_NAPI_STATIC_PROPERTY("ADDR_WORK",
1446             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PostalAddress::ADDR_WORK))),
1447         DECLARE_NAPI_STATIC_PROPERTY("ADDR_OTHER",
1448             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PostalAddress::ADDR_OTHER))),
1449         DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
1450             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(PostalAddress::INVALID_LABEL_ID))),
1451     };
1452     napi_value result = nullptr;
1453     napi_define_class(env, "PostalAddress", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1454         sizeof(desc) / sizeof(*desc), desc, &result);
1455     napi_set_named_property(env, exports, "PostalAddress", result);
1456     return exports;
1457 }
1458 
DeclareRelationConst(napi_env env,napi_value exports)1459 napi_value DeclareRelationConst(napi_env env, napi_value exports)
1460 {
1461     // Relation
1462     napi_property_descriptor desc[] = {
1463         DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
1464             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::CUSTOM_LABEL))),
1465         DECLARE_NAPI_STATIC_PROPERTY("RELATION_ASSISTANT",
1466             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_ASSISTANT))),
1467         DECLARE_NAPI_STATIC_PROPERTY("RELATION_BROTHER",
1468             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_BROTHER))),
1469         DECLARE_NAPI_STATIC_PROPERTY("RELATION_CHILD",
1470             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_CHILD))),
1471         DECLARE_NAPI_STATIC_PROPERTY("RELATION_DOMESTIC_PARTNER",
1472             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_DOMESTIC_PARTNER))),
1473         DECLARE_NAPI_STATIC_PROPERTY("RELATION_FATHER",
1474             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_FATHER))),
1475         DECLARE_NAPI_STATIC_PROPERTY("RELATION_FRIEND",
1476             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_FRIEND))),
1477         DECLARE_NAPI_STATIC_PROPERTY("RELATION_MANAGER",
1478             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_MANAGER))),
1479         DECLARE_NAPI_STATIC_PROPERTY("RELATION_MOTHER",
1480             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_MOTHER))),
1481         DECLARE_NAPI_STATIC_PROPERTY("RELATION_PARENT",
1482             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_PARENT))),
1483         DECLARE_NAPI_STATIC_PROPERTY("RELATION_PARTNER",
1484             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_PARTNER))),
1485         DECLARE_NAPI_STATIC_PROPERTY("RELATION_REFERRED_BY",
1486             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_REFERRED_BY))),
1487         DECLARE_NAPI_STATIC_PROPERTY("RELATION_RELATIVE",
1488             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_RELATIVE))),
1489         DECLARE_NAPI_STATIC_PROPERTY("RELATION_SISTER",
1490             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_SISTER))),
1491         DECLARE_NAPI_STATIC_PROPERTY("RELATION_SPOUSE",
1492             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::RELATION_SPOUSE))),
1493         DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
1494             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Relation::INVALID_LABEL_ID))),
1495     };
1496     napi_value result = nullptr;
1497     napi_define_class(env, "Relation", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1498         sizeof(desc) / sizeof(*desc), desc, &result);
1499     napi_set_named_property(env, exports, "Relation", result);
1500     return exports;
1501 }
1502 
DeclareSipAddressConst(napi_env env,napi_value exports)1503 napi_value DeclareSipAddressConst(napi_env env, napi_value exports)
1504 {
1505     // SipAddress
1506     napi_property_descriptor desc[] = {
1507         DECLARE_NAPI_STATIC_PROPERTY("CUSTOM_LABEL",
1508             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(SipAddress::CUSTOM_LABEL))),
1509         DECLARE_NAPI_STATIC_PROPERTY("SIP_HOME",
1510             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(SipAddress::SIP_HOME))),
1511         DECLARE_NAPI_STATIC_PROPERTY("SIP_WORK",
1512             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(SipAddress::SIP_WORK))),
1513         DECLARE_NAPI_STATIC_PROPERTY("SIP_OTHER",
1514             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(SipAddress::SIP_OTHER))),
1515         DECLARE_NAPI_STATIC_PROPERTY("INVALID_LABEL_ID",
1516             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(SipAddress::INVALID_LABEL_ID))),
1517     };
1518     napi_value result = nullptr;
1519     napi_define_class(env, "SipAddress", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1520         sizeof(desc) / sizeof(*desc), desc, &result);
1521     napi_set_named_property(env, exports, "SipAddress", result);
1522     return exports;
1523 }
1524 
DeclareAttributeConst(napi_env env,napi_value exports)1525 napi_value DeclareAttributeConst(napi_env env, napi_value exports)
1526 {
1527     // Attribute
1528     napi_property_descriptor desc[] = {
1529         DECLARE_NAPI_STATIC_PROPERTY("ATTR_CONTACT_EVENT",
1530             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_CONTACT_EVENT))),
1531         DECLARE_NAPI_STATIC_PROPERTY("ATTR_EMAIL",
1532             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_EMAIL))),
1533         DECLARE_NAPI_STATIC_PROPERTY("ATTR_GROUP_MEMBERSHIP",
1534             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_GROUP_MEMBERSHIP))),
1535         DECLARE_NAPI_STATIC_PROPERTY("ATTR_IM",
1536             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_IM))),
1537         DECLARE_NAPI_STATIC_PROPERTY("ATTR_NAME",
1538             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_NAME))),
1539         DECLARE_NAPI_STATIC_PROPERTY("ATTR_NICKNAME",
1540             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_NICKNAME))),
1541         DECLARE_NAPI_STATIC_PROPERTY("ATTR_NOTE",
1542             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_NOTE))),
1543         DECLARE_NAPI_STATIC_PROPERTY("ATTR_ORGANIZATION",
1544             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_ORGANIZATION))),
1545         DECLARE_NAPI_STATIC_PROPERTY("ATTR_PHONE",
1546             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_PHONE))),
1547         DECLARE_NAPI_STATIC_PROPERTY("ATTR_PORTRAIT",
1548             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_PORTRAIT))),
1549         DECLARE_NAPI_STATIC_PROPERTY("ATTR_POSTAL_ADDRESS",
1550             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_POSTAL_ADDRESS))),
1551         DECLARE_NAPI_STATIC_PROPERTY("ATTR_RELATION",
1552             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_RELATION))),
1553         DECLARE_NAPI_STATIC_PROPERTY("ATTR_SIP_ADDRESS",
1554             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_SIP_ADDRESS))),
1555         DECLARE_NAPI_STATIC_PROPERTY("ATTR_WEBSITE",
1556             ContactsNapiUtils::ToInt32Value(env, static_cast<int32_t>(Attribute::ATTR_WEBSITE))),
1557     };
1558     napi_value result = nullptr;
1559     napi_define_class(env, "Attribute", NAPI_AUTO_LENGTH, ContactsNapiUtils::CreateClassConstructor, nullptr,
1560         sizeof(desc) / sizeof(*desc), desc, &result);
1561     napi_set_named_property(env, exports, "Attribute", result);
1562     return exports;
1563 }
1564 
Init(napi_env env,napi_value exports)1565 void Init(napi_env env, napi_value exports)
1566 {
1567     napi_property_descriptor exportFuncs[] = {
1568         DECLARE_NAPI_FUNCTION("addContact", OHOS::ContactsApi::AddContact),
1569         DECLARE_NAPI_FUNCTION("deleteContact", OHOS::ContactsApi::DeleteContact),
1570         DECLARE_NAPI_FUNCTION("updateContact", OHOS::ContactsApi::UpdateContact),
1571         DECLARE_NAPI_FUNCTION("queryContact", OHOS::ContactsApi::QueryContact),
1572         DECLARE_NAPI_FUNCTION("queryContacts", OHOS::ContactsApi::QueryContacts),
1573         DECLARE_NAPI_FUNCTION("queryContactsByEmail", OHOS::ContactsApi::QueryContactsByEmail),
1574         DECLARE_NAPI_FUNCTION("queryContactsByPhoneNumber", OHOS::ContactsApi::QueryContactsByPhoneNumber),
1575         DECLARE_NAPI_FUNCTION("queryGroups", OHOS::ContactsApi::QueryGroups),
1576         DECLARE_NAPI_FUNCTION("queryHolders", OHOS::ContactsApi::QueryHolders),
1577         DECLARE_NAPI_FUNCTION("queryKey", OHOS::ContactsApi::QueryKey),
1578         DECLARE_NAPI_FUNCTION("queryMyCard", OHOS::ContactsApi::QueryMyCard),
1579         DECLARE_NAPI_FUNCTION("isMyCard", OHOS::ContactsApi::IsMyCard),
1580         DECLARE_NAPI_FUNCTION("isLocalContact", OHOS::ContactsApi::IsLocalContact),
1581     };
1582     napi_define_properties(env, exports, sizeof(exportFuncs) / sizeof(*exportFuncs), exportFuncs);
1583     // Declare class const initialization
1584     DeclareContactConst(env, exports);
1585     DeclareEmailConst(env, exports);
1586     DeclareEventConst(env, exports);
1587     DeclareImAddressConst(env, exports);
1588     DeclarePhoneNumberConst(env, exports);
1589     DeclarePostalAddressConst(env, exports);
1590     DeclareRelationConst(env, exports);
1591     DeclareSipAddressConst(env, exports);
1592     DeclareAttributeConst(env, exports);
1593 }
1594 } // namespace ContactsApi
1595 } // namespace OHOS
1596