projects / profile / ivi / wrt-plugins-tizen.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
merge wrt-plugins-tizen_0.2.0-2
[profile/ivi/wrt-plugins-tizen.git] / src / standards / Tizen / Contact / ContactConverter.cpp
diff --git a/src/standards/Tizen/Contact/ContactConverter.cpp b/src/standards/Tizen/Contact/ContactConverter.cpp
index 722ae55..259d4b8 100755 (executable)
--- a/src/standards/Tizen/Contact/ContactConverter.cpp
+++ b/src/standards/Tizen/Contact/ContactConverter.cpp
@@ -21,20 +21,22 @@
  * @brief
  */
 
+#include <algorithm>
 #include <dpl/log/log.h>
 #include <CommonsJavaScript/Validator.h>
 #include <CommonsJavaScript/ScopedJSStringRef.h>
 #include <CommonsJavaScript/JSUtils.h>
 #include <Commons/RegexUtils.h>
+#include <API/Contact/ContactFactory.h>
 
 #include "ContactConverter.h"
 #include "AddressBookController.h"
 #include "JSAddressBook.h"
 #include "JSAddressBookArray.h"
-#include "JSAttributesOfInterestArray.h"
+//#include "JSAttributesOfInterestArray.h"
 #include "JSContact.h"
+#include "JSContactRef.h"
 #include "JSContactArray.h"
-#include "JSContactProperties.h"
 #include "JSContactName.h"
 #include "JSContactAccount.h"
 #include "JSContactAnniversary.h"
@@ -56,11 +58,11 @@
 #include "JSStringArray.h"
 
 #define CONTACT_ATTRIBUTE_ACCOUNT "account"
-#define CONTACT_ATTRIBUTE_ACCOUNT_ID "accountId"
+#define CONTACT_ATTRIBUTE_ACCOUNT_SERVICE_ID "accountServiceId"
 #define CONTACT_ATTRIBUTE_ADDITIONAL_INFORMATION "additionalInformation"
 #define CONTACT_ATTRIBUTE_ADDRESSES "addresses"
 #define CONTACT_ATTRIBUTE_ANNIVERSARIES "anniversaries"
-#define CONTACT_ATTRIBUTE_ATTRIBUTES_OF_INTEREST "attributesOfInterest"
+//#define CONTACT_ATTRIBUTE_ATTRIBUTES_OF_INTEREST "attributesOfInterest"
 #define CONTACT_ATTRIBUTE_BIRTHDAY "birthday"
 #define CONTACT_ATTRIBUTE_CATEGORIES "categories"
 #define CONTACT_ATTRIBUTE_CITY "city"
@@ -138,274 +140,29 @@ using namespace TizenApis::Api::Contact;
 using namespace WrtDeviceApis::Commons;
 using namespace WrtDeviceApis::CommonsJavaScript;
 
-std::vector<std::string> ContactConverter::m_allowedAddressBookProperties;
-std::vector<std::string> ContactConverter::m_allowedContactProperties;
-std::vector<std::string> ContactConverter::m_allowedContactPropertiesProperties;
-std::vector<std::string> ContactConverter::m_allowedContactNameProperties;
-std::vector<std::string> ContactConverter::m_allowedContactAccountProperties;
-std::vector<std::string> ContactConverter::m_allowedContactOrganizationProperties;
-std::vector<std::string> ContactConverter::m_allowedContactWebSiteProperties;
-std::vector<std::string> ContactConverter::m_allowedContactAnniversaryProperties;
-std::vector<std::string> ContactConverter::m_allowedContactAddressProperties;
-std::vector<std::string> ContactConverter::m_allowedContactPhoneNumberProperties;
-std::vector<std::string> ContactConverter::m_allowedContactEmailAddressProperties;
+std::vector<std::string> ContactConverter::m_allowedContactInit;
+std::vector<std::string> ContactConverter::m_allowedContactNameInit;
+std::vector<std::string> ContactConverter::m_allowedContactOrganizationInit;
+std::vector<std::string> ContactConverter::m_allowedContactAddressInit;
 
 ContactConverter::ContactConverter(JSContextRef context) : Converter(context)
 {
-//    //LogDebug("entered");
-    static bool init = initializeAllowedProperties();
-    (void) init;
+       static bool init = initializeAllowedProperties();
+       (void) init;
 }
 
 ContactConverter::~ContactConverter()
 {
-//    //LogDebug("entered");
 }
 
-StringArrayPtr ContactConverter::toStringArray(const JSValueRef &jsValue)
-{
-       if(JSStringArray::isObjectOfClass(m_context, jsValue))
-               return JSStringArray::getStringArray(m_context, jsValue);
-
-       StringArrayPtr result = StringArrayPtr(new StringArray());
-       JSObjectRef jsObject = toJSObjectRef(jsValue);
-    for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
-        JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
-        result->push_back(toString(element));
-    }
-    return result;
-}
-
-JSValueRef ContactConverter::toJSValueRef(const StringArrayPtr &arg)
-{
-       return JSStringArray::createArray(m_context, arg);
-}
-
-// types converters
-ContactEmailAddressType ContactConverter::toContactEmailAddressType(const std::string &arg)
-{
-//     //LogDebug("entered");
-       if (arg == STR_CONTACT_EMAIL_TYPE_WORK) {
-               return CONTACT_EMAIL_TYPE_WORK;
-       } else if (arg == STR_CONTACT_EMAIL_TYPE_PREF) {
-               return CONTACT_EMAIL_TYPE_PREF;
-       } else if (arg == STR_CONTACT_EMAIL_TYPE_HOME) {
-               return CONTACT_EMAIL_TYPE_HOME;
-       } else {
-               Throw(WrtDeviceApis::Commons::ConversionException);
-       }
-       return CONTACT_EMAIL_TYPE_PREF;
-}
-
-std::string ContactConverter::toContactEmailAddressTypeStr(ContactEmailAddressType arg)
-{
-//     //LogDebug("entered");
-       if (arg == CONTACT_EMAIL_TYPE_WORK) {
-               return STR_CONTACT_EMAIL_TYPE_WORK;
-       } else if (arg == CONTACT_EMAIL_TYPE_PREF) {
-               return STR_CONTACT_EMAIL_TYPE_PREF;
-       } else if (arg == CONTACT_EMAIL_TYPE_HOME) {
-               return STR_CONTACT_EMAIL_TYPE_HOME;
-       } else {
-               Throw(WrtDeviceApis::Commons::ConversionException);
-       }
-       return STR_CONTACT_EMAIL_TYPE_PREF;
-}
-
-ContactEmailAddressType ContactConverter::toContactEmailAddressType(const JSValueRef &value)
-{
-       return toContactEmailAddressType(toString(value));
-}
-
-JSValueRef ContactConverter::toJSValueRef(ContactEmailAddressType arg)
-{
-       return toJSValueRef(toContactEmailAddressTypeStr(arg));
-}
-
-ContactPhoneNumberType ContactConverter::toContactPhoneNumberType(const std::string &arg)
-{
-//     //LogDebug("entered");
-       if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_WORK) {
-               return CONTACT_PHONE_NUMBER_TYPE_WORK;
-       } else if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_PREF) {
-               return CONTACT_PHONE_NUMBER_TYPE_PREF;
-       } else if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_HOME) {
-               return CONTACT_PHONE_NUMBER_TYPE_HOME;
-       } else if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_VOICE) {
-               return CONTACT_PHONE_NUMBER_TYPE_VOICE;
-       } else if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_FAX) {
-               return CONTACT_PHONE_NUMBER_TYPE_FAX;
-       } else if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_MSG) {
-               return CONTACT_PHONE_NUMBER_TYPE_MSG;
-       } else if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_CELL) {
-               return CONTACT_PHONE_NUMBER_TYPE_CELL;
-       } else if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_PAGER) {
-               return CONTACT_PHONE_NUMBER_TYPE_PAGER;
-       } else if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_BBS) {
-               return CONTACT_PHONE_NUMBER_TYPE_BBS;
-       } else if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_MODEM) {
-               return CONTACT_PHONE_NUMBER_TYPE_MODEM;
-       } else if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_CAR) {
-               return CONTACT_PHONE_NUMBER_TYPE_CAR;
-       } else if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_ISDN) {
-               return CONTACT_PHONE_NUMBER_TYPE_ISDN;
-       } else if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_VIDEO) {
-               return CONTACT_PHONE_NUMBER_TYPE_VIDEO;
-       } else if (arg == STR_CONTACT_PHONE_NUMBER_TYPE_PCS) {
-               return CONTACT_PHONE_NUMBER_TYPE_PCS;
-       } else {
-               Throw(WrtDeviceApis::Commons::ConversionException);
-       }
-       return CONTACT_PHONE_NUMBER_TYPE_WORK;
-}
-
-std::string ContactConverter::toContactPhoneNumberTypeStr(ContactPhoneNumberType arg)
-{
-//     //LogDebug("entered");
-       if (arg == CONTACT_PHONE_NUMBER_TYPE_WORK) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_WORK;
-       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_PREF) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_PREF;
-       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_HOME) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_HOME;
-       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_VOICE) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_VOICE;
-       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_FAX) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_FAX;
-       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_MSG) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_MSG;
-       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_CELL) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_CELL;
-       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_PAGER) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_PAGER;
-       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_BBS) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_BBS;
-       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_MODEM) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_MODEM;
-       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_CAR) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_CAR;
-       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_ISDN) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_ISDN;
-       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_VIDEO) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_VIDEO;
-       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_PCS) {
-               return STR_CONTACT_PHONE_NUMBER_TYPE_PCS;
-       } else {
-               Throw(WrtDeviceApis::Commons::ConversionException);
-       }
-       return STR_CONTACT_PHONE_NUMBER_TYPE_WORK;
-}
-
-ContactPhoneNumberType ContactConverter::toContactPhoneNumberType(const JSValueRef &value)
-{
-       return toContactPhoneNumberType(toString(value));
-}
-
-JSValueRef ContactConverter::toJSValueRef(ContactPhoneNumberType arg)
-{
-       return toJSValueRef(toContactPhoneNumberTypeStr(arg));
-}
-
-ContactAddressType ContactConverter::toContactAddressType(const std::string &arg)
-{
-//     //LogDebug("entered");
-       if (arg == STR_CONTACT_ADDRESS_TYPE_WORK) {
-               return CONTACT_ADDRESS_TYPE_WORK;
-       } else if (arg == STR_CONTACT_ADDRESS_TYPE_PREF) {
-               return CONTACT_ADDRESS_TYPE_PREF;
-       } else if (arg == STR_CONTACT_ADDRESS_TYPE_HOME) {
-               return CONTACT_ADDRESS_TYPE_HOME;
-       } else {
-               Throw(WrtDeviceApis::Commons::ConversionException);
-       }
-       return CONTACT_ADDRESS_TYPE_PREF;
-}
-std::string ContactConverter::toContactAddressTypeStr(ContactAddressType arg)
+JSValueRef ContactConverter::toJSValueRef(const AddressBookPtr &arg)
 {
-//     //LogDebug("entered");
-       if (arg == CONTACT_ADDRESS_TYPE_WORK) {
-               return STR_CONTACT_ADDRESS_TYPE_WORK;
-       } else if (arg == CONTACT_ADDRESS_TYPE_PREF) {
-               return STR_CONTACT_ADDRESS_TYPE_PREF;
-       } else if (arg == CONTACT_ADDRESS_TYPE_HOME) {
-               return STR_CONTACT_ADDRESS_TYPE_HOME;
-       } else {
-               Throw(WrtDeviceApis::Commons::ConversionException);
-       }
-       return STR_CONTACT_ADDRESS_TYPE_PREF;
-}
-
-ContactAddressType ContactConverter::toContactAddressType(const JSValueRef &value)
-{
-       return toContactAddressType(toString(value));
-}
-
-JSValueRef ContactConverter::toJSValueRef(ContactAddressType arg)
-{
-       return toJSValueRef(toContactAddressTypeStr(arg));
-}
-
-ContactWebSiteType ContactConverter::toContactWebSiteType(const std::string &arg)
-{
-       //LogDebug("entered");
-       if (arg == STR_WEBSITE_TYPE_HOMEPAGE) {
-               return WEBSITE_TYPE_HOMEPAGE;
-       } else if (arg == STR_WEBSITE_TYPE_BLOG) {
-               return WEBSITE_TYPE_BLOG;
-       } else {
-               Throw(WrtDeviceApis::Commons::ConversionException);
-       }
-       return WEBSITE_TYPE_HOMEPAGE;
-}
-
-std::string ContactConverter::toContactWebSiteTypeStr(ContactWebSiteType arg)
-{
-       //LogDebug("entered");
-       if (arg == WEBSITE_TYPE_HOMEPAGE) {
-               return STR_WEBSITE_TYPE_HOMEPAGE;
-       } else if (arg == WEBSITE_TYPE_BLOG) {
-               return STR_WEBSITE_TYPE_BLOG;
-       } else {
-               Throw(WrtDeviceApis::Commons::ConversionException);
-       }
-       return STR_WEBSITE_TYPE_HOMEPAGE;
-}
-
-ContactWebSiteType ContactConverter::toContactWebSiteType(const JSValueRef &value)
-{
-       return toContactWebSiteType(toString(value));
-}
-
-JSValueRef ContactConverter::toJSValueRef(ContactWebSiteType arg)
-{
-       return toJSValueRef(toContactWebSiteTypeStr(arg));
-}
-
-ContactCapabilityType ContactConverter::toContactCapabilityType(const JSValueRef &value)
-{
-       int result = toInt(value);
-       if(HAS_VIDEO_CAPABILITY != result &&
-                       HAS_VOICE_CAPABILITY != result &&
-                       HAS_CAMERA_CAPABILITY != result)
-               Throw(WrtDeviceApis::Commons::ConversionException);
-
-       return static_cast<ContactCapabilityType>(result);
-}
-
-std::string ContactConverter::toAttributesOfInterest(const JSValueRef &value)
-{
-       // TODO validate
-       return toString(value);
-}
-
-JSValueRef ContactConverter::toJSValueRef(const IAddressBookPtr &arg)
-{
-       //LogDebug("entered");
+       // It may not used
        AddressBookController *priv = new AddressBookController(m_context, arg);
        return JSObjectMake(m_context, JSAddressBook::getClassRef(), priv);
 }
 
