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