src/Contact/JSContactName.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        JSContactName.cpp
  20  * @author      Kisub Song (kisubs.song@samsung.com)
  21  * @version     0.1
  22  * @brief       Implementation of the JSContactName class
  23  */
  24
  25 #include <dpl/shared_ptr.h>
  26 #include <CommonsJavaScript/Validator.h>
  27 #include <JSTizenExceptionFactory.h>
  28 #include <JSTizenException.h>
  29 #include "ContactConverter.h"
  30 #include "JSContactName.h"
  31 #include <Logger.h>
  32 #include <Export.h>
  33
  34 #define CONTACT_CLASS_NAME                                              "ContactName"
  35 #define CONTACT_PROP_ATTR_PREFIX                                "prefix"
  36 #define CONTACT_PROP_ATTR_SUFFIX                                "suffix"
  37 #define CONTACT_PROP_ATTR_FIRST_NAME                    "firstName"
  38 #define CONTACT_PROP_ATTR_MIDDLE_NAME                   "middleName"
  39 #define CONTACT_PROP_ATTR_LAST_NAME                             "lastName"
  40 #define CONTACT_PROP_ATTR_NICKNAMES                             "nicknames"
  41 #define CONTACT_PROP_ATTR_PHONETIC_NAME             "phoneticName"
  42 #define CONTACT_PROP_ATTR_PHONETIC_FIRST_NAME   "phoneticFirstName"
  43 #define CONTACT_PROP_ATTR_PHONETIC_LAST_NAME    "phoneticLastName"
  44 #define CONTACT_PROP_ATTR_DISPLAY_NAME                  "displayName"
  45
  46 namespace DeviceAPI {
  47 namespace Contact {
  48
  49 using namespace DeviceAPI::Common;
  50 using namespace WrtDeviceApis::Commons;
  51 using namespace WrtDeviceApis::CommonsJavaScript;
  52
  53 JSClassDefinition JSContactName::m_classInfo =
  54 {
  55         0,
  56         kJSClassAttributeNone,
  57         CONTACT_CLASS_NAME,
  58         NULL,
  59         m_property,
  60         m_functions,
  61         Initialize,
  62         Finalize,
  63         NULL, //hasProperty,
  64         NULL, //GetProperty,
  65         NULL, //SetProperty,
  66         NULL, //DeleteProperty,
  67         NULL, //getPropertyNames,
  68         NULL, //CallAsFunction,
  69         constructor, //CallAsConstructor,
  70         hasInstance, //HasInstance,
  71         NULL, //ConvertToType,
  72 };
  73
  74 JSStaticValue JSContactName::m_property[] = {
  75         { CONTACT_PROP_ATTR_PREFIX, getPrefix, setPrefix, kJSPropertyAttributeNone },
  76         { CONTACT_PROP_ATTR_SUFFIX, getSuffix, setSuffix, kJSPropertyAttributeNone },
  77         { CONTACT_PROP_ATTR_FIRST_NAME, getFirstName, setFirstName, kJSPropertyAttributeNone },
  78         { CONTACT_PROP_ATTR_MIDDLE_NAME, getMiddleName, setMiddleName, kJSPropertyAttributeNone },
  79         { CONTACT_PROP_ATTR_LAST_NAME, getLastName, setLastName, kJSPropertyAttributeNone },
  80         { CONTACT_PROP_ATTR_NICKNAMES, getNicknames, setNicknames, kJSPropertyAttributeNone },
  81         { CONTACT_PROP_ATTR_PHONETIC_NAME, getPhoneticName, setPhoneticName, kJSPropertyAttributeNone },
  82         { CONTACT_PROP_ATTR_PHONETIC_FIRST_NAME, getPhoneticFirstName, setPhoneticFirstName, kJSPropertyAttributeNone },
  83         { CONTACT_PROP_ATTR_PHONETIC_LAST_NAME, getPhoneticLastName, setPhoneticLastName, kJSPropertyAttributeNone },
  84         { CONTACT_PROP_ATTR_DISPLAY_NAME, getDisplayName, NULL, kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete },
  85         { 0, 0, 0, 0 }
  86 };
  87
  88 JSStaticFunction JSContactName::m_functions[] =
  89 {
  90         { 0, 0, 0 }
  91 };
  92
  93 JSClassRef JSContactName::m_classRef = JSClassCreate(&m_classInfo);
  94
  95 JSClassRef DLL_EXPORT JSContactName::getClassRef()
  96 {
  97         if (!m_classRef) {
  98                 m_classRef = JSClassCreate(&m_classInfo);
  99         }
 100         return m_classRef;
 101 }
 102
 103 bool JSContactName::isObjectOfClass(JSContextRef context, JSValueRef value)
 104 {
 105         return JSValueIsObjectOfClass(context, value, getClassRef());
 106 }
 107
 108 ContactNamePtr JSContactName::getContactName(JSContextRef context, JSValueRef value)
 109 {
 110         if (!isObjectOfClass(context, value)) {
 111                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 112         }
 113
 114         JSObjectRef object = JSValueToObject(context, value, NULL);
 115         if (!object) {
 116                 Throw(WrtDeviceApis::Commons::InvalidArgumentException);
 117         }
 118
 119         JSContactNamePriv *priv = static_cast<JSContactNamePriv*>(JSObjectGetPrivate(object));
 120         if (!priv) {
 121                 Throw(WrtDeviceApis::Commons::NullPointerException);
 122         }
 123
 124         return priv->getObject();
 125 }
 126
 127 void JSContactName::Initialize(JSContextRef context, JSObjectRef object)
 128 {
 129         if (!JSObjectGetPrivate(object))
 130         {
 131                 ContactNamePtr name(new ContactName());
 132                 JSContactNamePriv *priv = new JSContactNamePriv(context, ContactNamePtr(name));
 133                 if (!JSObjectSetPrivate(object, priv)) {
 134                         delete priv;
 135                 }
 136         }
 137 }
 138
 139 void JSContactName::Finalize(JSObjectRef object)
 140 {
 141         JSContactNamePriv *priv = static_cast<JSContactNamePriv*>(JSObjectGetPrivate(object));
 142
 143         if (priv != NULL)
 144                 delete (priv);
 145 }
 146
 147 JSObjectRef JSContactName::createJSObject(JSContextRef context, ContactNamePtr contactName)
 148 {
 149         JSContactNamePriv *priv = new JSContactNamePriv(context, contactName);
 150         JSObjectRef jsObjectRef = JSObjectMake(context, getClassRef(), static_cast<void*>(priv));
 151         if (NULL == jsObjectRef)
 152         {
 153                 LoggerE("object creation error");
 154                 return NULL;
 155         }
 156         return jsObjectRef;
 157 }
 158
 159 ContactNamePtr JSContactName::getPrivData(JSObjectRef object)
 160 {
 161         JSContactNamePriv *priv = static_cast<JSContactNamePriv*>(JSObjectGetPrivate(object));
 162         if (!priv) {
 163                 ThrowMsg(WrtDeviceApis::Commons::NullPointerException, "Private object is null");
 164         }
 165
 166         ContactNamePtr result = priv->getObject();
 167         if (!result) {
 168                 ThrowMsg(WrtDeviceApis::Commons::NullPointerException, "Private object is null");
 169         }
 170
 171         return result;
 172 }
 173
 174 JSObjectRef JSContactName::constructor(JSContextRef context,
 175                 JSObjectRef constructor,
 176                 size_t argumentCount,
 177                 const JSValueRef arguments[],
 178                 JSValueRef* exception)
 179 {
 180         bool js1stParamIsObject = false;
 181
 182         JSContactNamePriv *priv = static_cast<JSContactNamePriv*>(JSObjectGetPrivate(constructor));
 183         if (!priv) {
 184                 ThrowMsg(WrtDeviceApis::Commons::NullPointerException, "Private object is null");
 185         }
 186         JSContextRef gContext = priv->getContext();
 187
 188         BasicValidator validator = BasicValidatorFactory::getValidator(context, exception);
 189         Try {
 190                 if (argumentCount >= 1)
 191                 {
 192                         if (JSValueIsObject(gContext, arguments[0]))
 193                                 js1stParamIsObject = true;
 194
 195                         if (!js1stParamIsObject &&
 196                                         !JSValueIsNull(gContext, arguments[0]) &&
 197                                         !JSValueIsUndefined(gContext, arguments[0]))
 198                                 ThrowMsg(InvalidArgumentException, "1st argument must be 'object'");
 199                 }
 200
 201         } Catch(Exception ) {
 202                 LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
 203                 *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::TYPE_MISMATCH_ERROR, "1st argument must be 'object'");
 204                 return NULL;
 205         }
 206
 207         ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(gContext);
 208
 209         ContactNamePtr contactName(NULL);
 210         Try {
 211                 if(js1stParamIsObject)
 212                         contactName = converter->toContactNameFromInit(arguments[0]);
 213                 else
 214                         contactName = ContactNamePtr(new ContactName());
 215
 216         } Catch(Exception) {
 217                 LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
 218                 *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Internal error");
 219                 return NULL;
 220         }
 221
 222         JSObjectRef jsobject;
 223
 224         Try {
 225                 jsobject = createJSObject(gContext, contactName);
 226         } Catch(Exception) {
 227                 LoggerE("Argument type mismatch : " << _rethrown_exception.GetMessage());
 228                 *exception = JSTizenExceptionFactory::makeErrorObject(context, JSTizenException::UNKNOWN_ERROR, "Internal error");
 229                 return NULL;
 230         }
 231
 232         return jsobject;
 233 }
 234
 235 bool JSContactName::hasInstance(JSContextRef context,
 236                 JSObjectRef constructor,
 237                 JSValueRef possibleInstance,
 238                 JSValueRef* exception)
 239 {
 240         return JSValueIsObjectOfClass(context, possibleInstance, getClassRef());
 241 }
 242
 243 JSValueRef JSContactName::getPrefix(JSContextRef context,
 244                 JSObjectRef object,
 245                 JSStringRef propertyName,
 246                 JSValueRef* exception)
 247 {
 248         Try
 249         {
 250                 ContactConverterFactory::ConverterType converter =
 251                                 ContactConverterFactory::getConverter(context);
 252                 ContactNamePtr contactName = getPrivData(object);
 253                 if(!contactName->getPrefixIsSet())
 254                         return JSValueMakeNull(context);
 255                 else
 256                         return converter->toJSValueRef(contactName->getPrefix());
 257         }
 258         Catch(WrtDeviceApis::Commons::Exception)
 259         {
 260                 LoggerW("trying to get incorrect value");
 261         }
 262
 263         return JSValueMakeUndefined(context);
 264 }
 265
 266 bool JSContactName::setPrefix(JSContextRef context,
 267                 JSObjectRef object,
 268                 JSStringRef propertyName,
 269                 JSValueRef value,
 270                 JSValueRef* exception)
 271 {
 272         Try
 273         {
 274                 ContactNamePtr contactName = getPrivData(object);
 275                 ContactConverterFactory::ConverterType converter =
 276                                 ContactConverterFactory::getConverter(context);
 277                 BasicValidator validator =
 278                                 BasicValidatorFactory::getValidator(context, exception);
 279                 if(validator->isNullOrUndefined(value))
 280                         contactName->unsetPrefix();
 281                 else
 282                         contactName->setPrefix(converter->toString(value));
 283         }
 284         Catch(WrtDeviceApis::Commons::Exception)
 285         {
 286                 LoggerW("trying to set incorrect value");
 287                 JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
 288         }
 289         return true;
 290 }
 291
 292 JSValueRef JSContactName::getSuffix(JSContextRef context,
 293                 JSObjectRef object,
 294                 JSStringRef propertyName,
 295                 JSValueRef* exception)
 296 {
 297         Try
 298         {
 299                 ContactConverterFactory::ConverterType converter =
 300                                 ContactConverterFactory::getConverter(context);
 301                 ContactNamePtr contactName = getPrivData(object);
 302                 if(!contactName->getSuffixIsSet())
 303                         return JSValueMakeNull(context);
 304                 else
 305                         return converter->toJSValueRef(contactName->getSuffix());
 306         }
 307         Catch(WrtDeviceApis::Commons::Exception)
 308         {
 309                 LoggerW("trying to get incorrect value");
 310         }
 311
 312         return JSValueMakeUndefined(context);
 313 }
 314
 315 bool JSContactName::setSuffix(JSContextRef context,
 316                 JSObjectRef object,
 317                 JSStringRef propertyName,
 318                 JSValueRef value,
 319                 JSValueRef* exception)
 320 {
 321         Try
 322         {
 323                 ContactNamePtr contactName = getPrivData(object);
 324                 ContactConverterFactory::ConverterType converter =
 325                                 ContactConverterFactory::getConverter(context);
 326                 BasicValidator validator = BasicValidatorFactory::getValidator(context, exception);
 327                 if(validator->isNullOrUndefined(value))
 328                         contactName->unsetSuffix();
 329                 else
 330                         contactName->setSuffix(converter->toString(value));
 331         }
 332         Catch(WrtDeviceApis::Commons::Exception)
 333         {
 334                 LoggerW("trying to set incorrect value");
 335                 JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
 336         }
 337         return true;
 338 }
 339
 340 JSValueRef JSContactName::getFirstName(JSContextRef context,
 341                 JSObjectRef object,
 342                 JSStringRef propertyName,
 343                 JSValueRef* exception)
 344 {
 345         Try
 346         {
 347                 ContactConverterFactory::ConverterType converter =
 348                                 ContactConverterFactory::getConverter(context);
 349                 ContactNamePtr contactName = getPrivData(object);
 350                 if(!contactName->getFirstNameIsSet())
 351                         return JSValueMakeNull(context);
 352                 else
 353                         return converter->toJSValueRef(contactName->getFirstName());
 354         }
 355         Catch(WrtDeviceApis::Commons::Exception)
 356         {
 357                 LoggerW("trying to get incorrect value");
 358         }
 359
 360         return JSValueMakeUndefined(context);
 361 }
 362
 363 bool JSContactName::setFirstName(JSContextRef context,
 364                 JSObjectRef object,
 365                 JSStringRef propertyName,
 366                 JSValueRef value,
 367                 JSValueRef* exception)
 368 {
 369         Try
 370         {
 371                 ContactNamePtr contactName = getPrivData(object);
 372                 ContactConverterFactory::ConverterType converter = ContactConverterFactory::getConverter(context);
 373                 BasicValidator validator = BasicValidatorFactory::getValidator(context, exception);
 374                 if(validator->isNullOrUndefined(value))
 375                         contactName->unsetFirstName();
 376                 else
 377                         contactName->setFirstName(converter->toString(value));
 378         }
 379         Catch(WrtDeviceApis::Commons::Exception)
 380         {
 381                 LoggerW("trying to set incorrect value");
 382                 JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
 383         }
 384
 385         return true;
 386 }
 387
 388 JSValueRef JSContactName::getMiddleName(JSContextRef context,
 389                 JSObjectRef object,
 390                 JSStringRef propertyName,
 391                 JSValueRef* exception)
 392 {
 393         Try
 394         {
 395                 ContactConverterFactory::ConverterType converter =
 396                                 ContactConverterFactory::getConverter(context);
 397                 ContactNamePtr contactName = getPrivData(object);
 398                 if(!contactName->getMiddleNameIsSet())
 399                         return JSValueMakeNull(context);
 400                 else
 401                         return converter->toJSValueRef(contactName->getMiddleName());
 402         }
 403         Catch(WrtDeviceApis::Commons::Exception)
 404         {
 405                 LoggerW("trying to get incorrect value");
 406         }
 407
 408         return JSValueMakeUndefined(context);
 409 }
 410
 411 bool JSContactName::setMiddleName(JSContextRef context,
 412                 JSObjectRef object,
 413                 JSStringRef propertyName,
 414                 JSValueRef value,
 415                 JSValueRef* exception)
 416 {
 417         Try
 418         {
 419                 ContactNamePtr contactName = getPrivData(object);
 420                 ContactConverterFactory::ConverterType converter =
 421                                 ContactConverterFactory::getConverter(context);
 422                 BasicValidator validator =
 423                                 BasicValidatorFactory::getValidator(context, exception);
 424                 if(validator->isNullOrUndefined(value))
 425                         contactName->unsetMiddleName();
 426                 else
 427                         contactName->setMiddleName(converter->toString(value));
 428         }
 429         Catch(WrtDeviceApis::Commons::Exception)
 430         {
 431                 LoggerW("trying to set incorrect value");
 432                 JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
 433         }
 434
 435         return true;
 436 }
 437
 438 JSValueRef JSContactName::getLastName(JSContextRef context,
 439                 JSObjectRef object,
 440                 JSStringRef propertyName,
 441                 JSValueRef* exception)
 442 {
 443         Try
 444         {
 445                 ContactConverterFactory::ConverterType converter =
 446                                 ContactConverterFactory::getConverter(context);
 447                 ContactNamePtr contactName = getPrivData(object);
 448                 if(!contactName->getLastNameIsSet())
 449                         return JSValueMakeNull(context);
 450                 else
 451                         return converter->toJSValueRef(contactName->getLastName());
 452         }
 453         Catch(WrtDeviceApis::Commons::Exception)
 454         {
 455                 LoggerW("trying to get incorrect value");
 456         }
 457
 458         return JSValueMakeUndefined(context);
 459 }
 460
 461 bool JSContactName::setLastName(JSContextRef context,
 462                 JSObjectRef object,
 463                 JSStringRef propertyName,
 464                 JSValueRef value,
 465                 JSValueRef* exception)
 466 {
 467         Try
 468         {
 469                 ContactNamePtr contactName = getPrivData(object);
 470                 ContactConverterFactory::ConverterType converter =
 471                                 ContactConverterFactory::getConverter(context);
 472                 BasicValidator validator =
 473                                 BasicValidatorFactory::getValidator(context, exception);
 474                 if(validator->isNullOrUndefined(value))
 475                         contactName->unsetLastName();
 476                 else
 477                         contactName->setLastName(converter->toString(value));
 478         }
 479         Catch(WrtDeviceApis::Commons::Exception)
 480         {
 481                 LoggerW("trying to set incorrect value");
 482                 JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
 483         }
 484
 485         return true;
 486 }
 487
 488 JSValueRef JSContactName::getNicknames(JSContextRef context,
 489                 JSObjectRef object,
 490                 JSStringRef propertyName,
 491                 JSValueRef* exception)
 492 {
 493         Try
 494         {
 495                 JSContactNamePriv *priv = static_cast<JSContactNamePriv*>(JSObjectGetPrivate(object));
 496                 if (!priv) {
 497                         ThrowMsg(WrtDeviceApis::Commons::NullPointerException, "Private object is null");
 498                 }
 499                 JSContextRef gContext = priv->getContext();
 500
 501                 ContactConverterFactory::ConverterType converter =      ContactConverterFactory::getConverter(gContext);
 502                 ContactNamePtr contactName = getPrivData(object);
 503
 504                 if(contactName->IsTypesSetJSArray()){
 505                         return contactName->getTypesJSObj();
 506                 }else{
 507                         JSValueRef tempJSValue = contactName->getTypesJSArray();
 508                         tempJSValue = converter->toJSValueRef(contactName->getNicknames());
 509
 510                         JSObjectRef convertedJSObject = contactName->getTypesJSObj();
 511                         convertedJSObject = JSValueToObject( gContext, tempJSValue, NULL );
 512                         contactName->setTypesJSArray(true, convertedJSObject);
 513
 514                         JSValueProtect(gContext, convertedJSObject);
 515                         contactName->setContext(gContext);
 516                         return tempJSValue;
 517                 }
 518         }
 519         Catch(WrtDeviceApis::Commons::Exception)
 520         {
 521                 LoggerW("trying to get incorrect value");
 522         }
 523
 524         return JSValueMakeUndefined(context);
 525 }
 526
 527 bool JSContactName::setNicknames(JSContextRef context,
 528                 JSObjectRef object,
 529                 JSStringRef propertyName,
 530                 JSValueRef value,
 531                 JSValueRef* exception)
 532 {
 533         Try
 534         {
 535                 ContactNamePtr contactName = getPrivData(object);
 536                 ContactConverterFactory::ConverterType converter =
 537                                 ContactConverterFactory::getConverter(context);
 538                 contactName->setNicknames(converter->toStringArray(value));
 539                 contactName->resetTypesJSObj();
 540         }
 541         Catch(WrtDeviceApis::Commons::Exception)
 542         {
 543                 LoggerW("trying to set incorrect value");
 544                 JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
 545         }
 546
 547         return true;
 548 }
 549
 550 JSValueRef JSContactName::getPhoneticName(JSContextRef context,
 551                 JSObjectRef object,
 552                 JSStringRef propertyName,
 553                 JSValueRef* exception)
 554 {
 555         // NOTE: Deprecated field.
 556         return JSValueMakeNull(context);
 557 }
 558
 559 bool JSContactName::setPhoneticName(JSContextRef context,
 560                 JSObjectRef object,
 561                 JSStringRef propertyName,
 562                 JSValueRef value,
 563                 JSValueRef* exception)
 564 {
 565         // NOTE: Deprecated field.
 566         return true;
 567 }
 568
 569 JSValueRef JSContactName::getPhoneticFirstName(JSContextRef context,
 570                 JSObjectRef object,
 571                 JSStringRef propertyName,
 572                 JSValueRef* exception)
 573 {
 574         Try
 575         {
 576                 ContactConverterFactory::ConverterType converter =
 577                                 ContactConverterFactory::getConverter(context);
 578                 ContactNamePtr contactName = getPrivData(object);
 579                 if(!contactName->getPhoneticFirstNameIsSet())
 580                         return JSValueMakeNull(context);
 581                 else
 582                         return converter->toJSValueRef(contactName->getPhoneticFirstName());
 583         }
 584         Catch(WrtDeviceApis::Commons::Exception)
 585         {
 586                 LoggerW("trying to get incorrect value");
 587         }
 588
 589         return JSValueMakeUndefined(context);
 590 }
 591
 592 bool JSContactName::setPhoneticFirstName(JSContextRef context,
 593                 JSObjectRef object,
 594                 JSStringRef propertyName,
 595                 JSValueRef value,
 596                 JSValueRef* exception)
 597 {
 598         Try
 599         {
 600                 ContactNamePtr contactName = getPrivData(object);
 601                 ContactConverterFactory::ConverterType converter =
 602                                 ContactConverterFactory::getConverter(context);
 603                 BasicValidator validator =
 604                                 BasicValidatorFactory::getValidator(context, exception);
 605                 if(validator->isNullOrUndefined(value))
 606                         contactName->unsetPhoneticFirstName();
 607                 else
 608                         contactName->setPhoneticFirstName(converter->toString(value));
 609         }
 610         Catch(WrtDeviceApis::Commons::Exception)
 611         {
 612                 LoggerW("trying to set incorrect value");
 613                 JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
 614         }
 615
 616         return true;
 617 }
 618
 619 JSValueRef JSContactName::getPhoneticLastName(JSContextRef context,
 620                 JSObjectRef object,
 621                 JSStringRef propertyName,
 622                 JSValueRef* exception)
 623 {
 624         Try
 625         {
 626                 ContactConverterFactory::ConverterType converter =
 627                                 ContactConverterFactory::getConverter(context);
 628                 ContactNamePtr contactName = getPrivData(object);
 629                 if(!contactName->getPhoneticLastNameIsSet())
 630                         return JSValueMakeNull(context);
 631                 else
 632                         return converter->toJSValueRef(contactName->getPhoneticLastName());
 633         }
 634         Catch(WrtDeviceApis::Commons::Exception)
 635         {
 636                 LoggerW("trying to get incorrect value");
 637         }
 638
 639         return JSValueMakeUndefined(context);
 640 }
 641
 642 bool JSContactName::setPhoneticLastName(JSContextRef context,
 643                 JSObjectRef object,
 644                 JSStringRef propertyName,
 645                 JSValueRef value,
 646                 JSValueRef* exception)
 647 {
 648         Try
 649         {
 650                 ContactNamePtr contactName = getPrivData(object);
 651                 ContactConverterFactory::ConverterType converter =
 652                                 ContactConverterFactory::getConverter(context);
 653                 BasicValidator validator =
 654                                 BasicValidatorFactory::getValidator(context, exception);
 655                 if(validator->isNullOrUndefined(value))
 656                         contactName->unsetPhoneticLastName();
 657                 else
 658                         contactName->setPhoneticLastName(converter->toString(value));
 659         }
 660         Catch(WrtDeviceApis::Commons::Exception)
 661         {
 662                 LoggerW("trying to set incorrect value");
 663                 JSTizenExceptionFactory::postException(context, exception, JSTizenException::TYPE_MISMATCH_ERROR, "Type mismatch");
 664         }
 665
 666         return true;
 667 }
 668
 669 JSValueRef JSContactName::getDisplayName(JSContextRef context,
 670                 JSObjectRef object,
 671                 JSStringRef propertyName,
 672                 JSValueRef* exception)
 673 {
 674         Try
 675         {
 676                 ContactConverterFactory::ConverterType converter =
 677                                 ContactConverterFactory::getConverter(context);
 678                 ContactNamePtr contactName = getPrivData(object);
 679                 if(!contactName->getDisplayNameIsSet())
 680                         return JSValueMakeNull(context);
 681                 else
 682                         return converter->toJSValueRef(contactName->getDisplayName());
 683         }
 684         Catch(WrtDeviceApis::Commons::Exception)
 685         {
 686                 LoggerW("trying to get incorrect value");
 687         }
 688
 689         return JSValueMakeUndefined(context);
 690 }
 691
 692 } // Contact
 693 } // DeviceAPI