-IAddressBookPtr ContactConverter::toAddressBook(const JSValueRef &jsValue)
+AddressBookPtr ContactConverter::toAddressBook(const JSValueRef &jsValue)
 {
        if(!JSAddressBook::isObjectOfClass(m_context, jsValue))
                ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
@@ -413,11 +170,10 @@ IAddressBookPtr ContactConverter::toAddressBook(const JSValueRef &jsValue)
        return JSAddressBook::getAddressBook(m_context, jsValue);
 }
 
-JSValueRef ContactConverter::toJSValueRef(const IAddressBookArrayPtr &arg)
+JSValueRef ContactConverter::toJSValueRef(const AddressBookArrayPtr &arg)
 {
+       // TODO Check it is right? not a platform object right?
        int size = arg->size();
-       if(size == 0)
-               return JSValueMakeNull(m_context);
 
        JSObjectRef resultObject = JSCreateArrayObject(m_context, 0, NULL);
        if (!resultObject)
@@ -433,12 +189,15 @@ JSValueRef ContactConverter::toJSValueRef(const IAddressBookArrayPtr &arg)
        return static_cast<JSValueRef>(resultObject);
 }
 
-IAddressBookArrayPtr ContactConverter::toAddressBookArray(const JSValueRef &jsValue)
+AddressBookArrayPtr ContactConverter::toAddressBookArray(const JSValueRef &jsValue)
 {
        if(JSAddressBookArray::isObjectOfClass(m_context, jsValue))
                return JSAddressBookArray::getAddressBookArray(m_context, jsValue);
 
-       IAddressBookArrayPtr result(new IAddressBookArray());
+       if(!JSIsArrayValue(m_context, jsValue))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "AddressBookArray is not array.");
+
+       AddressBookArrayPtr result(new AddressBookArray());
 
        JSObjectRef jsObject = toJSObjectRef(jsValue);
     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
