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