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