@@ -450,53 +209,36 @@ IAddressBookArrayPtr ContactConverter::toAddressBookArray(const JSValueRef &jsVa
 
 JSValueRef ContactConverter::toJSValueRef(const ContactPtr &arg)
 {
-       //LogDebug("entered");
        return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContact::getClassRef(), arg);
 }
 
 ContactPtr ContactConverter::toContact(const JSValueRef &jsValue)
 {
        if(!JSContact::isObjectOfClass(m_context, jsValue))
+       {
+               LogError("Not a Contact object");
                ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
 
        return JSContact::getContact(m_context, jsValue);
 }
 
-JSValueRef ContactConverter::toJSValueRef(const ContactArrayPtr &arg)
-{
-       //LogDebug("entered");
-       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactArray::getClassRef(), arg);
-}
-
-ContactArrayPtr ContactConverter::toContactArray(const JSValueRef &jsValue)
-{
-       if(JSContactArray::isObjectOfClass(m_context, jsValue))
-               return JSContactArray::getContactArray(m_context, jsValue);
-
-       ContactArrayPtr result = ContactArrayPtr(new ContactArray());
-
-       JSObjectRef jsObject = toJSObjectRef(jsValue);
-    for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
-        JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
-        result->push_back(toContact(element));
-    }
-    return result;
-}
-
-JSValueRef ContactConverter::toJSValueRef(const ContactPropertiesPtr &arg)
+ContactPtr ContactConverter::toContactFromInit(const JSValueRef &jsValue)
 {
-       // TODO make user object
-       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactProperties::getClassRef(), arg);
-}
+       // from ContactInit to Contact
+       Validator validator(m_context);
+       if (validator.isNullOrUndefined(jsValue)) {
+               LogError("ContactInit object is null");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
 
-ContactPropertiesPtr ContactConverter::toContactProperties(const JSValueRef &jsValue)
-{
-       if(JSContactProperties::isObjectOfClass(m_context, jsValue))
-               return JSContactProperties::getContactProperties(m_context, jsValue);
+       if (!JSValueIsObject(m_context, jsValue) || JSIsArrayValue(m_context, jsValue)) {
+               LogError("ContactInit object is not object");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
 
-       Validator validator(m_context);
-       if (!validator.checkArrayKeys(m_allowedContactPropertiesProperties, jsValue)) {
-               LogError("invalid properties in contact object");
+       if (!validator.checkArrayKeys(m_allowedContactInit, jsValue)) {
+               LogError("invalid properties in ContactInit object");
                ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
        }
 
@@ -547,77 +289,85 @@ ContactPropertiesPtr ContactConverter::toContactProperties(const JSValueRef &jsV
        std::string ringtoneURI;
        StringArrayPtr categories;
 
-       ContactPropertiesPtr result = ContactPropertiesPtr(new ContactProperties());
+       ContactPtr result = ContactFactory::getInstance().createContact();
        if (!result) {
-               Throw(WrtDeviceApis::Commons::ConversionException);
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Cannot create Contact object");
        }
 
-       if (!JSValueIsUndefined(m_context, nameData)) {
+       if (!validator.isNullOrUndefined(nameData)) {
                name = toContactName(nameData);
                result->setName(name);
        }
 
-       if (!JSValueIsUndefined(m_context, accountData)) {
+       if (!validator.isNullOrUndefined(accountData)) {
                account = toContactAccount(accountData);
                result->setAccount(account);
        }
 
-       if (!JSValueIsUndefined(m_context, addressesData)) {
+       if (!validator.isNullOrUndefined(addressesData)) {
                addresses = toContactAddressArray(addressesData);
                result->setAddresses(addresses);
        }
 
-       if (!JSValueIsUndefined(m_context, photoURIData)) {
+       if (!validator.isNullOrUndefined(photoURIData)) {
+               if(!JSValueIsString(m_context, photoURIData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "photoURI is not string");
                photoURI = toString(photoURIData);
                result->setPhotoURI(photoURI);
        }
 
-       if (!JSValueIsUndefined(m_context, phoneNumbersData)) {
+       if (!validator.isNullOrUndefined(phoneNumbersData)) {
                phoneNumbers = toContactPhoneNumberArray(phoneNumbersData);
                result->setPhoneNumbers(phoneNumbers);
        }
 
-       if (!JSValueIsUndefined(m_context, emailsData)) {
+       if (!validator.isNullOrUndefined(emailsData)) {
                emails = toContactEmailAddressArray(emailsData);
                result->setEmails(emails);
        }
 
-       if (!JSValueIsUndefined(m_context, birthdayData)) {
+       if (!validator.isNullOrUndefined(birthdayData)) {
+               if(!validator.isDate(birthdayData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "birthday is not Date");
                birthday = toDateTm(birthdayData);
                result->setBirthday(birthday);
        }
 
-       if (!JSValueIsUndefined(m_context, anniversariesData)) {
+       if (!validator.isNullOrUndefined(anniversariesData)) {
                anniversaries = toContactAnniversaryArray(anniversariesData);
                result->setAnniversaries(anniversaries);
        }
 
-       if (!JSValueIsUndefined(m_context, organizationData)) {
+       if (!validator.isNullOrUndefined(organizationData)) {
                organization = toContactOrganization(organizationData);
                result->setOrganization(organization);
        }
 
-       if (!JSValueIsUndefined(m_context, notesData)) {
+       if (!validator.isNullOrUndefined(notesData)) {
                notes = toStringArray(notesData);
                result->setNotes(notes);
        }
 
-       if (!JSValueIsUndefined(m_context, urlsData)) {
+       if (!validator.isNullOrUndefined(urlsData)) {
                urls = toContactWebSiteArray(urlsData);
                result->setUrls(urls);
        }
 
-       if (!JSValueIsUndefined(m_context, isFavoriteData)) {
+       if (!validator.isNullOrUndefined(isFavoriteData)) {
+               if(!JSValueIsBoolean(m_context, isFavoriteData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "isFavorite is not boolean");
                isFavorite = toBool(isFavoriteData);
                result->setIsFavorite(isFavorite);
        }
 
-       if (!JSValueIsUndefined(m_context, ringtoneURIData)) {
+       if (!validator.isNullOrUndefined(ringtoneURIData)) {
+               if(!JSValueIsString(m_context, ringtoneURIData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ringtoneURI is not string");
                ringtoneURI = toString(ringtoneURIData);
                result->setRingtoneURI(ringtoneURI);
        }
 
-       if (!JSValueIsUndefined(m_context, categoriesData)) {
+       if (!validator.isNullOrUndefined(categoriesData)) {
                categories = toStringArray(categoriesData);
                result->setCategories(categories);
        }
@@ -625,12 +375,10 @@ ContactPropertiesPtr ContactConverter::toContactProperties(const JSValueRef &jsV
        return result;
 }
 
-JSValueRef ContactConverter::toJSValueRef(const ContactPropertiesArrayPtr &arg)
+JSValueRef ContactConverter::toJSValueRef(const ContactArrayPtr &arg)
 {
-       //LogDebug("entered");
+       // TODO Check it is right? not a platform object right?
        int size = arg->size();
-       if(size == 0)
-               return JSValueMakeNull(m_context);
 
        JSObjectRef resultObject = JSCreateArrayObject(m_context, 0, NULL);
        if (!resultObject)
@@ -640,38 +388,79 @@ JSValueRef ContactConverter::toJSValueRef(const ContactPropertiesArrayPtr &arg)
        {
                JSValueRef jsvalue = toJSValueRef(arg->at(i));
                if (!JSSetArrayElement(m_context, resultObject, i, jsvalue))
-                       ThrowMsg(ConversionException, "Can not fill contact properties array.");
+                       ThrowMsg(ConversionException, "Can not fill contact array.");
        }
 
        return static_cast<JSValueRef>(resultObject);
 }
 
-ContactPropertiesArrayPtr ContactConverter::toContactPropertiesArray(const JSValueRef &jsValue)
+ContactArrayPtr ContactConverter::toContactArray(const JSValueRef &jsValue)
 {
-       ContactPropertiesArrayPtr result = ContactPropertiesArrayPtr(new ContactPropertiesArray());
+//  // toJSValueRef(ContactArrayPtr) creates user object.
+//     if(JSContactArray::isObjectOfClass(m_context, jsValue))
+//             return JSContactArray::getContactArray(m_context, jsValue);
+
+       if(!JSIsArrayValue(m_context, jsValue))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactArray is not array.");
+
+       ContactArrayPtr result = ContactArrayPtr(new ContactArray());
 
        JSObjectRef jsObject = toJSObjectRef(jsValue);
     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
-        result->push_back(toContactProperties(element));
+        result->push_back(toContact(element));
     }
     return result;
 }
 
+JSValueRef ContactConverter::toJSValueRef(const ContactRefPtr &arg)
+{
+       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactRef::getClassRef(), arg);
+}
+
+ContactRefPtr ContactConverter::toContactRef(const JSValueRef &jsValue)
+{
+       if(!JSContactRef::isObjectOfClass(m_context, jsValue))
+       {
+               LogError("Not a ContactRef object");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
+
+       return JSContactRef::getContactRef(m_context, jsValue);
+}
+
 JSValueRef ContactConverter::toJSValueRef(const ContactNamePtr &arg)
 {
-       // TODO make user object
        return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactName::getClassRef(), arg);
 }
 
 ContactNamePtr ContactConverter::toContactName(const JSValueRef &jsValue)
 {
-       if(JSContactName::isObjectOfClass(m_context, jsValue))
-               return JSContactName::getContactName(m_context, jsValue);
+       if(!JSContactName::isObjectOfClass(m_context, jsValue))
+       {
+               LogError("Not a ContactName object");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
+
+       return JSContactName::getContactName(m_context, jsValue);
+}
 
+ContactNamePtr ContactConverter::toContactNameFromInit(const JSValueRef &jsValue)
+{
+       // from ContactNameInit to ContactName
        Validator validator(m_context);
-       if (!validator.checkArrayKeys(m_allowedContactNameProperties, jsValue)) {
-               LogError("invalid properties in contact object");
+       if (validator.isNullOrUndefined(jsValue)) {
+               LogError("ContactNameInit object is null");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
+
+       if (!JSValueIsObject(m_context, jsValue) || JSIsArrayValue(m_context, jsValue)) {
+               LogError("ContactNameInit object is not object");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
+
+       if (!validator.checkArrayKeys(m_allowedContactNameInit, jsValue)) {
+               LogError("invalid properties in ContactNameInit object");
                ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
        }
 
@@ -703,40 +492,52 @@ ContactNamePtr ContactConverter::toContactName(const JSValueRef &jsValue)
 
        ContactNamePtr result = ContactNamePtr(new ContactName());
        if (!result) {
-               Throw(WrtDeviceApis::Commons::ConversionException);
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Cannot create ContactName object");
        }
 
-       if (!JSValueIsUndefined(m_context, prefixData)) {
+       if (!validator.isNullOrUndefined(prefixData)) {
+               if(!JSValueIsString(m_context, prefixData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "prefix is not string");
                prefix = toString(prefixData);
                result->setPrefix(prefix);
        }
 
-       if (!JSValueIsUndefined(m_context, firstNameData)) {
+       if (!validator.isNullOrUndefined(firstNameData)) {
+               if(!JSValueIsString(m_context, firstNameData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "firstName is not string");
                firstName = toString(firstNameData);
                result->setFirstName(firstName);
        }
 
-       if (!JSValueIsUndefined(m_context, middleNameData)) {
+       if (!validator.isNullOrUndefined(middleNameData)) {
+               if(!JSValueIsString(m_context, middleNameData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "middleName is not string");
                middleName = toString(middleNameData);
                result->setMiddleName(middleName);
        }
 
-       if (!JSValueIsUndefined(m_context, lastNameData)) {
+       if (!validator.isNullOrUndefined(lastNameData)) {
+               if(!JSValueIsString(m_context, lastNameData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "lastName is not string");
                lastName = toString(lastNameData);
                result->setLastName(lastName);
        }
 
-       if (!JSValueIsUndefined(m_context, nicknamesData)) {
+       if (!validator.isNullOrUndefined(nicknamesData)) {
                nicknames = toStringArray(nicknamesData);
                result->setNicknames(nicknames);
        }
 
-       if (!JSValueIsUndefined(m_context, phoneticNameData)) {
+       if (!validator.isNullOrUndefined(phoneticNameData)) {
+               if(!JSValueIsString(m_context, phoneticNameData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "phoneticName is not string");
                phoneticName = toString(phoneticNameData);
                result->setPhoneticName(phoneticName);
        }
 
-       if (!JSValueIsUndefined(m_context, displayNameData)) {
+       if (!validator.isNullOrUndefined(displayNameData)) {
+               if(!JSValueIsString(m_context, displayNameData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "displayName is not string");
                displayName = toString(displayNameData);
                result->setDisplayName(displayName);
        }
@@ -744,101 +545,174 @@ ContactNamePtr ContactConverter::toContactName(const JSValueRef &jsValue)
        return result;
 }
 
-JSValueRef ContactConverter::toJSValueRef(const ContactAccountPtr &arg)
+JSValueRef ContactConverter::toJSValueRef(const ContactOrganizationPtr &arg)
 {
-       //LogDebug("entered");
-       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAccount::getClassRef(), arg);
+       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactOrganization::getClassRef(), arg);
 }
 
-ContactAccountPtr ContactConverter::toContactAccount(const JSValueRef &jsValue)
+ContactOrganizationPtr ContactConverter::toContactOrganization(const JSValueRef &jsValue)
 {
-       if(JSContactAccount::isObjectOfClass(m_context, jsValue))
-               return JSContactAccount::getContactAccount(m_context, jsValue);
+       if(!JSContactOrganization::isObjectOfClass(m_context, jsValue))
+       {
+               LogError("Not a ContactOrganization object");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
 
+       return JSContactOrganization::getContactOrganization(m_context, jsValue);
+}
+
+ContactOrganizationPtr ContactConverter::toContactOrganizationFromInit(const JSValueRef &jsValue)
+{
+       // from ContactOrganizationInit to ContactOrganization
        Validator validator(m_context);
-       if (!validator.checkArrayKeys(m_allowedContactAccountProperties, jsValue)) {
-               LogError("invalid properties in contact object");
+       if (validator.isNullOrUndefined(jsValue)) {
+               LogError("ContactOrganizationInit object is null");
                ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
        }
 
-       const ScopedJSStringRef accountIdStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_ACCOUNT_ID));
-       const ScopedJSStringRef contactURIStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_CONTACT_URI));
-
+       if (!JSValueIsObject(m_context, jsValue) || JSIsArrayValue(m_context, jsValue)) {
+               LogError("ContactOrganizationInit object is not object");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
+
+       if (!validator.checkArrayKeys(m_allowedContactOrganizationInit, jsValue)) {
+               LogError("invalid properties in ContactOrganizationInit object");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
+
+       const ScopedJSStringRef nameStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_NAME));
+       const ScopedJSStringRef departmentStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_DEPARTMENT));
+       const ScopedJSStringRef titleStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_TITLE));
+       const ScopedJSStringRef roleStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_ROLE));
+
        JSObjectRef jsObject = toJSObjectRef(jsValue);
 
-       JSValueRef accountIdData = JSObjectGetProperty(m_context, jsObject, accountIdStr.get(), NULL);
-       JSValueRef contactURIData = JSObjectGetProperty(m_context, jsObject, contactURIStr.get(), NULL);
+       JSValueRef nameData = JSObjectGetProperty(m_context, jsObject, nameStr.get(), NULL);
+       JSValueRef departmentData = JSObjectGetProperty(m_context, jsObject, departmentStr.get(), NULL);
+       JSValueRef titleData = JSObjectGetProperty(m_context, jsObject, titleStr.get(), NULL);
+       JSValueRef roleData = JSObjectGetProperty(m_context, jsObject, roleStr.get(), NULL);
 
-       std::string accountId;
-       std::string contactURI;
+       std::string name;
+       std::string department;
+       std::string title;
+       std::string role;
 
-       ContactAccountPtr result(new ContactAccount());
+       ContactOrganizationPtr result(new ContactOrganization());
        if (!result) {
-               Throw(WrtDeviceApis::Commons::ConversionException);
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Cannot create ContactOrganization object");
        }
 
-       if (!JSValueIsUndefined(m_context, accountIdData)) {
-               accountId = toString(accountIdData);
-               result->setAccountId(accountId);
+       if (!validator.isNullOrUndefined(nameData)) {
+               if(!JSValueIsString(m_context, nameData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "name is not string");
+               name = toString(nameData);
+               result->setName(name);
        }
 
-       if (!JSValueIsUndefined(m_context, contactURIData)) {
-               contactURI = toString(contactURIData);
-               result->setContactURI(contactURI);
+       if (!validator.isNullOrUndefined(departmentData)) {
+               if(!JSValueIsString(m_context, departmentData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "department is not string");
+               department = toString(departmentData);
+               result->setDepartment(department);
+       }
+
+       if (!validator.isNullOrUndefined(titleData)) {
+               if(!JSValueIsString(m_context, titleData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "title is not string");
+               title = toString(titleData);
+               result->setTitle(title);
+       }
+
+       if (!validator.isNullOrUndefined(roleData)) {
+               if(!JSValueIsString(m_context, roleData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "role is not string");
+               role = toString(roleData);
+               result->setRole(role);
        }
 
        return result;
 }
 
-JSValueRef ContactConverter::toJSValueRef(const ContactAnniversaryPtr &arg)
+JSValueRef ContactConverter::toJSValueRef(const ContactOrganizationArrayPtr &arg)
 {
-       //LogDebug("entered");
-       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAnniversary::getClassRef(), arg);
+       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactOrganizationArray::getClassRef(), arg);
 }
 
-ContactAnniversaryPtr ContactConverter::toContactAnniversary(const JSValueRef &jsValue)
+ContactOrganizationArrayPtr ContactConverter::toContactOrganizationArray(const JSValueRef &jsValue)
 {
-       if(JSContactAnniversary::isObjectOfClass(m_context, jsValue))
-               return JSContactAnniversary::getContactAnniversary(m_context, jsValue);
+       if(JSContactOrganizationArray::isObjectOfClass(m_context, jsValue))
+               return JSContactOrganizationArray::getContactOrganizationArray(m_context, jsValue);
 
-       Validator validator(m_context);
-       if (!validator.checkArrayKeys(m_allowedContactAnniversaryProperties, jsValue)) {
-               LogError("invalid properties in contact object");
+       ContactOrganizationArrayPtr result(new ContactOrganizationArray());
+
+       if(!JSIsArrayValue(m_context, jsValue))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactOrganizationArray is not array.");
+
+       JSObjectRef jsObject = toJSObjectRef(jsValue);
+    for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
+        JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
+        result->push_back(toContactOrganization(element));
+    }
+    return result;
+}
+
+JSValueRef ContactConverter::toJSValueRef(const ContactWebSitePtr &arg)
+{
+       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactWebSite::getClassRef(), arg);
+}
+
+ContactWebSitePtr ContactConverter::toContactWebSite(const JSValueRef &jsValue)
+{
+       if(!JSContactWebSite::isObjectOfClass(m_context, jsValue))
+       {
+               LogError("Not a ContactWebSite object");
                ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
        }
 
-       const ScopedJSStringRef dateStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_DATE));
-       const ScopedJSStringRef labelStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_LABEL));
+       return JSContactWebSite::getContactWebSite(m_context, jsValue);
+}
 
-       JSObjectRef jsObject = toJSObjectRef(jsValue);
+JSValueRef ContactConverter::toJSValueRef(const ContactWebSiteArrayPtr &arg)
+{
+       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactWebSiteArray::getClassRef(), arg);
+}
 
-       JSValueRef dateData = JSObjectGetProperty(m_context, jsObject, dateStr.get(), NULL);
-       JSValueRef labelData = JSObjectGetProperty(m_context, jsObject, labelStr.get(), NULL);
+ContactWebSiteArrayPtr ContactConverter::toContactWebSiteArray(const JSValueRef &jsValue)
+{
+       if(JSContactWebSiteArray::isObjectOfClass(m_context, jsValue))
+               return JSContactWebSiteArray::getContactWebSiteArray(m_context, jsValue);
 
-       std::tm date;
-       std::string label;
+       if(!JSIsArrayValue(m_context, jsValue))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactWebSiteArray is not array.");
 
-       ContactAnniversaryPtr result(new ContactAnniversary());
-       if (!result) {
-               Throw(WrtDeviceApis::Commons::ConversionException);
-       }
+       ContactWebSiteArrayPtr result(new ContactWebSiteArray());
 
-       if (!JSValueIsUndefined(m_context, dateData)) {
-               date = toDateTm(dateData);
-               result->setDate(date);
-       }
+       JSObjectRef jsObject = toJSObjectRef(jsValue);
+    for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
+        JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
+        result->push_back(toContactWebSite(element));
+    }
+    return result;
+}
+
+JSValueRef ContactConverter::toJSValueRef(const ContactAnniversaryPtr &arg)
+{
+       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAnniversary::getClassRef(), arg);
+}
 
-       if (!JSValueIsUndefined(m_context, labelData)) {
-               label = toString(labelData);
-               result->setLabel(label);
+ContactAnniversaryPtr ContactConverter::toContactAnniversary(const JSValueRef &jsValue)
+{
+       if(!JSContactAnniversary::isObjectOfClass(m_context, jsValue))
+       {
+               LogError("Not a ContactAnniversary object");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
        }
 
-       return result;
+       return JSContactAnniversary::getContactAnniversary(m_context, jsValue);
 }
 
 JSValueRef ContactConverter::toJSValueRef(const ContactAnniversaryArrayPtr &arg)
 {
-       //LogDebug("entered");
        return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAnniversaryArray::getClassRef(), arg);
 }
 
@@ -847,6 +721,9 @@ ContactAnniversaryArrayPtr ContactConverter::toContactAnniversaryArray(const JSV
        if(JSContactAnniversaryArray::isObjectOfClass(m_context, jsValue))
                return JSContactAnniversaryArray::getContactAnniversaryArray(m_context, jsValue);
 
+       if(!JSIsArrayValue(m_context, jsValue))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactAnniversaryArray is not array.");
+
        ContactAnniversaryArrayPtr result(new ContactAnniversaryArray());
 
        JSObjectRef jsObject = toJSObjectRef(jsValue);
@@ -857,41 +734,54 @@ ContactAnniversaryArrayPtr ContactConverter::toContactAnniversaryArray(const JSV
     return result;
 }
 
-JSValueRef ContactConverter::toJSValueRefAttributesOfInterestArray(const AttributesOfInterestArrayPtr &arg)
+JSValueRef ContactConverter::toJSValueRef(const ContactAccountPtr &arg)
 {
-       //LogDebug("entered");
-       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSAttributesOfInterestArray::getClassRef(), arg);
+       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAccount::getClassRef(), arg);
 }
 
-AttributesOfInterestArrayPtr ContactConverter::toAttributesOfInterestArray(const JSValueRef &jsValue)
+ContactAccountPtr ContactConverter::toContactAccount(const JSValueRef &jsValue)
 {
-       if(JSAttributesOfInterestArray::isObjectOfClass(m_context, jsValue))
-               return JSAttributesOfInterestArray::getAttributesOfInterestArray(m_context, jsValue);
-
-       AttributesOfInterestArrayPtr result(new AttributesOfInterestArray());
+       if(!JSContactAccount::isObjectOfClass(m_context, jsValue))
+       {
+               LogError("Not a ContactAccount object");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
 
-       JSObjectRef jsObject = toJSObjectRef(jsValue);
-    for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
-        JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
-        result->push_back(toAttributesOfInterest(element));
-    }
-    return result;
+       return JSContactAccount::getContactAccount(m_context, jsValue);
 }
 
 JSValueRef ContactConverter::toJSValueRef(const ContactAddressPtr &arg)
 {
-       //LogDebug("entered");
        return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAddress::getClassRef(), arg);
 }
 
 ContactAddressPtr ContactConverter::toContactAddress(const JSValueRef &jsValue)
 {
-       if(JSContactAddress::isObjectOfClass(m_context, jsValue))
-               return JSContactAddress::getContactAddress(m_context, jsValue);
+       if(!JSContactAddress::isObjectOfClass(m_context, jsValue))
+       {
+               LogError("Not a ContactAddress object");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
+
+       return JSContactAddress::getContactAddress(m_context, jsValue);
+}
 
+ContactAddressPtr ContactConverter::toContactAddressFromInit(const JSValueRef &jsValue)
+{
+       // from ContactAddressInit to ContactAddress
        Validator validator(m_context);
-       if (!validator.checkArrayKeys(m_allowedContactAddressProperties, jsValue)) {
-               LogError("invalid properties in contact object");
+       if (validator.isNullOrUndefined(jsValue)) {
+               LogError("ContactAddressInit object is null");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
+
+       if (!JSValueIsObject(m_context, jsValue) || JSIsArrayValue(m_context, jsValue)) {
+               LogError("ContactAddressInit object is not object");
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       }
+
+       if (!validator.checkArrayKeys(m_allowedContactAddressInit, jsValue)) {
+               LogError("invalid properties in ContactAddressInit object");
                ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
        }
 
@@ -923,40 +813,52 @@ ContactAddressPtr ContactConverter::toContactAddress(const JSValueRef &jsValue)
 
        ContactAddressPtr result(new ContactAddress());
        if (!result) {
-               Throw(WrtDeviceApis::Commons::ConversionException);
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Cannot make ContactAddress");
        }
 
-       if (!JSValueIsUndefined(m_context, countryData)) {
+       if (!validator.isNullOrUndefined(countryData)) {
+               if(!JSValueIsString(m_context, countryData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "country is not string");
                country = toString(countryData);
                result->setCountry(country);
        }
 
-       if (!JSValueIsUndefined(m_context, regionData)) {
+       if (!validator.isNullOrUndefined(regionData)) {
+               if(!JSValueIsString(m_context, regionData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "region is not string");
                region = toString(regionData);
                result->setRegion(region);
        }
 
-       if (!JSValueIsUndefined(m_context, cityData)) {
+       if (!validator.isNullOrUndefined(cityData)) {
+               if(!JSValueIsString(m_context, cityData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "city is not string");
                city = toString(cityData);
                result->setCity(city);
        }
 
-       if (!JSValueIsUndefined(m_context, streetAddressData)) {
+       if (!validator.isNullOrUndefined(streetAddressData)) {
+               if(!JSValueIsString(m_context, streetAddressData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "streetAddress is not string");
                streetAddress = toString(streetAddressData);
                result->setStreetAddress(streetAddress);
        }
 
-       if (!JSValueIsUndefined(m_context, additionalInformationData)) {
+       if (!validator.isNullOrUndefined(additionalInformationData)) {
+               if(!JSValueIsString(m_context, additionalInformationData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "additionalInformation is not string");
                additionalInformation = toString(additionalInformationData);
                result->setAdditionalInformation(additionalInformation);
        }
 
-       if (!JSValueIsUndefined(m_context, postalCodeData)) {
+       if (!validator.isNullOrUndefined(postalCodeData)) {
+               if(!JSValueIsString(m_context, postalCodeData))
+                       ThrowMsg(WrtDeviceApis::Commons::ConversionException, "postalCode is not string");
                postalCode = toString(postalCodeData);
                result->setPostalCode(postalCode);
        }
 
-       if (!JSValueIsUndefined(m_context, typesData)) {
+       if (!validator.isNullOrUndefined(typesData)) {
                types = toContactAddressTypeArray(typesData);
                result->setTypes(types);
        }
@@ -966,7 +868,6 @@ ContactAddressPtr ContactConverter::toContactAddress(const JSValueRef &jsValue)
 
 JSValueRef ContactConverter::toJSValueRef(const ContactAddressArrayPtr &arg)
 {
-       //LogDebug("entered");
        return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAddressArray::getClassRef(), arg);
 }
 
@@ -975,6 +876,9 @@ ContactAddressArrayPtr ContactConverter::toContactAddressArray(const JSValueRef
        if(JSContactAddressArray::isObjectOfClass(m_context, jsValue))
                return JSContactAddressArray::getContactAddressArray(m_context, jsValue);
 
+       if(!JSIsArrayValue(m_context, jsValue))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactAddressArray is not array.");
+
        ContactAddressArrayPtr result(new ContactAddressArray());
 
        JSObjectRef jsObject = toJSObjectRef(jsValue);
@@ -985,99 +889,24 @@ ContactAddressArrayPtr ContactConverter::toContactAddressArray(const JSValueRef
     return result;
 }
 
-JSValueRef ContactConverter::toJSValueRef(const ContactAddressTypeArrayPtr &arg)
-{
-       //LogDebug("entered");
-       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAddressTypeArray::getClassRef(), arg);
-}
-
-ContactAddressTypeArrayPtr ContactConverter::toContactAddressTypeArray(const JSValueRef &jsValue)
-{
-       if(JSContactAddressTypeArray::isObjectOfClass(m_context, jsValue))
-               return JSContactAddressTypeArray::getContactAddressTypeArray(m_context, jsValue);
-
-       ContactAddressTypeArrayPtr result(new ContactAddressTypeArray());
-
-       JSObjectRef jsObject = toJSObjectRef(jsValue);
-    for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
-        JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
-        result->push_back(toContactAddressType(element));
-    }
-    return result;
-}
-
-//JSValueRef ContactConverter::toJSValueRef(const ContactCapabilityTypeArrayPtr &arg)
-//{
-//     //LogDebug("entered");
-//     return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactCapabilityTypeArray::getClassRef(), arg);
-//}
-//
-//ContactCapabilityTypeArrayPtr ContactConverter::toContactCapabilityTypeArray(const JSValueRef &jsValue)
-//{
-//     if(JSContactCapabilityTypeArray::isObjectOfClass(m_context, jsValue))
-//             return JSContactCapabilityTypeArray::getContactCapabilityTypeArray(m_context, jsValue);
-//
-//     ContactCapabilityTypeArrayPtr result(new ContactCapabilityTypeArray());
-//
-//     JSObjectRef jsObject = toJSObjectRef(jsValue);
-//    for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
-//        JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
-//        result->push_back(toContactCapabilityType(element));
-//    }
-//    return result;
-//}
-
 JSValueRef ContactConverter::toJSValueRef(const ContactPhoneNumberPtr &arg)
 {
-       //LogDebug("entered");
        return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactPhoneNumber::getClassRef(), arg);
 }
 
 ContactPhoneNumberPtr ContactConverter::toContactPhoneNumber(const JSValueRef &jsValue)
 {
-       if(JSContactPhoneNumber::isObjectOfClass(m_context, jsValue))
-               return JSContactPhoneNumber::getContactPhoneNumber(m_context, jsValue);
-
-       Validator validator(m_context);
-       if (!validator.checkArrayKeys(m_allowedContactPhoneNumberProperties, jsValue)) {
-               LogError("invalid properties in contact object");
+       if(!JSContactPhoneNumber::isObjectOfClass(m_context, jsValue))
+       {
+               LogError("Not a ContactPhoneNumber object");
                ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
        }
 
-       const ScopedJSStringRef numberStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_NUMBER));
-       const ScopedJSStringRef typesStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_TYPES));
-
-       JSObjectRef jsObject = toJSObjectRef(jsValue);
-
-       JSValueRef numberData = JSObjectGetProperty(m_context, jsObject, numberStr.get(), NULL);
-       JSValueRef typesData = JSObjectGetProperty(m_context, jsObject, typesStr.get(), NULL);
-
-       std::string number;
-       StringArrayPtr types;
-
-       ContactPhoneNumberPtr result(new ContactPhoneNumber());
-       if (!result) {
-               Throw(WrtDeviceApis::Commons::ConversionException);
-       }
-
-       if (!JSValueIsUndefined(m_context, numberData)) {
-               number = toString(numberData);
-               result->setNumber(number);
-       }
-
-       if (!JSValueIsUndefined(m_context, typesData)) {
-               types = toStringArray(typesData);
-               result->setTypes(types);
-       } else {
-               result->addType("VOICE");
-       }
-
-       return result;
+       return JSContactPhoneNumber::getContactPhoneNumber(m_context, jsValue);
 }
 
 JSValueRef ContactConverter::toJSValueRef(const ContactPhoneNumberArrayPtr &arg)
 {
-       //LogDebug("entered");
        return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactPhoneNumberArray::getClassRef(), arg);
 }
 
@@ -1086,6 +915,9 @@ ContactPhoneNumberArrayPtr ContactConverter::toContactPhoneNumberArray(const JSV
        if(JSContactPhoneNumberArray::isObjectOfClass(m_context, jsValue))
                return JSContactPhoneNumberArray::getContactPhoneNumberArray(m_context, jsValue);
 
+       if(!JSIsArrayValue(m_context, jsValue))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactPhoneNumberArray is not array.");
+
        ContactPhoneNumberArrayPtr result(new ContactPhoneNumberArray());
 
        JSObjectRef jsObject = toJSObjectRef(jsValue);
@@ -1096,79 +928,24 @@ ContactPhoneNumberArrayPtr ContactConverter::toContactPhoneNumberArray(const JSV
     return result;
 }
 
-JSValueRef ContactConverter::toJSValueRef(const ContactPhoneNumberTypeArrayPtr &arg)
-{
-       //LogDebug("entered");
-       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactPhoneNumberTypeArray::getClassRef(), arg);
-}
-
-ContactPhoneNumberTypeArrayPtr ContactConverter::toContactPhoneNumberTypeArray(const JSValueRef &jsValue)
-{
-       if(JSContactPhoneNumberTypeArray::isObjectOfClass(m_context, jsValue))
-               return JSContactPhoneNumberTypeArray::getContactPhoneNumberTypeArray(m_context, jsValue);
-
-       ContactPhoneNumberTypeArrayPtr result(new ContactPhoneNumberTypeArray());
-
-       JSObjectRef jsObject = toJSObjectRef(jsValue);
-    for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
-        JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
-        result->push_back(toContactPhoneNumberType(element));
-    }
-    return result;
-}
-
 JSValueRef ContactConverter::toJSValueRef(const ContactEmailAddressPtr &arg)
 {
-       //LogDebug("entered");
        return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactEmailAddress::getClassRef(), arg);
 }
 
 ContactEmailAddressPtr ContactConverter::toContactEmailAddress(const JSValueRef &jsValue)
 {
-       if(JSContactEmailAddress::isObjectOfClass(m_context, jsValue))
-               return JSContactEmailAddress::getContactEmailAddress(m_context, jsValue);
-
-       Validator validator(m_context);
-       if (!validator.checkArrayKeys(m_allowedContactEmailAddressProperties, jsValue)) {
-               LogError("invalid properties in contact object");
+       if(!JSContactEmailAddress::isObjectOfClass(m_context, jsValue))
+       {
+               LogError("Not a ContactEmailAddress object");
                ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
        }
 
-       const ScopedJSStringRef emailStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_EMAIL));
-       const ScopedJSStringRef typesStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_TYPES));
-
-       JSObjectRef jsObject = toJSObjectRef(jsValue);
-
-
-       JSValueRef emailData = JSObjectGetProperty(m_context, jsObject, emailStr.get(), NULL);
-       JSValueRef typesData = JSObjectGetProperty(m_context, jsObject, typesStr.get(), NULL);
-
-
-       std::string email;
-       ContactEmailAddressTypeArrayPtr types;
-
-       ContactEmailAddressPtr result(new ContactEmailAddress());
-       if (!result) {
-               Throw(WrtDeviceApis::Commons::ConversionException);
-       }
-
-       if (!JSValueIsUndefined(m_context, emailData)) {
-               email = toString(emailData);
-               result->setEmail(email);
-       }
-
-       if (!JSValueIsUndefined(m_context, typesData)) {
-               types = toContactEmailAddressTypeArray(typesData);
-               result->setTypes(types);
-       } else {
-               result->addType(CONTACT_EMAIL_TYPE_PREF);
-       }
-       return result;
+       return JSContactEmailAddress::getContactEmailAddress(m_context, jsValue);
 }
 
 JSValueRef ContactConverter::toJSValueRef(const ContactEmailAddressArrayPtr &arg)
 {
-       //LogDebug("entered");
        return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactEmailAddressArray::getClassRef(), arg);
 }
 
@@ -1177,6 +954,9 @@ ContactEmailAddressArrayPtr ContactConverter::toContactEmailAddressArray(const J
        if(JSContactEmailAddressArray::isObjectOfClass(m_context, jsValue))
                return JSContactEmailAddressArray::getContactEmailAddressArray(m_context, jsValue);
 
+       if(!JSIsArrayValue(m_context, jsValue))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactEmailAddressArray is not array.");
+
        ContactEmailAddressArrayPtr result(new ContactEmailAddressArray());
 
        JSObjectRef jsObject = toJSObjectRef(jsValue);
@@ -1187,251 +967,380 @@ ContactEmailAddressArrayPtr ContactConverter::toContactEmailAddressArray(const J
     return result;
 }
 
-JSValueRef ContactConverter::toJSValueRef(const ContactEmailAddressTypeArrayPtr &arg)
+ContactWebSiteType ContactConverter::toContactWebSiteType(const std::string &arg)
 {
-       //LogDebug("entered");
-       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactEmailAddressTypeArray::getClassRef(), arg);
+       std::string argUpper;
+       std::transform(arg.begin(), arg.end(), std::back_inserter(argUpper), ::toupper);
+
+       if (argUpper == STR_WEBSITE_TYPE_HOMEPAGE) {
+               return WEBSITE_TYPE_HOMEPAGE;
+       } else if (argUpper == STR_WEBSITE_TYPE_BLOG) {
+               return WEBSITE_TYPE_BLOG;
+       } else {
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactWebSiteType : " << arg);
+       }
+       return WEBSITE_TYPE_HOMEPAGE;
 }
 
-ContactEmailAddressTypeArrayPtr ContactConverter::toContactEmailAddressTypeArray(const JSValueRef &jsValue)
+std::string ContactConverter::toContactWebSiteTypeStr(ContactWebSiteType arg)
 {
-       if(JSContactEmailAddressTypeArray::isObjectOfClass(m_context, jsValue))
-               return JSContactEmailAddressTypeArray::getContactEmailAddressTypeArray(m_context, jsValue);
+       if (arg == WEBSITE_TYPE_HOMEPAGE) {
+               return STR_WEBSITE_TYPE_HOMEPAGE;
+       } else if (arg == WEBSITE_TYPE_BLOG) {
+               return STR_WEBSITE_TYPE_BLOG;
+       } else {
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactWebSiteType : " << arg);
+       }
+       return STR_WEBSITE_TYPE_HOMEPAGE;
+}
 
-       ContactEmailAddressTypeArrayPtr result(new ContactEmailAddressTypeArray());
+ContactWebSiteType ContactConverter::toContactWebSiteType(const JSValueRef &value)
+{
+       if(!JSValueIsString(m_context, value))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactWebSiteType is not string.");
 
-       JSObjectRef jsObject = toJSObjectRef(jsValue);
-    for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
-        JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
-        result->push_back(toContactEmailAddressType(element));
-    }
-    return result;
+       return toContactWebSiteType(toString(value));
 }
 
-JSValueRef ContactConverter::toJSValueRef(const ContactOrganizationPtr &arg)
+JSValueRef ContactConverter::toJSValueRef(ContactWebSiteType arg)
 {
-       //LogDebug("entered");
-       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactOrganization::getClassRef(), arg);
+       return toJSValueRef(toContactWebSiteTypeStr(arg));
 }
 
-ContactOrganizationPtr ContactConverter::toContactOrganization(const JSValueRef &jsValue)
+ContactAddressType ContactConverter::toContactAddressType(const std::string &arg)
 {
-       if(JSContactOrganization::isObjectOfClass(m_context, jsValue))
-               return JSContactOrganization::getContactOrganization(m_context, jsValue);
+       std::string argUpper;
+       std::transform(arg.begin(), arg.end(), std::back_inserter(argUpper), ::toupper);
 
-       Validator validator(m_context);
-       if (!validator.checkArrayKeys(m_allowedContactOrganizationProperties, jsValue)) {
-               LogError("invalid properties in contact object");
-               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       if (argUpper == STR_CONTACT_ADDRESS_TYPE_WORK) {
+               return CONTACT_ADDRESS_TYPE_WORK;
+       } else if (argUpper == STR_CONTACT_ADDRESS_TYPE_PREF) {
+               return CONTACT_ADDRESS_TYPE_PREF;
+       } else if (argUpper == STR_CONTACT_ADDRESS_TYPE_HOME) {
+               return CONTACT_ADDRESS_TYPE_HOME;
+       } else {
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactAddressType : " << arg);
        }
+       return CONTACT_ADDRESS_TYPE_PREF;
+}
+std::string ContactConverter::toContactAddressTypeStr(ContactAddressType arg)
+{
+       if (arg == CONTACT_ADDRESS_TYPE_WORK) {
+               return STR_CONTACT_ADDRESS_TYPE_WORK;
+       } else if (arg == CONTACT_ADDRESS_TYPE_PREF) {
+               return STR_CONTACT_ADDRESS_TYPE_PREF;
+       } else if (arg == CONTACT_ADDRESS_TYPE_HOME) {
+               return STR_CONTACT_ADDRESS_TYPE_HOME;
+       } else {
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactAddressType : " << arg);
+       }
+       return STR_CONTACT_ADDRESS_TYPE_PREF;
+}
 
-       const ScopedJSStringRef nameStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_NAME));
-       const ScopedJSStringRef departmentStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_DEPARTMENT));
-       const ScopedJSStringRef titleStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_TITLE));
-       const ScopedJSStringRef roleStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_ROLE));
+ContactAddressType ContactConverter::toContactAddressType(const JSValueRef &value)
+{
+       if(!JSValueIsString(m_context, value))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactAddressType is not string.");
 
-       JSObjectRef jsObject = toJSObjectRef(jsValue);
+       return toContactAddressType(toString(value));
+}
 
-       JSValueRef nameData = JSObjectGetProperty(m_context, jsObject, nameStr.get(), NULL);
-       JSValueRef departmentData = JSObjectGetProperty(m_context, jsObject, departmentStr.get(), NULL);
-       JSValueRef titleData = JSObjectGetProperty(m_context, jsObject, titleStr.get(), NULL);
-       JSValueRef roleData = JSObjectGetProperty(m_context, jsObject, roleStr.get(), NULL);
+JSValueRef ContactConverter::toJSValueRef(ContactAddressType arg)
+{
+       return toJSValueRef(toContactAddressTypeStr(arg));
+}
 
-       std::string name;
-       std::string department;
-       std::string title;
-       std::string role;
+JSValueRef ContactConverter::toJSValueRef(const ContactAddressTypeArrayPtr &arg)
+{
+       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactAddressTypeArray::getClassRef(), arg);
+}
 
-       ContactOrganizationPtr result(new ContactOrganization());
-       if (!result) {
-               Throw(WrtDeviceApis::Commons::ConversionException);
-       }
+ContactAddressTypeArrayPtr ContactConverter::toContactAddressTypeArray(const JSValueRef &jsValue)
+{
+       if(JSContactAddressTypeArray::isObjectOfClass(m_context, jsValue))
+               return JSContactAddressTypeArray::getContactAddressTypeArray(m_context, jsValue);
 
-       if (!JSValueIsUndefined(m_context, nameData)) {
-               name = toString(nameData);
-               result->setName(name);
-       }
+       if(!JSIsArrayValue(m_context, jsValue))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactAddressTypeArray is not array.");
 
-       if (!JSValueIsUndefined(m_context, departmentData)) {
-               department = toString(departmentData);
-               result->setDepartment(department);
-       }
+       ContactAddressTypeArrayPtr result(new ContactAddressTypeArray());
 
-       if (!JSValueIsUndefined(m_context, titleData)) {
-               title = toString(titleData);
-               result->setTitle(title);
+       JSObjectRef jsObject = toJSObjectRef(jsValue);
+    for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
+        JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
+        result->push_back(toContactAddressType(element));
+    }
+    return result;
+}
+
+ContactPhoneNumberType ContactConverter::toContactPhoneNumberType(const std::string &arg)
+{
+       std::string argUpper;
+       std::transform(arg.begin(), arg.end(), std::back_inserter(argUpper), ::toupper);
+
+       if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_WORK) {
+               return CONTACT_PHONE_NUMBER_TYPE_WORK;
+       } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_PREF) {
+               return CONTACT_PHONE_NUMBER_TYPE_PREF;
+       } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_HOME) {
+               return CONTACT_PHONE_NUMBER_TYPE_HOME;
+       } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_VOICE) {
+               return CONTACT_PHONE_NUMBER_TYPE_VOICE;
+       } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_FAX) {
+               return CONTACT_PHONE_NUMBER_TYPE_FAX;
+       } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_MSG) {
+               return CONTACT_PHONE_NUMBER_TYPE_MSG;
+       } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_CELL) {
+               return CONTACT_PHONE_NUMBER_TYPE_CELL;
+       } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_PAGER) {
+               return CONTACT_PHONE_NUMBER_TYPE_PAGER;
+       } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_BBS) {
+               return CONTACT_PHONE_NUMBER_TYPE_BBS;
+       } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_MODEM) {
+               return CONTACT_PHONE_NUMBER_TYPE_MODEM;
+       } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_CAR) {
+               return CONTACT_PHONE_NUMBER_TYPE_CAR;
+       } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_ISDN) {
+               return CONTACT_PHONE_NUMBER_TYPE_ISDN;
+       } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_VIDEO) {
+               return CONTACT_PHONE_NUMBER_TYPE_VIDEO;
+       } else if (argUpper == STR_CONTACT_PHONE_NUMBER_TYPE_PCS) {
+               return CONTACT_PHONE_NUMBER_TYPE_PCS;
+       } else {
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactPhoneNumverType : " << arg);
        }
+       return CONTACT_PHONE_NUMBER_TYPE_WORK;
+}
 
-       if (!JSValueIsUndefined(m_context, roleData)) {
-               role = toString(roleData);
-               result->setRole(role);
+std::string ContactConverter::toContactPhoneNumberTypeStr(ContactPhoneNumberType arg)
+{
+       if (arg == CONTACT_PHONE_NUMBER_TYPE_WORK) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_WORK;
+       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_PREF) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_PREF;
+       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_HOME) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_HOME;
+       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_VOICE) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_VOICE;
+       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_FAX) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_FAX;
+       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_MSG) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_MSG;
+       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_CELL) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_CELL;
+       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_PAGER) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_PAGER;
+       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_BBS) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_BBS;
+       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_MODEM) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_MODEM;
+       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_CAR) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_CAR;
+       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_ISDN) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_ISDN;
+       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_VIDEO) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_VIDEO;
+       } else if (arg == CONTACT_PHONE_NUMBER_TYPE_PCS) {
+               return STR_CONTACT_PHONE_NUMBER_TYPE_PCS;
+       } else {
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactPhoneNumverType : " << arg);
        }
