upload tizen1.0 source
[profile/ivi/wrt-plugins-tizen.git] / src / standards / Tizen / Contact / ContactConverter.cpp
1 /*
2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
3  *
4  * Licensed under the Apache License, Version 2.0 (the License);
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an AS IS BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 /**
18  * @file        ContactConverter.cpp
19  * @author      Kisub Song (kisubs.song@samsung.com)
20  * @version     0.1
21  * @brief
22  */
23
24 #include <algorithm>
25 #include <dpl/log/log.h>
26 #include <CommonsJavaScript/Validator.h>
27 #include <CommonsJavaScript/ScopedJSStringRef.h>
28 #include <CommonsJavaScript/JSUtils.h>
29 #include <Commons/RegexUtils.h>
30 #include <API/Contact/ContactFactory.h>
31
32 #include "ContactConverter.h"
33 #include "AddressBookController.h"
34 #include "JSAddressBook.h"
35 #include "JSAddressBookArray.h"
36 //#include "JSAttributesOfInterestArray.h"
37 #include "JSContact.h"
38 #include "JSContactRef.h"
39 #include "JSContactArray.h"
40 #include "JSContactName.h"
41 #include "JSContactAccount.h"
42 #include "JSContactAnniversary.h"
43 #include "JSContactAnniversaryArray.h"
44 #include "JSContactAddress.h"
45 #include "JSContactAddressArray.h"
46 #include "JSContactAddressTypeArray.h"
47 #include "JSContactManager.h"
48 #include "JSContactPhoneNumber.h"
49 #include "JSContactPhoneNumberArray.h"
50 #include "JSContactPhoneNumberTypeArray.h"
51 #include "JSContactEmailAddress.h"
52 #include "JSContactEmailAddressArray.h"
53 #include "JSContactEmailAddressTypeArray.h"
54 #include "JSContactOrganization.h"
55 #include "JSContactOrganizationArray.h"
56 #include "JSContactWebSite.h"
57 #include "JSContactWebSiteArray.h"
58 #include "JSStringArray.h"
59
60 #define CONTACT_ATTRIBUTE_ACCOUNT "account"
61 #define CONTACT_ATTRIBUTE_ACCOUNT_SERVICE_ID "accountServiceId"
62 #define CONTACT_ATTRIBUTE_ADDITIONAL_INFORMATION "additionalInformation"
63 #define CONTACT_ATTRIBUTE_ADDRESSES "addresses"
64 #define CONTACT_ATTRIBUTE_ANNIVERSARIES "anniversaries"
65 //#define CONTACT_ATTRIBUTE_ATTRIBUTES_OF_INTEREST "attributesOfInterest"
66 #define CONTACT_ATTRIBUTE_BIRTHDAY "birthday"
67 #define CONTACT_ATTRIBUTE_CATEGORIES "categories"
68 #define CONTACT_ATTRIBUTE_CITY "city"
69 #define CONTACT_ATTRIBUTE_CONTACT_ID "contactId"
70 #define CONTACT_ATTRIBUTE_CONTACT_URI "contactURI"
71 #define CONTACT_ATTRIBUTE_COUNTRY "country"
72 #define CONTACT_ATTRIBUTE_COUNTY "county"
73 #define CONTACT_ATTRIBUTE_DATE "date"
74 #define CONTACT_ATTRIBUTE_DEPARTMENT "department"
75 #define CONTACT_ATTRIBUTE_DISPLAY_NAME "displayName"
76 #define CONTACT_ATTRIBUTE_EMAIL "email"
77 #define CONTACT_ATTRIBUTE_EMAILS "emails"
78 #define CONTACT_ATTRIBUTE_FIRST_NAME "firstName"
79 #define CONTACT_ATTRIBUTE_ID "id"
80 #define CONTACT_ATTRIBUTE_IS_FAVORITE "isFavorite"
81 #define CONTACT_ATTRIBUTE_LABEL "label"
82 #define CONTACT_ATTRIBUTE_LAST_NAME "lastName"
83 #define CONTACT_ATTRIBUTE_LAST_UPDATED "lastUpdated"
84 #define CONTACT_ATTRIBUTE_LOGO_URI "logoURI"
85 #define CONTACT_ATTRIBUTE_MIDDLE_NAME "middleName"
86 #define CONTACT_ATTRIBUTE_NAME "name"
87 #define CONTACT_ATTRIBUTE_NICKNAMES "nicknames"
88 #define CONTACT_ATTRIBUTE_NOTES "notes"
89 #define CONTACT_ATTRIBUTE_NUMBER "number"
90 #define CONTACT_ATTRIBUTE_OFFICE "office"
91 #define CONTACT_ATTRIBUTE_ORGANIZATION "organization"
92 #define CONTACT_ATTRIBUTE_PHONE_NUMBERS "phoneNumbers"
93 #define CONTACT_ATTRIBUTE_PHONETIC_NAME "phoneticName"
94 #define CONTACT_ATTRIBUTE_PHOTO_URI  "photoURI"
95 #define CONTACT_ATTRIBUTE_POSITION "position"
96 #define CONTACT_ATTRIBUTE_POSTAL_CODE "postalCode"
97 #define CONTACT_ATTRIBUTE_PREFIX "prefix"
98 #define CONTACT_ATTRIBUTE_READ_ONLY "readOnly"
99 #define CONTACT_ATTRIBUTE_REGION "region"
100 #define CONTACT_ATTRIBUTE_RINGTONE_URI "ringtoneURI"
101 #define CONTACT_ATTRIBUTE_ROLE "role"
102 #define CONTACT_ATTRIBUTE_STREET_ADDRESS "streetAddress"
103 #define CONTACT_ATTRIBUTE_TITLE "title"
104 #define CONTACT_ATTRIBUTE_TYPE "type"
105 #define CONTACT_ATTRIBUTE_TYPES "types"
106 #define CONTACT_ATTRIBUTE_URL "url"
107 #define CONTACT_ATTRIBUTE_URLS "urls"
108
109 #define STR_CONTACT_EMAIL_TYPE_WORK "WORK"
110 #define STR_CONTACT_EMAIL_TYPE_PREF "PREF"
111 #define STR_CONTACT_EMAIL_TYPE_HOME "HOME"
112
113 #define STR_CONTACT_PHONE_NUMBER_TYPE_WORK "WORK"
114 #define STR_CONTACT_PHONE_NUMBER_TYPE_PREF "PREF"
115 #define STR_CONTACT_PHONE_NUMBER_TYPE_HOME "HOME"
116 #define STR_CONTACT_PHONE_NUMBER_TYPE_VOICE "VOICE"
117 #define STR_CONTACT_PHONE_NUMBER_TYPE_FAX "FAX"
118 #define STR_CONTACT_PHONE_NUMBER_TYPE_MSG "MSG"
119 #define STR_CONTACT_PHONE_NUMBER_TYPE_CELL "CELL"
120 #define STR_CONTACT_PHONE_NUMBER_TYPE_PAGER "PAGER"
121 #define STR_CONTACT_PHONE_NUMBER_TYPE_BBS "BBS"
122 #define STR_CONTACT_PHONE_NUMBER_TYPE_MODEM "MODEM"
123 #define STR_CONTACT_PHONE_NUMBER_TYPE_CAR "CAR"
124 #define STR_CONTACT_PHONE_NUMBER_TYPE_ISDN "ISDN"
125 #define STR_CONTACT_PHONE_NUMBER_TYPE_VIDEO "VIDEO"
126 #define STR_CONTACT_PHONE_NUMBER_TYPE_PCS "PCS"
127
128 #define STR_CONTACT_ADDRESS_TYPE_WORK "WORK"
129 #define STR_CONTACT_ADDRESS_TYPE_PREF "PREF"
130 #define STR_CONTACT_ADDRESS_TYPE_HOME "HOME"
131
132 #define STR_WEBSITE_TYPE_HOMEPAGE "HOMEPAGE"
133 #define STR_WEBSITE_TYPE_BLOG "BLOG"
134
135 namespace TizenApis {
136 namespace Tizen1_0 {
137 namespace Contact {
138
139 using namespace TizenApis::Api::Contact;
140 using namespace WrtDeviceApis::Commons;
141 using namespace WrtDeviceApis::CommonsJavaScript;
142
143 std::vector<std::string> ContactConverter::m_allowedContactInit;
144 std::vector<std::string> ContactConverter::m_allowedContactNameInit;
145 std::vector<std::string> ContactConverter::m_allowedContactOrganizationInit;
146 std::vector<std::string> ContactConverter::m_allowedContactAddressInit;
147
148 ContactConverter::ContactConverter(JSContextRef context) : Converter(context)
149 {
150         static bool init = initializeAllowedProperties();
151         (void) init;
152 }
153
154 ContactConverter::~ContactConverter()
155 {
156 }
157
158 JSValueRef ContactConverter::toJSValueRef(const AddressBookPtr &arg)
159 {
160         // It may not used
161         AddressBookController *priv = new AddressBookController(m_context, arg);
162         return JSObjectMake(m_context, JSAddressBook::getClassRef(), priv);
163 }
164
165 AddressBookPtr ContactConverter::toAddressBook(const JSValueRef &jsValue)
166 {
167         if(!JSAddressBook::isObjectOfClass(m_context, jsValue))
168                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
169
170         return JSAddressBook::getAddressBook(m_context, jsValue);
171 }
172
173 JSValueRef ContactConverter::toJSValueRef(const AddressBookArrayPtr &arg)
174 {
175         // TODO Check it is right? not a platform object right?
176         int size = arg->size();
177
178         JSObjectRef resultObject = JSCreateArrayObject(m_context, 0, NULL);
179         if (!resultObject)
180                 ThrowMsg(ConversionException, "Can not create array object.");
181
182         for(int i = 0; i < size; i++)
183         {
184                 JSValueRef jsvalue = toJSValueRef(arg->at(i));
185                 if (!JSSetArrayElement(m_context, resultObject, i, jsvalue))
186                         ThrowMsg(ConversionException, "Can not fill address book array.");
187         }
188
189         return static_cast<JSValueRef>(resultObject);
190 }
191
192 AddressBookArrayPtr ContactConverter::toAddressBookArray(const JSValueRef &jsValue)
193 {
194         if(JSAddressBookArray::isObjectOfClass(m_context, jsValue))
195                 return JSAddressBookArray::getAddressBookArray(m_context, jsValue);
196
197         if(!JSIsArrayValue(m_context, jsValue))
198                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "AddressBookArray is not array.");
199
200         AddressBookArrayPtr result(new AddressBookArray());
201
202         JSObjectRef jsObject = toJSObjectRef(jsValue);
203     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
204         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
205         result->push_back(toAddressBook(element));
206     }
207     return result;
208 }
209
210 JSValueRef ContactConverter::toJSValueRef(const ContactPtr &arg)
211 {
212         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContact::getClassRef(), arg);
213 }
214
215 ContactPtr ContactConverter::toContact(const JSValueRef &jsValue)
216 {
217         if(!JSContact::isObjectOfClass(m_context, jsValue))
218         {
219                 LogError("Not a Contact object");
220                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
221         }
222
223         return JSContact::getContact(m_context, jsValue);
224 }
225
226 ContactPtr ContactConverter::toContactFromInit(const JSValueRef &jsValue)
227 {
228         // from ContactInit to Contact
229         Validator validator(m_context);
230         if (validator.isNullOrUndefined(jsValue)) {
231                 LogError("ContactInit object is null");
232                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
233         }
234
235         if (!JSValueIsObject(m_context, jsValue) || JSIsArrayValue(m_context, jsValue)) {
236                 LogError("ContactInit object is not object");
237                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
238         }
239
240 //      if (!validator.checkArrayKeys(m_allowedContactInit, jsValue)) {
241 //              LogError("invalid properties in ContactInit object");
242 //              ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
243 //      }
244
245         const ScopedJSStringRef nameStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_NAME));
246         const ScopedJSStringRef accountStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_ACCOUNT));
247         const ScopedJSStringRef addressesStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_ADDRESSES));
248         const ScopedJSStringRef photoURIStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_PHOTO_URI));
249         const ScopedJSStringRef phoneNumbersStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_PHONE_NUMBERS));
250         const ScopedJSStringRef emailsStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_EMAILS));
251         const ScopedJSStringRef birthdayStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_BIRTHDAY));
252         const ScopedJSStringRef anniversariesStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_ANNIVERSARIES));
253         const ScopedJSStringRef organizationStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_ORGANIZATION));
254         const ScopedJSStringRef notesStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_NOTES));
255         const ScopedJSStringRef urlsStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_URLS));
256         const ScopedJSStringRef isFavoriteStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_IS_FAVORITE));
257         const ScopedJSStringRef ringtoneURIStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_RINGTONE_URI));
258         const ScopedJSStringRef categoriesStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_CATEGORIES));
259
260         JSObjectRef jsObject = toJSObjectRef(jsValue);
261
262         JSValueRef nameData = JSObjectGetProperty(m_context, jsObject, nameStr.get(), NULL);
263         JSValueRef accountData = JSObjectGetProperty(m_context, jsObject, accountStr.get(), NULL);
264         JSValueRef addressesData = JSObjectGetProperty(m_context, jsObject, addressesStr.get(), NULL);
265         JSValueRef photoURIData = JSObjectGetProperty(m_context, jsObject, photoURIStr.get(), NULL);
266         JSValueRef phoneNumbersData = JSObjectGetProperty(m_context, jsObject, phoneNumbersStr.get(), NULL);
267         JSValueRef emailsData = JSObjectGetProperty(m_context, jsObject, emailsStr.get(), NULL);
268         JSValueRef birthdayData = JSObjectGetProperty(m_context, jsObject, birthdayStr.get(), NULL);
269         JSValueRef anniversariesData = JSObjectGetProperty(m_context, jsObject, anniversariesStr.get(), NULL);
270         JSValueRef organizationData = JSObjectGetProperty(m_context, jsObject, organizationStr.get(), NULL);
271         JSValueRef notesData = JSObjectGetProperty(m_context, jsObject, notesStr.get(), NULL);
272         JSValueRef urlsData = JSObjectGetProperty(m_context, jsObject, urlsStr.get(), NULL);
273         JSValueRef isFavoriteData = JSObjectGetProperty(m_context, jsObject, isFavoriteStr.get(), NULL);
274         JSValueRef ringtoneURIData = JSObjectGetProperty(m_context, jsObject, ringtoneURIStr.get(), NULL);
275         JSValueRef categoriesData = JSObjectGetProperty(m_context, jsObject, categoriesStr.get(), NULL);
276
277         ContactNamePtr name;
278         ContactAccountPtr account;
279         ContactAddressArrayPtr addresses;
280         std::string photoURI;
281         ContactPhoneNumberArrayPtr phoneNumbers;
282         ContactEmailAddressArrayPtr emails;
283         tm birthday;
284         ContactAnniversaryArrayPtr anniversaries;
285         ContactOrganizationPtr organization;
286         StringArrayPtr notes;
287         ContactWebSiteArrayPtr urls;
288         bool isFavorite;
289         std::string ringtoneURI;
290         StringArrayPtr categories;
291
292         ContactPtr result = ContactFactory::getInstance().createContact();
293         if (!result) {
294                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Cannot create Contact object");
295         }
296
297         if (!validator.isNullOrUndefined(nameData)) {
298                 name = toContactName(nameData);
299                 result->setName(name);
300         }
301
302         if (!validator.isNullOrUndefined(accountData)) {
303                 account = toContactAccount(accountData);
304                 result->setAccount(account);
305         }
306
307         if (!validator.isNullOrUndefined(addressesData)) {
308                 addresses = toContactAddressArray(addressesData);
309                 result->setAddresses(addresses);
310         }
311
312         if (!validator.isNullOrUndefined(photoURIData)) {
313                 if(!JSValueIsString(m_context, photoURIData))
314                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "photoURI is not string");
315                 photoURI = toString(photoURIData);
316                 result->setPhotoURI(photoURI);
317         }
318
319         if (!validator.isNullOrUndefined(phoneNumbersData)) {
320                 phoneNumbers = toContactPhoneNumberArray(phoneNumbersData);
321                 result->setPhoneNumbers(phoneNumbers);
322         }
323
324         if (!validator.isNullOrUndefined(emailsData)) {
325                 emails = toContactEmailAddressArray(emailsData);
326                 result->setEmails(emails);
327         }
328
329         if (!validator.isNullOrUndefined(birthdayData)) {
330                 if(!validator.isDate(birthdayData))
331                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "birthday is not Date");
332                 birthday = toDateTm(birthdayData);
333                 result->setBirthday(birthday);
334         }
335
336         if (!validator.isNullOrUndefined(anniversariesData)) {
337                 anniversaries = toContactAnniversaryArray(anniversariesData);
338                 result->setAnniversaries(anniversaries);
339         }
340
341         if (!validator.isNullOrUndefined(organizationData)) {
342                 organization = toContactOrganization(organizationData);
343                 result->setOrganization(organization);
344         }
345
346         if (!validator.isNullOrUndefined(notesData)) {
347                 notes = toStringArray(notesData);
348                 result->setNotes(notes);
349         }
350
351         if (!validator.isNullOrUndefined(urlsData)) {
352                 urls = toContactWebSiteArray(urlsData);
353                 result->setUrls(urls);
354         }
355
356         if (!validator.isNullOrUndefined(isFavoriteData)) {
357                 if(!JSValueIsBoolean(m_context, isFavoriteData))
358                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "isFavorite is not boolean");
359                 isFavorite = toBool(isFavoriteData);
360                 result->setIsFavorite(isFavorite);
361         }
362
363         if (!validator.isNullOrUndefined(ringtoneURIData)) {
364                 if(!JSValueIsString(m_context, ringtoneURIData))
365                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ringtoneURI is not string");
366                 ringtoneURI = toString(ringtoneURIData);
367                 result->setRingtoneURI(ringtoneURI);
368         }
369
370         if (!validator.isNullOrUndefined(categoriesData)) {
371                 categories = toStringArray(categoriesData);
372                 result->setCategories(categories);
373         }
374
375         return result;
376 }
377
378 JSValueRef ContactConverter::toJSValueRef(const ContactArrayPtr &arg)
379 {
380         // TODO Check it is right? not a platform object right?
381         int size = arg->size();
382
383         JSObjectRef resultObject = JSCreateArrayObject(m_context, 0, NULL);
384         if (!resultObject)
385                 ThrowMsg(ConversionException, "Can not create array object.");
386
387         for(int i = 0; i < size; i++)
388         {
389                 JSValueRef jsvalue = toJSValueRef(arg->at(i));
390                 if (!JSSetArrayElement(m_context, resultObject, i, jsvalue))
391                         ThrowMsg(ConversionException, "Can not fill contact array.");
392         }
393
394         return static_cast<JSValueRef>(resultObject);
395 }
396
397 ContactArrayPtr ContactConverter::toContactArray(const JSValueRef &jsValue)
398 {
399 //  // toJSValueRef(ContactArrayPtr) creates user object.
400 //      if(JSContactArray::isObjectOfClass(m_context, jsValue))
401 //              return JSContactArray::getContactArray(m_context, jsValue);
402
403         if(!JSIsArrayValue(m_context, jsValue))
404                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactArray is not array.");
405
406         ContactArrayPtr result = ContactArrayPtr(new ContactArray());
407
408         JSObjectRef jsObject = toJSObjectRef(jsValue);
409     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
410         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
411         result->push_back(toContact(element));
412     }
413     return result;
414 }
415
416 JSValueRef ContactConverter::toJSValueRef(const ContactRefPtr &arg)
417 {
418         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactRef::getClassRef(), arg);
419 }
420
421 ContactRefPtr ContactConverter::toContactRef(const JSValueRef &jsValue)
422 {
423         if(!JSContactRef::isObjectOfClass(m_context, jsValue))
424         {
425                 LogError("Not a ContactRef object");
426                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
427         }
428
429         return JSContactRef::getContactRef(m_context, jsValue);
430 }
431
432 JSValueRef ContactConverter::toJSValueRef(const ContactNamePtr &arg)
433 {
434         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactName::getClassRef(), arg);
435 }
436
437 ContactNamePtr ContactConverter::toContactName(const JSValueRef &jsValue)
438 {
439         if(!JSContactName::isObjectOfClass(m_context, jsValue))
440         {
441                 LogError("Not a ContactName object");
442                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
443         }
444
445         return JSContactName::getContactName(m_context, jsValue);
446 }
447
448 ContactNamePtr ContactConverter::toContactNameFromInit(const JSValueRef &jsValue)
449 {
450         // from ContactNameInit to ContactName
451         Validator validator(m_context);
452         if (validator.isNullOrUndefined(jsValue)) {
453                 LogError("ContactNameInit object is null");
454                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
455         }
456
457         if (!JSValueIsObject(m_context, jsValue) || JSIsArrayValue(m_context, jsValue)) {
458                 LogError("ContactNameInit object is not object");
459                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
460         }
461
462 //      if (!validator.checkArrayKeys(m_allowedContactNameInit, jsValue)) {
463 //              LogError("invalid properties in ContactNameInit object");
464 //              ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
465 //      }
466
467         const ScopedJSStringRef prefixStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_PREFIX));
468         const ScopedJSStringRef firstNameStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_FIRST_NAME));
469         const ScopedJSStringRef middleNameStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_MIDDLE_NAME));
470         const ScopedJSStringRef lastNameStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_LAST_NAME));
471         const ScopedJSStringRef nicknamesStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_NICKNAMES));
472         const ScopedJSStringRef phoneticNameStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_PHONETIC_NAME));
473         const ScopedJSStringRef displayNameStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_DISPLAY_NAME));
474
475         JSObjectRef jsObject = toJSObjectRef(jsValue);
476
477         JSValueRef prefixData = JSObjectGetProperty(m_context, jsObject, prefixStr.get(), NULL);
478         JSValueRef firstNameData = JSObjectGetProperty(m_context, jsObject, firstNameStr.get(), NULL);
479         JSValueRef middleNameData = JSObjectGetProperty(m_context, jsObject, middleNameStr.get(), NULL);
480         JSValueRef lastNameData = JSObjectGetProperty(m_context, jsObject, lastNameStr.get(), NULL);
481         JSValueRef nicknamesData = JSObjectGetProperty(m_context, jsObject, nicknamesStr.get(), NULL);
482         JSValueRef phoneticNameData = JSObjectGetProperty(m_context, jsObject, phoneticNameStr.get(), NULL);
483         JSValueRef displayNameData = JSObjectGetProperty(m_context, jsObject, displayNameStr.get(), NULL);
484
485         std::string prefix;
486         std::string firstName;
487         std::string middleName;
488         std::string lastName;
489         StringArrayPtr nicknames;
490         std::string phoneticName;
491         std::string displayName;
492
493         ContactNamePtr result = ContactNamePtr(new ContactName());
494         if (!result) {
495                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Cannot create ContactName object");
496         }
497
498         if (!validator.isNullOrUndefined(prefixData)) {
499                 if(!JSValueIsString(m_context, prefixData))
500                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "prefix is not string");
501                 prefix = toString(prefixData);
502                 result->setPrefix(prefix);
503         }
504
505         if (!validator.isNullOrUndefined(firstNameData)) {
506                 if(!JSValueIsString(m_context, firstNameData))
507                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "firstName is not string");
508                 firstName = toString(firstNameData);
509                 result->setFirstName(firstName);
510         }
511
512         if (!validator.isNullOrUndefined(middleNameData)) {
513                 if(!JSValueIsString(m_context, middleNameData))
514                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "middleName is not string");
515                 middleName = toString(middleNameData);
516                 result->setMiddleName(middleName);
517         }
518
519         if (!validator.isNullOrUndefined(lastNameData)) {
520                 if(!JSValueIsString(m_context, lastNameData))
521                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "lastName is not string");
522                 lastName = toString(lastNameData);
523                 result->setLastName(lastName);
524         }
525
526         if (!validator.isNullOrUndefined(nicknamesData)) {
527                 nicknames = toStringArray(nicknamesData);
528                 result->setNicknames(nicknames);
529         }
530
531         if (!validator.isNullOrUndefined(phoneticNameData)) {
532                 if(!JSValueIsString(m_context, phoneticNameData))
533                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "phoneticName is not string");
534                 phoneticName = toString(phoneticNameData);
535                 result->setPhoneticName(phoneticName);
536         }
537
538         if (!validator.isNullOrUndefined(displayNameData)) {
539                 if(!JSValueIsString(m_context, displayNameData))
540                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "displayName is not string");
541                 displayName = toString(displayNameData);
542                 result->setDisplayName(displayName);
543         }
544
545         return result;
546 }
547
548 JSValueRef ContactConverter::toJSValueRef(const ContactOrganizationPtr &arg)
549 {
550         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactOrganization::getClassRef(), arg);
551 }
552
553 ContactOrganizationPtr ContactConverter::toContactOrganization(const JSValueRef &jsValue)
554 {
555         if(!JSContactOrganization::isObjectOfClass(m_context, jsValue))
556         {
557                 LogError("Not a ContactOrganization object");
558                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
559         }
560
561         return JSContactOrganization::getContactOrganization(m_context, jsValue);
562 }
563
564 ContactOrganizationPtr ContactConverter::toContactOrganizationFromInit(const JSValueRef &jsValue)
565 {
566         // from ContactOrganizationInit to ContactOrganization
567         Validator validator(m_context);
568         if (validator.isNullOrUndefined(jsValue)) {
569                 LogError("ContactOrganizationInit object is null");
570                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
571         }
572
573         if (!JSValueIsObject(m_context, jsValue) || JSIsArrayValue(m_context, jsValue)) {
574                 LogError("ContactOrganizationInit object is not object");
575                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
576         }
577
578 //      if (!validator.checkArrayKeys(m_allowedContactOrganizationInit, jsValue)) {
579 //              LogError("invalid properties in ContactOrganizationInit object");
580 //              ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
581 //      }
582
583         // NOTE: Currently not support office and logoURI fields
584         const ScopedJSStringRef nameStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_NAME));
585         const ScopedJSStringRef departmentStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_DEPARTMENT));
586         const ScopedJSStringRef titleStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_TITLE));
587         const ScopedJSStringRef roleStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_ROLE));
588
589         JSObjectRef jsObject = toJSObjectRef(jsValue);
590
591         JSValueRef nameData = JSObjectGetProperty(m_context, jsObject, nameStr.get(), NULL);
592         JSValueRef departmentData = JSObjectGetProperty(m_context, jsObject, departmentStr.get(), NULL);
593         JSValueRef titleData = JSObjectGetProperty(m_context, jsObject, titleStr.get(), NULL);
594         JSValueRef roleData = JSObjectGetProperty(m_context, jsObject, roleStr.get(), NULL);
595
596         std::string name;
597         std::string department;
598         std::string title;
599         std::string role;
600
601         ContactOrganizationPtr result(new ContactOrganization());
602         if (!result) {
603                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Cannot create ContactOrganization object");
604         }
605
606         if (!validator.isNullOrUndefined(nameData)) {
607                 if(!JSValueIsString(m_context, nameData))
608                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "name is not string");
609                 name = toString(nameData);
610                 result->setName(name);
611         }
612
613         if (!validator.isNullOrUndefined(departmentData)) {
614                 if(!JSValueIsString(m_context, departmentData))
615                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "department is not string");
616                 department = toString(departmentData);
617                 result->setDepartment(department);
618         }
619
620         if (!validator.isNullOrUndefined(titleData)) {
621                 if(!JSValueIsString(m_context, titleData))
622                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "title is not string");
623                 title = toString(titleData);
624                 result->setTitle(title);
625         }
626
627         if (!validator.isNullOrUndefined(roleData)) {
628                 if(!JSValueIsString(m_context, roleData))
629                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "role is not string");
630                 role = toString(roleData);
631                 result->setRole(role);
632         }
633
634         return result;
635 }
636
637 JSValueRef ContactConverter::toJSValueRef(const ContactOrganizationArrayPtr &arg)
638 {
639         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactOrganizationArray::getClassRef(), arg);
640 }
641
642 ContactOrganizationArrayPtr ContactConverter::toContactOrganizationArray(const JSValueRef &jsValue)
643 {
644         if(JSContactOrganizationArray::isObjectOfClass(m_context, jsValue))
645                 return JSContactOrganizationArray::getContactOrganizationArray(m_context, jsValue);
646
647         ContactOrganizationArrayPtr result(new ContactOrganizationArray());
648
649         if(!JSIsArrayValue(m_context, jsValue))
650                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactOrganizationArray is not array.");
651
652         JSObjectRef jsObject = toJSObjectRef(jsValue);
653     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
654         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
655         result->push_back(toContactOrganization(element));
656     }
657     return result;
658 }
659
660 JSValueRef ContactConverter::toJSValueRef(const ContactWebSitePtr &arg)
661 {
662         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactWebSite::getClassRef(), arg);
663 }
664
665 ContactWebSitePtr ContactConverter::toContactWebSite(const JSValueRef &jsValue)
666 {
667         if(!JSContactWebSite::isObjectOfClass(m_context, jsValue))
668         {
669                 LogError("Not a ContactWebSite object");
670                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
671         }
672
673         return JSContactWebSite::getContactWebSite(m_context, jsValue);
674 }
675
676 JSValueRef ContactConverter::toJSValueRef(const ContactWebSiteArrayPtr &arg)
677 {
678         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactWebSiteArray::getClassRef(), arg);
679 }
680
681 ContactWebSiteArrayPtr ContactConverter::toContactWebSiteArray(const JSValueRef &jsValue)
682 {
683         if(JSContactWebSiteArray::isObjectOfClass(m_context, jsValue))
684                 return JSContactWebSiteArray::getContactWebSiteArray(m_context, jsValue);
685
686         if(!JSIsArrayValue(m_context, jsValue))
687                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactWebSiteArray is not array.");
688
689         ContactWebSiteArrayPtr result(new ContactWebSiteArray());
690
691         JSObjectRef jsObject = toJSObjectRef(jsValue);
692     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
693         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
694         result->push_back(toContactWebSite(element));
695     }
696     return result;
697 }
698
699 JSValueRef ContactConverter::toJSValueRef(const ContactAnniversaryPtr &arg)
700 {
701         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAnniversary::getClassRef(), arg);
702 }
703
704 ContactAnniversaryPtr ContactConverter::toContactAnniversary(const JSValueRef &jsValue)
705 {
706         if(!JSContactAnniversary::isObjectOfClass(m_context, jsValue))
707         {
708                 LogError("Not a ContactAnniversary object");
709                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
710         }
711
712         return JSContactAnniversary::getContactAnniversary(m_context, jsValue);
713 }
714
715 JSValueRef ContactConverter::toJSValueRef(const ContactAnniversaryArrayPtr &arg)
716 {
717         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAnniversaryArray::getClassRef(), arg);
718 }
719
720 ContactAnniversaryArrayPtr ContactConverter::toContactAnniversaryArray(const JSValueRef &jsValue)
721 {
722         if(JSContactAnniversaryArray::isObjectOfClass(m_context, jsValue))
723                 return JSContactAnniversaryArray::getContactAnniversaryArray(m_context, jsValue);
724
725         if(!JSIsArrayValue(m_context, jsValue))
726                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactAnniversaryArray is not array.");
727
728         ContactAnniversaryArrayPtr result(new ContactAnniversaryArray());
729
730         JSObjectRef jsObject = toJSObjectRef(jsValue);
731     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
732         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
733         result->push_back(toContactAnniversary(element));
734     }
735     return result;
736 }
737
738 JSValueRef ContactConverter::toJSValueRef(const ContactAccountPtr &arg)
739 {
740         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAccount::getClassRef(), arg);
741 }
742
743 ContactAccountPtr ContactConverter::toContactAccount(const JSValueRef &jsValue)
744 {
745         if(!JSContactAccount::isObjectOfClass(m_context, jsValue))
746         {
747                 LogError("Not a ContactAccount object");
748                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
749         }
750
751         return JSContactAccount::getContactAccount(m_context, jsValue);
752 }
753
754 JSValueRef ContactConverter::toJSValueRef(const ContactAddressPtr &arg)
755 {
756         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAddress::getClassRef(), arg);
757 }
758
759 ContactAddressPtr ContactConverter::toContactAddress(const JSValueRef &jsValue)
760 {
761         if(!JSContactAddress::isObjectOfClass(m_context, jsValue))
762         {
763                 LogError("Not a ContactAddress object");
764                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
765         }
766
767         return JSContactAddress::getContactAddress(m_context, jsValue);
768 }
769
770 ContactAddressPtr ContactConverter::toContactAddressFromInit(const JSValueRef &jsValue)
771 {
772         // from ContactAddressInit to ContactAddress
773         Validator validator(m_context);
774         if (validator.isNullOrUndefined(jsValue)) {
775                 LogError("ContactAddressInit object is null");
776                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
777         }
778
779         if (!JSValueIsObject(m_context, jsValue) || JSIsArrayValue(m_context, jsValue)) {
780                 LogError("ContactAddressInit object is not object");
781                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
782         }
783
784 //      if (!validator.checkArrayKeys(m_allowedContactAddressInit, jsValue)) {
785 //              LogError("invalid properties in ContactAddressInit object");
786 //              ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
787 //      }
788
789         const ScopedJSStringRef countryStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_COUNTRY));
790         const ScopedJSStringRef regionStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_REGION));
791         const ScopedJSStringRef cityStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_CITY));
792         const ScopedJSStringRef streetAddressStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_STREET_ADDRESS));
793         const ScopedJSStringRef additionalInformationStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_ADDITIONAL_INFORMATION));
794         const ScopedJSStringRef postalCodeStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_POSTAL_CODE));
795         const ScopedJSStringRef typesStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_TYPES));
796
797         JSObjectRef jsObject = toJSObjectRef(jsValue);
798
799         JSValueRef countryData = JSObjectGetProperty(m_context, jsObject, countryStr.get(), NULL);
800         JSValueRef regionData = JSObjectGetProperty(m_context, jsObject, regionStr.get(), NULL);
801         JSValueRef cityData = JSObjectGetProperty(m_context, jsObject, cityStr.get(), NULL);
802         JSValueRef streetAddressData = JSObjectGetProperty(m_context, jsObject, streetAddressStr.get(), NULL);
803         JSValueRef additionalInformationData = JSObjectGetProperty(m_context, jsObject, additionalInformationStr.get(), NULL);
804         JSValueRef postalCodeData = JSObjectGetProperty(m_context, jsObject, postalCodeStr.get(), NULL);
805         JSValueRef typesData = JSObjectGetProperty(m_context, jsObject, typesStr.get(), NULL);
806
807         std::string country;
808         std::string region;
809         std::string city;
810         std::string streetAddress;
811         std::string additionalInformation;
812         std::string postalCode;
813         ContactAddressTypeArrayPtr types;
814
815         ContactAddressPtr result(new ContactAddress());
816         if (!result) {
817                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Cannot make ContactAddress");
818         }
819
820         if (!validator.isNullOrUndefined(countryData)) {
821                 if(!JSValueIsString(m_context, countryData))
822                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "country is not string");
823                 country = toString(countryData);
824                 result->setCountry(country);
825         }
826
827         if (!validator.isNullOrUndefined(regionData)) {
828                 if(!JSValueIsString(m_context, regionData))
829                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "region is not string");
830                 region = toString(regionData);
831                 result->setRegion(region);
832         }
833
834         if (!validator.isNullOrUndefined(cityData)) {
835                 if(!JSValueIsString(m_context, cityData))
836                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "city is not string");
837                 city = toString(cityData);
838                 result->setCity(city);
839         }
840
841         if (!validator.isNullOrUndefined(streetAddressData)) {
842                 if(!JSValueIsString(m_context, streetAddressData))
843                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "streetAddress is not string");
844                 streetAddress = toString(streetAddressData);
845                 result->setStreetAddress(streetAddress);
846         }
847
848         if (!validator.isNullOrUndefined(additionalInformationData)) {
849                 if(!JSValueIsString(m_context, additionalInformationData))
850                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "additionalInformation is not string");
851                 additionalInformation = toString(additionalInformationData);
852                 result->setAdditionalInformation(additionalInformation);
853         }
854
855         if (!validator.isNullOrUndefined(postalCodeData)) {
856                 if(!JSValueIsString(m_context, postalCodeData))
857                         ThrowMsg(WrtDeviceApis::Commons::ConversionException, "postalCode is not string");
858                 postalCode = toString(postalCodeData);
859                 result->setPostalCode(postalCode);
860         }
861
862         if (!validator.isNullOrUndefined(typesData)) {
863                 types = toContactAddressTypeArray(typesData);
864                 result->setTypes(types);
865         }
866
867         return result;
868 }
869
870 JSValueRef ContactConverter::toJSValueRef(const ContactAddressArrayPtr &arg)
871 {
872         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAddressArray::getClassRef(), arg);
873 }
874
875 ContactAddressArrayPtr ContactConverter::toContactAddressArray(const JSValueRef &jsValue)
876 {
877         if(JSContactAddressArray::isObjectOfClass(m_context, jsValue))
878                 return JSContactAddressArray::getContactAddressArray(m_context, jsValue);
879
880         if(!JSIsArrayValue(m_context, jsValue))
881                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactAddressArray is not array.");
882
883         ContactAddressArrayPtr result(new ContactAddressArray());
884
885         JSObjectRef jsObject = toJSObjectRef(jsValue);
886     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
887         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
888         result->push_back(toContactAddress(element));
889     }
890     return result;
891 }
892
893 JSValueRef ContactConverter::toJSValueRef(const ContactPhoneNumberPtr &arg)
894 {
895         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactPhoneNumber::getClassRef(), arg);
896 }
897
898 ContactPhoneNumberPtr ContactConverter::toContactPhoneNumber(const JSValueRef &jsValue)
899 {
900         if(!JSContactPhoneNumber::isObjectOfClass(m_context, jsValue))
901         {
902                 LogError("Not a ContactPhoneNumber object");
903                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
904         }
905
906         return JSContactPhoneNumber::getContactPhoneNumber(m_context, jsValue);
907 }
908
909 JSValueRef ContactConverter::toJSValueRef(const ContactPhoneNumberArrayPtr &arg)
910 {
911         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactPhoneNumberArray::getClassRef(), arg);
912 }
913
914 ContactPhoneNumberArrayPtr ContactConverter::toContactPhoneNumberArray(const JSValueRef &jsValue)
915 {
916         if(JSContactPhoneNumberArray::isObjectOfClass(m_context, jsValue))
917                 return JSContactPhoneNumberArray::getContactPhoneNumberArray(m_context, jsValue);
918
919         if(!JSIsArrayValue(m_context, jsValue))
920                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactPhoneNumberArray is not array.");
921
922         ContactPhoneNumberArrayPtr result(new ContactPhoneNumberArray());
923
924         JSObjectRef jsObject = toJSObjectRef(jsValue);
925     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
926         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
927         result->push_back(toContactPhoneNumber(element));
928     }
929     return result;
930 }
931
932 JSValueRef ContactConverter::toJSValueRef(const ContactEmailAddressPtr &arg)
933 {
934         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactEmailAddress::getClassRef(), arg);
935 }
936
937 ContactEmailAddressPtr ContactConverter::toContactEmailAddress(const JSValueRef &jsValue)
938 {
939         if(!JSContactEmailAddress::isObjectOfClass(m_context, jsValue))
940         {
941                 LogError("Not a ContactEmailAddress object");
942                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
943         }
944
945         return JSContactEmailAddress::getContactEmailAddress(m_context, jsValue);
946 }
947
948 JSValueRef ContactConverter::toJSValueRef(const ContactEmailAddressArrayPtr &arg)
949 {
950         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactEmailAddressArray::getClassRef(), arg);
951 }
952
953 ContactEmailAddressArrayPtr ContactConverter::toContactEmailAddressArray(const JSValueRef &jsValue)
954 {
955         if(JSContactEmailAddressArray::isObjectOfClass(m_context, jsValue))
956                 return JSContactEmailAddressArray::getContactEmailAddressArray(m_context, jsValue);
957
958         if(!JSIsArrayValue(m_context, jsValue))
959                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactEmailAddressArray is not array.");
960
961         ContactEmailAddressArrayPtr result(new ContactEmailAddressArray());
962
963         JSObjectRef jsObject = toJSObjectRef(jsValue);
964     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
965         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
966         result->push_back(toContactEmailAddress(element));
967     }
968     return result;
969 }
970
971 ContactWebSiteType ContactConverter::toContactWebSiteType(const std::string &arg)
972 {
973         std::string argUpper;
974         std::transform(arg.begin(), arg.end(), std::back_inserter(argUpper), ::toupper);
975
976         if (argUpper == STR_WEBSITE_TYPE_HOMEPAGE) {
977                 return WEBSITE_TYPE_HOMEPAGE;
978         } else if (argUpper == STR_WEBSITE_TYPE_BLOG) {
979                 return WEBSITE_TYPE_BLOG;
980         } else {
981                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactWebSiteType : " << arg);
982         }
983         return WEBSITE_TYPE_HOMEPAGE;
984 }
985
986 std::string ContactConverter::toContactWebSiteTypeStr(ContactWebSiteType arg)
987 {
988         if (arg == WEBSITE_TYPE_HOMEPAGE) {
989                 return STR_WEBSITE_TYPE_HOMEPAGE;
990         } else if (arg == WEBSITE_TYPE_BLOG) {
991                 return STR_WEBSITE_TYPE_BLOG;
992         } else {
993                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactWebSiteType : " << arg);
994         }
995         return STR_WEBSITE_TYPE_HOMEPAGE;
996 }
997
998 ContactWebSiteType ContactConverter::toContactWebSiteType(const JSValueRef &value)
999 {
1000         if(!JSValueIsString(m_context, value))
1001                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactWebSiteType is not string.");
1002
1003         return toContactWebSiteType(toString(value));
1004 }
1005
1006 JSValueRef ContactConverter::toJSValueRef(ContactWebSiteType arg)
1007 {
1008         return toJSValueRef(toContactWebSiteTypeStr(arg));
1009 }
1010
1011 ContactAddressType ContactConverter::toContactAddressType(const std::string &arg)
1012 {
1013         std::string argUpper;
1014         std::transform(arg.begin(), arg.end(), std::back_inserter(argUpper), ::toupper);
1015
1016         if (argUpper == STR_CONTACT_ADDRESS_TYPE_WORK) {
1017                 return CONTACT_ADDRESS_TYPE_WORK;
1018         } else if (argUpper == STR_CONTACT_ADDRESS_TYPE_PREF) {
1019                 return CONTACT_ADDRESS_TYPE_PREF;
1020         } else if (argUpper == STR_CONTACT_ADDRESS_TYPE_HOME) {
1021                 return CONTACT_ADDRESS_TYPE_HOME;
1022         } else {
1023                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactAddressType : " << arg);
1024         }
1025         return CONTACT_ADDRESS_TYPE_PREF;
1026 }
1027 std::string ContactConverter::toContactAddressTypeStr(ContactAddressType arg)
1028 {
1029         if (arg == CONTACT_ADDRESS_TYPE_WORK) {
1030                 return STR_CONTACT_ADDRESS_TYPE_WORK;
1031         } else if (arg == CONTACT_ADDRESS_TYPE_PREF) {
1032                 return STR_CONTACT_ADDRESS_TYPE_PREF;
1033         } else if (arg == CONTACT_ADDRESS_TYPE_HOME) {
1034                 return STR_CONTACT_ADDRESS_TYPE_HOME;
1035         } else {
1036                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactAddressType : " << arg);
1037         }
1038         return STR_CONTACT_ADDRESS_TYPE_PREF;
1039 }
1040
1041 ContactAddressType ContactConverter::toContactAddressType(const JSValueRef &value)
1042 {
1043         if(!JSValueIsString(m_context, value))
1044                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactAddressType is not string.");
1045
1046         return toContactAddressType(toString(value));
1047 }
1048
1049 JSValueRef ContactConverter::toJSValueRef(ContactAddressType arg)
1050 {
1051         return toJSValueRef(toContactAddressTypeStr(arg));
1052 }
1053
1054 JSValueRef ContactConverter::toJSValueRef(const ContactAddressTypeArrayPtr &arg)
1055 {
1056         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAddressTypeArray::getClassRef(), arg);
1057 }
1058
1059 ContactAddressTypeArrayPtr ContactConverter::toContactAddressTypeArray(const JSValueRef &jsValue)
1060 {
1061         if(JSContactAddressTypeArray::isObjectOfClass(m_context, jsValue))
1062                 return JSContactAddressTypeArray::getContactAddressTypeArray(m_context, jsValue);
1063
1064         if(!JSIsArrayValue(m_context, jsValue))
1065                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactAddressTypeArray is not array.");
1066
1067         ContactAddressTypeArrayPtr result(new ContactAddressTypeArray());
1068
1069         JSObjectRef jsObject = toJSObjectRef(jsValue);
1070     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
1071         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
1072         result->push_back(toContactAddressType(element));
1073     }
1074     return result;
1075 }
1076
1077 ContactPhoneNumberType ContactConverter::toContactPhoneNumberType(const std::string &arg)
1078 {
1079         std::string argUpper;
1080         std::transform(arg.begin(), arg.end(), std::back_inserter(argUpper), ::toupper);
1081
1082         if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_WORK) {
1083                 return CONTACT_PHONE_NUMBER_TYPE_WORK;
1084         } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_PREF) {
1085                 return CONTACT_PHONE_NUMBER_TYPE_PREF;
1086         } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_HOME) {
1087                 return CONTACT_PHONE_NUMBER_TYPE_HOME;
1088         } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_VOICE) {
1089                 return CONTACT_PHONE_NUMBER_TYPE_VOICE;
1090         } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_FAX) {
1091                 return CONTACT_PHONE_NUMBER_TYPE_FAX;
1092         } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_MSG) {
1093                 return CONTACT_PHONE_NUMBER_TYPE_MSG;
1094         } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_CELL) {
1095                 return CONTACT_PHONE_NUMBER_TYPE_CELL;
1096         } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_PAGER) {
1097                 return CONTACT_PHONE_NUMBER_TYPE_PAGER;
1098         } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_BBS) {
1099                 return CONTACT_PHONE_NUMBER_TYPE_BBS;
1100         } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_MODEM) {
1101                 return CONTACT_PHONE_NUMBER_TYPE_MODEM;
1102         } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_CAR) {
1103                 return CONTACT_PHONE_NUMBER_TYPE_CAR;
1104         } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_ISDN) {
1105                 return CONTACT_PHONE_NUMBER_TYPE_ISDN;
1106         } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_VIDEO) {
1107                 return CONTACT_PHONE_NUMBER_TYPE_VIDEO;
1108         } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_PCS) {
1109                 return CONTACT_PHONE_NUMBER_TYPE_PCS;
1110         } else {
1111                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactPhoneNumverType : " << arg);
1112         }
1113         return CONTACT_PHONE_NUMBER_TYPE_WORK;
1114 }
1115
1116 std::string ContactConverter::toContactPhoneNumberTypeStr(ContactPhoneNumberType arg)
1117 {
1118         if (arg == CONTACT_PHONE_NUMBER_TYPE_WORK) {
1119                 return STR_CONTACT_PHONE_NUMBER_TYPE_WORK;
1120         } else if (arg == CONTACT_PHONE_NUMBER_TYPE_PREF) {
1121                 return STR_CONTACT_PHONE_NUMBER_TYPE_PREF;
1122         } else if (arg == CONTACT_PHONE_NUMBER_TYPE_HOME) {
1123                 return STR_CONTACT_PHONE_NUMBER_TYPE_HOME;
1124         } else if (arg == CONTACT_PHONE_NUMBER_TYPE_VOICE) {
1125                 return STR_CONTACT_PHONE_NUMBER_TYPE_VOICE;
1126         } else if (arg == CONTACT_PHONE_NUMBER_TYPE_FAX) {
1127                 return STR_CONTACT_PHONE_NUMBER_TYPE_FAX;
1128         } else if (arg == CONTACT_PHONE_NUMBER_TYPE_MSG) {
1129                 return STR_CONTACT_PHONE_NUMBER_TYPE_MSG;
1130         } else if (arg == CONTACT_PHONE_NUMBER_TYPE_CELL) {
1131                 return STR_CONTACT_PHONE_NUMBER_TYPE_CELL;
1132         } else if (arg == CONTACT_PHONE_NUMBER_TYPE_PAGER) {
1133                 return STR_CONTACT_PHONE_NUMBER_TYPE_PAGER;
1134         } else if (arg == CONTACT_PHONE_NUMBER_TYPE_BBS) {
1135                 return STR_CONTACT_PHONE_NUMBER_TYPE_BBS;
1136         } else if (arg == CONTACT_PHONE_NUMBER_TYPE_MODEM) {
1137                 return STR_CONTACT_PHONE_NUMBER_TYPE_MODEM;
1138         } else if (arg == CONTACT_PHONE_NUMBER_TYPE_CAR) {
1139                 return STR_CONTACT_PHONE_NUMBER_TYPE_CAR;
1140         } else if (arg == CONTACT_PHONE_NUMBER_TYPE_ISDN) {
1141                 return STR_CONTACT_PHONE_NUMBER_TYPE_ISDN;
1142         } else if (arg == CONTACT_PHONE_NUMBER_TYPE_VIDEO) {
1143                 return STR_CONTACT_PHONE_NUMBER_TYPE_VIDEO;
1144         } else if (arg == CONTACT_PHONE_NUMBER_TYPE_PCS) {
1145                 return STR_CONTACT_PHONE_NUMBER_TYPE_PCS;
1146         } else {
1147                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactPhoneNumverType : " << arg);
1148         }
1149         return STR_CONTACT_PHONE_NUMBER_TYPE_WORK;
1150 }
1151
1152 ContactPhoneNumberType ContactConverter::toContactPhoneNumberType(const JSValueRef &value)
1153 {
1154         if(!JSValueIsString(m_context, value))
1155                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactPhoneNumberType is not string.");
1156
1157         return toContactPhoneNumberType(toString(value));
1158 }
1159
1160 JSValueRef ContactConverter::toJSValueRef(ContactPhoneNumberType arg)
1161 {
1162         return toJSValueRef(toContactPhoneNumberTypeStr(arg));
1163 }
1164
1165 JSValueRef ContactConverter::toJSValueRef(const ContactPhoneNumberTypeArrayPtr &arg)
1166 {
1167         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactPhoneNumberTypeArray::getClassRef(), arg);
1168 }
1169
1170 ContactPhoneNumberTypeArrayPtr ContactConverter::toContactPhoneNumberTypeArray(const JSValueRef &jsValue)
1171 {
1172         if(JSContactPhoneNumberTypeArray::isObjectOfClass(m_context, jsValue))
1173                 return JSContactPhoneNumberTypeArray::getContactPhoneNumberTypeArray(m_context, jsValue);
1174
1175         if(!JSIsArrayValue(m_context, jsValue))
1176                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactEmailAddressTypeArray is not array.");
1177
1178         ContactPhoneNumberTypeArrayPtr result(new ContactPhoneNumberTypeArray());
1179
1180         JSObjectRef jsObject = toJSObjectRef(jsValue);
1181     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
1182         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
1183         Try {
1184                 result->push_back(toContactPhoneNumberType(element));
1185         } Catch (Exception) {
1186                 // nothing
1187         }
1188     }
1189     return result;
1190 }
1191
1192 ContactEmailAddressType ContactConverter::toContactEmailAddressType(const std::string &arg)
1193 {
1194         std::string argUpper;
1195         std::transform(arg.begin(), arg.end(), std::back_inserter(argUpper), ::toupper);
1196
1197         if (argUpper == STR_CONTACT_EMAIL_TYPE_WORK) {
1198                 return CONTACT_EMAIL_TYPE_WORK;
1199         } else if (argUpper == STR_CONTACT_EMAIL_TYPE_PREF) {
1200                 return CONTACT_EMAIL_TYPE_PREF;
1201         } else if (argUpper == STR_CONTACT_EMAIL_TYPE_HOME) {
1202                 return CONTACT_EMAIL_TYPE_HOME;
1203         } else {
1204                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactEmailAddressType : " << arg);
1205         }
1206         return CONTACT_EMAIL_TYPE_PREF;
1207 }
1208
1209 std::string ContactConverter::toContactEmailAddressTypeStr(ContactEmailAddressType arg)
1210 {
1211         if (arg == CONTACT_EMAIL_TYPE_WORK) {
1212                 return STR_CONTACT_EMAIL_TYPE_WORK;
1213         } else if (arg == CONTACT_EMAIL_TYPE_PREF) {
1214                 return STR_CONTACT_EMAIL_TYPE_PREF;
1215         } else if (arg == CONTACT_EMAIL_TYPE_HOME) {
1216                 return STR_CONTACT_EMAIL_TYPE_HOME;
1217         } else {
1218                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactEmailAddressType : " << arg);
1219         }
1220         return STR_CONTACT_EMAIL_TYPE_PREF;
1221 }
1222
1223 ContactEmailAddressType ContactConverter::toContactEmailAddressType(const JSValueRef &value)
1224 {
1225         if(!JSValueIsString(m_context, value))
1226                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactEmailAddressType is not string.");
1227
1228         return toContactEmailAddressType(toString(value));
1229 }
1230
1231 JSValueRef ContactConverter::toJSValueRef(ContactEmailAddressType arg)
1232 {
1233         return toJSValueRef(toContactEmailAddressTypeStr(arg));
1234 }
1235
1236 JSValueRef ContactConverter::toJSValueRef(const ContactEmailAddressTypeArrayPtr &arg)
1237 {
1238         return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactEmailAddressTypeArray::getClassRef(), arg);
1239 }
1240
1241 ContactEmailAddressTypeArrayPtr ContactConverter::toContactEmailAddressTypeArray(const JSValueRef &jsValue)
1242 {
1243         if(JSContactEmailAddressTypeArray::isObjectOfClass(m_context, jsValue))
1244                 return JSContactEmailAddressTypeArray::getContactEmailAddressTypeArray(m_context, jsValue);
1245
1246         if(!JSIsArrayValue(m_context, jsValue))
1247                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactEmailAddressTypeArray is not array.");
1248
1249         ContactEmailAddressTypeArrayPtr result(new ContactEmailAddressTypeArray());
1250
1251         JSObjectRef jsObject = toJSObjectRef(jsValue);
1252     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
1253         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
1254         Try {
1255                 result->push_back(toContactEmailAddressType(element));
1256         } Catch (Exception) {
1257                 // nothing
1258         }
1259     }
1260     return result;
1261 }
1262
1263 StringArrayPtr ContactConverter::toStringArray(const JSValueRef &jsValue)
1264 {
1265         if(JSStringArray::isObjectOfClass(m_context, jsValue))
1266                 return JSStringArray::getStringArray(m_context, jsValue);
1267
1268         if(!JSIsArrayValue(m_context, jsValue))
1269                 ThrowMsg(WrtDeviceApis::Commons::ConversionException, "StringArray is not array.");
1270
1271         StringArrayPtr result = StringArrayPtr(new StringArray());
1272         JSObjectRef jsObject = toJSObjectRef(jsValue);
1273     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
1274         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
1275         result->push_back(toString(element));
1276     }
1277     return result;
1278 }
1279
1280 JSValueRef ContactConverter::toJSValueRef(const StringArrayPtr &arg)
1281 {
1282         return JSStringArray::createArray(m_context, arg);
1283 }
1284
1285 //std::string ContactConverter::toAttributesOfInterest(const JSValueRef &value)
1286 //{
1287 //      // need validator
1288 //      return toString(value);
1289 //}
1290
1291 //JSValueRef ContactConverter::toJSValueRefAttributesOfInterestArray(const AttributesOfInterestArrayPtr &arg)
1292 //{
1293 //      return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSAttributesOfInterestArray::getClassRef(), arg);
1294 //}
1295
1296 //AttributesOfInterestArrayPtr ContactConverter::toAttributesOfInterestArray(const JSValueRef &jsValue)
1297 //{
1298 //      if(JSAttributesOfInterestArray::isObjectOfClass(m_context, jsValue))
1299 //              return JSAttributesOfInterestArray::getAttributesOfInterestArray(m_context, jsValue);
1300 //
1301 //      if(!JSIsArrayValue(m_context, jsValue))
1302 //              ThrowMsg(WrtDeviceApis::Commons::ConversionException, "AttributesOfInterestArray is not array.");
1303 //
1304 //      AttributesOfInterestArrayPtr result(new AttributesOfInterestArray());
1305 //
1306 //      JSObjectRef jsObject = toJSObjectRef(jsValue);
1307 //    for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
1308 //        JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
1309 //        result->push_back(toAttributesOfInterest(element));
1310 //    }
1311 //    return result;
1312 //}
1313
1314 bool ContactConverter::initializeAllowedProperties()
1315 {
1316         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_NAME);
1317         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_ACCOUNT);
1318         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_ADDRESSES);
1319         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_PHOTO_URI );
1320         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_PHONE_NUMBERS);
1321         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_EMAILS);
1322         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_BIRTHDAY);
1323         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_ANNIVERSARIES);
1324         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_ORGANIZATION);
1325         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_NOTES);
1326         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_URLS);
1327         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_IS_FAVORITE);
1328         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_RINGTONE_URI);
1329         m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_CATEGORIES);
1330
1331         m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_PREFIX);
1332         m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_FIRST_NAME);
1333         m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_MIDDLE_NAME);
1334         m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_LAST_NAME);
1335         m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_NICKNAMES);
1336         m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_PHONETIC_NAME);
1337         m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_DISPLAY_NAME);
1338
1339         m_allowedContactOrganizationInit.push_back(CONTACT_ATTRIBUTE_NAME);
1340         m_allowedContactOrganizationInit.push_back(CONTACT_ATTRIBUTE_DEPARTMENT);
1341         m_allowedContactOrganizationInit.push_back(CONTACT_ATTRIBUTE_OFFICE);
1342         m_allowedContactOrganizationInit.push_back(CONTACT_ATTRIBUTE_TITLE);
1343         m_allowedContactOrganizationInit.push_back(CONTACT_ATTRIBUTE_ROLE);
1344         m_allowedContactOrganizationInit.push_back(CONTACT_ATTRIBUTE_LOGO_URI);
1345
1346         m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_COUNTRY);
1347         m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_REGION);
1348         m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_CITY);
1349         m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_STREET_ADDRESS);
1350         m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_ADDITIONAL_INFORMATION);
1351         m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_POSTAL_CODE);
1352         m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_TYPES);
1353
1354         return true;
1355 }
1356
1357 } // Contact
1358 } // Tizen1_0
1359 } // TizenApis