src/Contact/ContactConverter.cpp

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