+       return STR_CONTACT_PHONE_NUMBER_TYPE_WORK;
+}
 
-       return result;
+ContactPhoneNumberType ContactConverter::toContactPhoneNumberType(const JSValueRef &value)
+{
+       if(!JSValueIsString(m_context, value))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactPhoneNumberType is not string.");
+
+       return toContactPhoneNumberType(toString(value));
 }
 
-JSValueRef ContactConverter::toJSValueRef(const ContactOrganizationArrayPtr &arg)
+JSValueRef ContactConverter::toJSValueRef(ContactPhoneNumberType arg)
 {
-       //LogDebug("entered");
-       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactOrganizationArray::getClassRef(), arg);
+       return toJSValueRef(toContactPhoneNumberTypeStr(arg));
 }
 
-ContactOrganizationArrayPtr ContactConverter::toContactOrganizationArray(const JSValueRef &jsValue)
+JSValueRef ContactConverter::toJSValueRef(const ContactPhoneNumberTypeArrayPtr &arg)
 {
-       if(JSContactOrganizationArray::isObjectOfClass(m_context, jsValue))
-               return JSContactOrganizationArray::getContactOrganizationArray(m_context, jsValue);
+       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactPhoneNumberTypeArray::getClassRef(), arg);
+}
 
-       ContactOrganizationArrayPtr result(new ContactOrganizationArray());
+ContactPhoneNumberTypeArrayPtr ContactConverter::toContactPhoneNumberTypeArray(const JSValueRef &jsValue)
+{
+       if(JSContactPhoneNumberTypeArray::isObjectOfClass(m_context, jsValue))
+               return JSContactPhoneNumberTypeArray::getContactPhoneNumberTypeArray(m_context, jsValue);
+
+       if(!JSIsArrayValue(m_context, jsValue))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactEmailAddressTypeArray is not array.");
+
+       ContactPhoneNumberTypeArrayPtr result(new ContactPhoneNumberTypeArray());
 
        JSObjectRef jsObject = toJSObjectRef(jsValue);
     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
-        result->push_back(toContactOrganization(element));
+        result->push_back(toContactPhoneNumberType(element));
     }
     return result;
 }
 
-JSValueRef ContactConverter::toJSValueRef(const ContactWebSitePtr &arg)
+ContactEmailAddressType ContactConverter::toContactEmailAddressType(const std::string &arg)
 {
-       //LogDebug("entered");
-       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactWebSite::getClassRef(), arg);
+       std::string argUpper;
+       std::transform(arg.begin(), arg.end(), std::back_inserter(argUpper), ::toupper);
+
+       if (argUpper == STR_CONTACT_EMAIL_TYPE_WORK) {
+               return CONTACT_EMAIL_TYPE_WORK;
+       } else if (argUpper == STR_CONTACT_EMAIL_TYPE_PREF) {
+               return CONTACT_EMAIL_TYPE_PREF;
+       } else if (argUpper == STR_CONTACT_EMAIL_TYPE_HOME) {
+               return CONTACT_EMAIL_TYPE_HOME;
+       } else {
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactEmailAddressType : " << arg);
+       }
+       return CONTACT_EMAIL_TYPE_PREF;
 }
 
-ContactWebSitePtr ContactConverter::toContactWebSite(const JSValueRef &jsValue)
+std::string ContactConverter::toContactEmailAddressTypeStr(ContactEmailAddressType arg)
 {
-       if(JSContactWebSite::isObjectOfClass(m_context, jsValue))
-               return JSContactWebSite::getContactWebSite(m_context, jsValue);
-
-       Validator validator(m_context);
-       if (!validator.checkArrayKeys(m_allowedContactWebSiteProperties, jsValue)) {
-               LogError("invalid properties in contact object");
-               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
+       if (arg == CONTACT_EMAIL_TYPE_WORK) {
+               return STR_CONTACT_EMAIL_TYPE_WORK;
+       } else if (arg == CONTACT_EMAIL_TYPE_PREF) {
+               return STR_CONTACT_EMAIL_TYPE_PREF;
+       } else if (arg == CONTACT_EMAIL_TYPE_HOME) {
+               return STR_CONTACT_EMAIL_TYPE_HOME;
+       } else {
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Invalid ContactEmailAddressType : " << arg);
        }
+       return STR_CONTACT_EMAIL_TYPE_PREF;
+}
 
-       const ScopedJSStringRef urlStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_URL));
-       const ScopedJSStringRef typeStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_TYPE));
-
-       JSObjectRef jsObject = toJSObjectRef(jsValue);
+ContactEmailAddressType ContactConverter::toContactEmailAddressType(const JSValueRef &value)
+{
+       if(!JSValueIsString(m_context, value))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactEmailAddressType is not string.");
 
-       JSValueRef urlData = JSObjectGetProperty(m_context, jsObject, urlStr.get(), NULL);
-       JSValueRef typeData = JSObjectGetProperty(m_context, jsObject, typeStr.get(), NULL);
+       return toContactEmailAddressType(toString(value));
+}
 
-       std::string url;
-       ContactWebSiteType type;
+JSValueRef ContactConverter::toJSValueRef(ContactEmailAddressType arg)
+{
+       return toJSValueRef(toContactEmailAddressTypeStr(arg));
+}
 
-       ContactWebSitePtr result(new ContactWebSite());
-       if (!result) {
-               Throw(WrtDeviceApis::Commons::ConversionException);
-       }
+JSValueRef ContactConverter::toJSValueRef(const ContactEmailAddressTypeArrayPtr &arg)
+{
+       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactEmailAddressTypeArray::getClassRef(), arg);
+}
 
-       if (!JSValueIsUndefined(m_context, urlData)) {
-               url = toString(urlData);
-               result->setUrl(url);
-       }
+ContactEmailAddressTypeArrayPtr ContactConverter::toContactEmailAddressTypeArray(const JSValueRef &jsValue)
+{
+       if(JSContactEmailAddressTypeArray::isObjectOfClass(m_context, jsValue))
+               return JSContactEmailAddressTypeArray::getContactEmailAddressTypeArray(m_context, jsValue);
 
-       if (!JSValueIsUndefined(m_context, typeData)) {
-               type = toContactWebSiteType(typeData);
-               result->setType(type);
-       }
+       if(!JSIsArrayValue(m_context, jsValue))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "ContactEmailAddressTypeArray is not array.");
 
-       return result;
-}
+       ContactEmailAddressTypeArrayPtr result(new ContactEmailAddressTypeArray());
 
-JSValueRef ContactConverter::toJSValueRef(const ContactWebSiteArrayPtr &arg)
-{
-       //LogDebug("entered");
-       return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSContactWebSiteArray::getClassRef(), arg);
+       JSObjectRef jsObject = toJSObjectRef(jsValue);
+    for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
+        JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
+        result->push_back(toContactEmailAddressType(element));
+    }
+    return result;
 }
 
-ContactWebSiteArrayPtr ContactConverter::toContactWebSiteArray(const JSValueRef &jsValue)
+StringArrayPtr ContactConverter::toStringArray(const JSValueRef &jsValue)
 {
-       if(JSContactWebSiteArray::isObjectOfClass(m_context, jsValue))
-               return JSContactWebSiteArray::getContactWebSiteArray(m_context, jsValue);
+       if(JSStringArray::isObjectOfClass(m_context, jsValue))
+               return JSStringArray::getStringArray(m_context, jsValue);
 
-       ContactWebSiteArrayPtr result(new ContactWebSiteArray());
+       if(!JSIsArrayValue(m_context, jsValue))
+               ThrowMsg(WrtDeviceApis::Commons::ConversionException, "StringArray is not array.");
 
+       StringArrayPtr result = StringArrayPtr(new StringArray());
        JSObjectRef jsObject = toJSObjectRef(jsValue);
     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
-        result->push_back(toContactWebSite(element));
+        result->push_back(toString(element));
     }
     return result;
 }
 
+JSValueRef ContactConverter::toJSValueRef(const StringArrayPtr &arg)
+{
+       return JSStringArray::createArray(m_context, arg);
+}
+
+//std::string ContactConverter::toAttributesOfInterest(const JSValueRef &value)
+//{
+//     // need validator
+//     return toString(value);
+//}
+
+//JSValueRef ContactConverter::toJSValueRefAttributesOfInterestArray(const AttributesOfInterestArrayPtr &arg)
+//{
+//     return WrtDeviceApis::CommonsJavaScript::JSUtils::makeObject(m_context, JSAttributesOfInterestArray::getClassRef(), arg);
+//}
+
+//AttributesOfInterestArrayPtr ContactConverter::toAttributesOfInterestArray(const JSValueRef &jsValue)
+//{
+//     if(JSAttributesOfInterestArray::isObjectOfClass(m_context, jsValue))
+//             return JSAttributesOfInterestArray::getAttributesOfInterestArray(m_context, jsValue);
+//
+//     if(!JSIsArrayValue(m_context, jsValue))
+//             ThrowMsg(WrtDeviceApis::Commons::ConversionException, "AttributesOfInterestArray is not array.");
+//
+//     AttributesOfInterestArrayPtr result(new AttributesOfInterestArray());
+//
+//     JSObjectRef jsObject = toJSObjectRef(jsValue);
+//    for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
+//        JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
+//        result->push_back(toAttributesOfInterest(element));
+//    }
+//    return result;
+//}
+
 bool ContactConverter::initializeAllowedProperties()
 {
-       m_allowedAddressBookProperties.push_back(CONTACT_ATTRIBUTE_NAME);
-
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_ID);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_READ_ONLY);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_LAST_UPDATED);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_NAME);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_ACCOUNT);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_ADDRESSES);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_PHOTO_URI );
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_PHONE_NUMBERS);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_EMAILS);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_BIRTHDAY);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_ANNIVERSARIES);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_ORGANIZATION);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_NOTES);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_URLS);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_IS_FAVORITE);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_RINGTONE_URI);
-       m_allowedContactProperties.push_back(CONTACT_ATTRIBUTE_CATEGORIES);
-
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_NAME);
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_ACCOUNT);
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_ADDRESSES);
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_PHOTO_URI );
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_PHONE_NUMBERS);
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_EMAILS);
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_BIRTHDAY);
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_ANNIVERSARIES);
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_ORGANIZATION);
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_NOTES);
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_URLS);
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_IS_FAVORITE);
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_RINGTONE_URI);
-       m_allowedContactPropertiesProperties.push_back(CONTACT_ATTRIBUTE_CATEGORIES);
-
-       m_allowedContactNameProperties.push_back(CONTACT_ATTRIBUTE_PREFIX);
-       m_allowedContactNameProperties.push_back(CONTACT_ATTRIBUTE_FIRST_NAME);
-       m_allowedContactNameProperties.push_back(CONTACT_ATTRIBUTE_MIDDLE_NAME);
-       m_allowedContactNameProperties.push_back(CONTACT_ATTRIBUTE_LAST_NAME);
-       m_allowedContactNameProperties.push_back(CONTACT_ATTRIBUTE_NICKNAMES);
-       m_allowedContactNameProperties.push_back(CONTACT_ATTRIBUTE_PHONETIC_NAME);
-       m_allowedContactNameProperties.push_back(CONTACT_ATTRIBUTE_DISPLAY_NAME);
-
-       m_allowedContactAccountProperties.push_back(CONTACT_ATTRIBUTE_ACCOUNT_ID);
-       m_allowedContactAccountProperties.push_back(CONTACT_ATTRIBUTE_CONTACT_URI);
-
-       m_allowedContactOrganizationProperties.push_back(CONTACT_ATTRIBUTE_NAME);
-       m_allowedContactOrganizationProperties.push_back(CONTACT_ATTRIBUTE_DEPARTMENT);
-       m_allowedContactOrganizationProperties.push_back(CONTACT_ATTRIBUTE_OFFICE);
-       m_allowedContactOrganizationProperties.push_back(CONTACT_ATTRIBUTE_TITLE);
-       m_allowedContactOrganizationProperties.push_back(CONTACT_ATTRIBUTE_ROLE);
-       m_allowedContactOrganizationProperties.push_back(CONTACT_ATTRIBUTE_LOGO_URI);
-
-       m_allowedContactWebSiteProperties.push_back(CONTACT_ATTRIBUTE_URL);
-       m_allowedContactWebSiteProperties.push_back(CONTACT_ATTRIBUTE_TYPE);
-
-       m_allowedContactAnniversaryProperties.push_back(CONTACT_ATTRIBUTE_DATE);
-       m_allowedContactAnniversaryProperties.push_back(CONTACT_ATTRIBUTE_LABEL);
-
-       m_allowedContactAddressProperties.push_back(CONTACT_ATTRIBUTE_COUNTRY);
-       m_allowedContactAddressProperties.push_back(CONTACT_ATTRIBUTE_REGION);
-       m_allowedContactAddressProperties.push_back(CONTACT_ATTRIBUTE_CITY);
-       m_allowedContactAddressProperties.push_back(CONTACT_ATTRIBUTE_STREET_ADDRESS);
-       m_allowedContactAddressProperties.push_back(CONTACT_ATTRIBUTE_ADDITIONAL_INFORMATION);
-       m_allowedContactAddressProperties.push_back(CONTACT_ATTRIBUTE_POSTAL_CODE);
-       m_allowedContactAddressProperties.push_back(CONTACT_ATTRIBUTE_TYPES);
-
-       m_allowedContactPhoneNumberProperties.push_back(CONTACT_ATTRIBUTE_NUMBER);
-       m_allowedContactPhoneNumberProperties.push_back(CONTACT_ATTRIBUTE_TYPES);
-
-       m_allowedContactEmailAddressProperties.push_back(CONTACT_ATTRIBUTE_EMAIL);
-       m_allowedContactEmailAddressProperties.push_back(CONTACT_ATTRIBUTE_TYPES);
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_NAME);
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_ACCOUNT);
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_ADDRESSES);
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_PHOTO_URI );
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_PHONE_NUMBERS);
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_EMAILS);
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_BIRTHDAY);
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_ANNIVERSARIES);
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_ORGANIZATION);
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_NOTES);
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_URLS);
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_IS_FAVORITE);
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_RINGTONE_URI);
+       m_allowedContactInit.push_back(CONTACT_ATTRIBUTE_CATEGORIES);
+
+       m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_PREFIX);
+       m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_FIRST_NAME);
+       m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_MIDDLE_NAME);
+       m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_LAST_NAME);
+       m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_NICKNAMES);
+       m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_PHONETIC_NAME);
+       m_allowedContactNameInit.push_back(CONTACT_ATTRIBUTE_DISPLAY_NAME);
+
+       m_allowedContactOrganizationInit.push_back(CONTACT_ATTRIBUTE_NAME);
+       m_allowedContactOrganizationInit.push_back(CONTACT_ATTRIBUTE_DEPARTMENT);
+       m_allowedContactOrganizationInit.push_back(CONTACT_ATTRIBUTE_OFFICE);
+       m_allowedContactOrganizationInit.push_back(CONTACT_ATTRIBUTE_TITLE);
+       m_allowedContactOrganizationInit.push_back(CONTACT_ATTRIBUTE_ROLE);
+       m_allowedContactOrganizationInit.push_back(CONTACT_ATTRIBUTE_LOGO_URI);
+
+       m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_COUNTRY);
+       m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_REGION);
+       m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_CITY);
+       m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_STREET_ADDRESS);
+       m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_ADDITIONAL_INFORMATION);
+       m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_POSTAL_CODE);
+       m_allowedContactAddressInit.push_back(CONTACT_ATTRIBUTE_TYPES);
 
        return true;
 }
Domain: Web Framework / Uncategorized;