src/platform/Tizen/Contact/ContactObjectP2AConverter.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /*
  17  * @file        ContactObjectP2AConverter.cpp
  18  * @author      Kisub Song (kisubs.song@samsung.com)
  19  * @version     0.1
  20  * @brief       Converter (CTSstruct* -> TizenApis::Api::Contact::ContactPtr)
  21  */
  22
  23 #include "ContactObjectP2AConverter.h"
  24
  25 #include <vector>
  26 #include <pcrecpp.h>
  27 #include <dpl/log/log.h>
  28 #include <Commons/Exception.h>
  29 #include <Commons/Regex.h>
  30 #include "AddressBook.h"
  31 #include "Contact.h"
  32 #include "ContactUtility.h"
  33 #include "query-svc/query-service.h"
  34
  35 namespace TizenApis {
  36 namespace Platform {
  37 namespace Contact {
  38
  39 using namespace TizenApis::Api::Contact;
  40 using namespace WrtDeviceApis::Commons;
  41 using namespace std;
  42
  43 ContactObjectP2AConverter::ContactObjectP2AConverter(CTSstruct* platformContact,
  44                 bool forScratch) :
  45                 m_platformContact(platformContact),
  46                 m_abstractContact(ContactPtr(NULL)),
  47                 m_forScratch(forScratch),
  48                 m_convertFinished(false)
  49 {
  50 }
  51
  52 ContactObjectP2AConverter::ContactObjectP2AConverter(CTSstruct* platformContact,
  53                 bool forScratch,
  54                 ContactPtr &abstractContact) :
  55                 m_platformContact(platformContact),
  56                 m_abstractContact(abstractContact),
  57                 m_forScratch(forScratch),
  58                 m_convertFinished(false)
  59 {
  60 }
  61
  62 ContactObjectP2AConverter::~ContactObjectP2AConverter()
  63 {
  64 }
  65
  66 ContactPtr ContactObjectP2AConverter::getAbstractContact()
  67 {
  68         LogDebug("enter");
  69
  70         if(m_platformContact == NULL)
  71         {
  72                 LogError("Platform contact object did not set");
  73                 ThrowMsg(InvalidArgumentException, "Platform contact object did not set");
  74         }
  75
  76         if(m_abstractContact == NULL)
  77         {
  78                 LogDebug("Abstract contact object did not set, so a new object has been created");
  79                 m_abstractContact = ContactPtr(new Contact());
  80         }
  81
  82         LogDebug("for scratch : " << m_forScratch);
  83
  84         Try
  85         {
  86                 if(m_convertFinished == false)
  87                         convertToAbstractObject();
  88         }
  89         Catch(Exception)
  90         {
  91                 LogError("Error while converting - " << _rethrown_exception.GetMessage());
  92                 ThrowMsg(PlatformException, "Fail to convert platform object to abstract object.");
  93         }
  94
  95         return m_abstractContact;
  96 }
  97
  98 void ContactObjectP2AConverter::convertToAbstractObject()
  99 {
 100         exportBaseInfoValue();
 101         exportNameValue();
 102         exportCompanyValue();
 103 //      exportNoteValue();
 104         exportNumberList();
 105         exportEmailList();
 106         exportGrouprelList();
 107         exportEventList();
 108         exportPostalList();
 109         exportWebAddrList();
 110         exportNicknameList();
 111
 112         m_convertFinished = true;
 113 }
 114
 115 void ContactObjectP2AConverter::exportBaseInfoValue()
 116 {
 117         int errorCode = 0;
 118         CTSvalue *ctsValue = NULL;
 119
 120         errorCode = contacts_svc_struct_get_value(m_platformContact, CTS_CF_BASE_INFO_VALUE, &ctsValue);
 121         if (errorCode != CTS_SUCCESS)
 122                 ThrowMsg(UnknownException, "getting base info value (err:" << errorCode << ")");
 123
 124         if(!m_forScratch)
 125         {
 126                 int id = contacts_svc_value_get_int(ctsValue, CTS_BASE_VAL_ID_INT);
 127                 m_abstractContact->setId(id);
 128
 129                 int addressBookId = contacts_svc_value_get_int(ctsValue, CTS_BASE_VAL_ADDRESSBOOK_ID_INT);
 130                 m_abstractContact->setAddressBookId(addressBookId);
 131
 132                 time_t changedTime = (time_t)contacts_svc_value_get_int(ctsValue, CTS_BASE_VAL_CHANGED_TIME_INT);
 133                 struct tm *changedTimeTm = gmtime(&changedTime);
 134                 m_abstractContact->setLastUpdated(*changedTimeTm);
 135         }
 136
 137         const char *charValue = NULL;
 138
 139         charValue = contacts_svc_value_get_str(ctsValue, CTS_BASE_VAL_IMG_PATH_STR);
 140         if (charValue)
 141                 m_abstractContact->setPhotoURI(ContactUtility::convertPathToUri(charValue));
 142         else
 143         {
 144                 if(m_abstractContact->getPhotoURIIsSet())
 145                         m_abstractContact->unsetPhotoURI();
 146         }
 147
 148         charValue = contacts_svc_value_get_str(ctsValue, CTS_BASE_VAL_RINGTONE_PATH_STR);
 149         if (charValue)
 150                 m_abstractContact->setRingtoneURI(ContactUtility::convertPathToUri(charValue));
 151         else
 152         {
 153                 if(m_abstractContact->getRingtoneURIIsSet())
 154                         m_abstractContact->unsetRingtoneURI();
 155         }
 156
 157         charValue = contacts_svc_value_get_str(ctsValue, CTS_BASE_VAL_NOTE_STR);
 158         if (charValue)
 159                 m_abstractContact->setNote(charValue);
 160         else
 161         {
 162                 if(m_abstractContact->getNoteIsSet())
 163                         m_abstractContact->unsetNote();
 164         }
 165 }
 166
 167 void ContactObjectP2AConverter::exportNameValue()
 168 {
 169         int errorCode = 0;
 170         CTSvalue *ctsValue = NULL;
 171
 172         errorCode = contacts_svc_struct_get_value(m_platformContact, CTS_CF_NAME_VALUE, &ctsValue);
 173         if(errorCode != CTS_SUCCESS && errorCode != CTS_ERR_NO_DATA)
 174                 ThrowMsg(UnknownException, "getting name value (err:" << errorCode << ")");
 175
 176         if(ctsValue == NULL || errorCode == CTS_ERR_NO_DATA)
 177         {
 178                 //LogDebug("Platform contact don't have name value");
 179                 ContactNamePtr contactName = m_abstractContact->getName();
 180                 if(contactName != NULL)
 181                 {
 182                         if(contactName->getFirstNameIsSet())
 183                                 contactName->unsetFirstName();
 184
 185                         if(contactName->getMiddleNameIsSet())
 186                                 contactName->unsetMiddleName();
 187
 188                         if(contactName->getLastNameIsSet())
 189                                 contactName->unsetLastName();
 190
 191                         if(contactName->getPrefixIsSet())
 192                                 contactName->unsetPrefix();
 193
 194                         if(contactName->getPhoneticFirstNameIsSet())
 195                                 contactName->unsetPhoneticFirstName();
 196
 197                         if(contactName->getPhoneticLastNameIsSet())
 198                                 contactName->unsetPhoneticLastName();
 199
 200                         if(contactName->getDisplayNameIsSet())
 201                                 contactName->unsetDisplayName();
 202                 }
 203                 return;
 204         }
 205
 206         ContactNamePtr contactName = m_abstractContact->getName();
 207         if(contactName == NULL)
 208         {
 209                 contactName = ContactNamePtr(new ContactName());
 210                 m_abstractContact->setName(contactName);
 211         }
 212
 213         const char *charValue = NULL;
 214
 215         charValue = contacts_svc_value_get_str(ctsValue, CTS_NAME_VAL_FIRST_STR);
 216         if (charValue)
 217                 contactName->setFirstName(charValue);
 218         else
 219         {
 220                 if(contactName->getFirstNameIsSet())
 221                         contactName->unsetFirstName();
 222         }
 223
 224         charValue = contacts_svc_value_get_str(ctsValue, CTS_NAME_VAL_ADDITION_STR);
 225         if (charValue)
 226                 contactName->setMiddleName(charValue);
 227         else
 228         {
 229                 if(contactName->getMiddleNameIsSet())
 230                         contactName->unsetMiddleName();
 231         }
 232
 233         charValue = contacts_svc_value_get_str(ctsValue, CTS_NAME_VAL_LAST_STR);
 234         if (charValue)
 235                 contactName->setLastName(charValue);
 236         else
 237         {
 238                 if(contactName->getLastNameIsSet())
 239                         contactName->unsetLastName();
 240         }
 241
 242         charValue = contacts_svc_value_get_str(ctsValue, CTS_NAME_VAL_PREFIX_STR);
 243         if (charValue)
 244                 contactName->setPrefix(charValue);
 245         else
 246         {
 247                 if(contactName->getPrefixIsSet())
 248                         contactName->unsetPrefix();
 249         }
 250
 251         charValue = contacts_svc_value_get_str(ctsValue, CTS_NAME_VAL_DISPLAY_STR);
 252         if (charValue)
 253                 contactName->setDisplayName(charValue);
 254         else
 255         {
 256                 if(contactName->getDisplayNameIsSet())
 257                         contactName->unsetDisplayName();
 258         }
 259
 260 //      charValue = contacts_svc_value_get_str(ctsValue, CTS_NAME_VAL_PHONETIC_NAME_STR);
 261 //      if (charValue)
 262 //              contactName->setPhoneticFirstName(charValue);
 263 //      else
 264 //      {
 265 //              if(contactName->getPhoneticFirstNameIsSet())
 266 //                      contactName->unsetPhoneticFirstName();
 267 //      }
 268 //
 269 //      charValue = contacts_svc_value_get_str(ctsValue, CTS_NAME_VAL_PHONETIC_LAST_STR);
 270 //      if (charValue)
 271 //              contactName->setPhoneticLastName(charValue);
 272 //      else
 273 //      {
 274 //              if(contactName->getPhoneticLastNameIsSet())
 275 //                      contactName->unsetPhoneticLastName();
 276 //      }
 277 }
 278
 279
 280 void ContactObjectP2AConverter::exportCompanyValue()
 281 {
 282         int errorCode = 0;
 283         CTSvalue *ctsValue = NULL;
 284
 285         errorCode = contacts_svc_struct_get_value(m_platformContact, CTS_CF_COMPANY_VALUE, &ctsValue);
 286         if(errorCode != CTS_SUCCESS && errorCode != CTS_ERR_NO_DATA)
 287                 ThrowMsg(UnknownException, "getting company value (err:" << errorCode << ")");
 288
 289         if(ctsValue == NULL || errorCode == CTS_ERR_NO_DATA)
 290         {
 291                 //LogDebug("Platform contact don't have company value");
 292                 if(m_abstractContact->getOrganization() != NULL)
 293                         m_abstractContact->unsetOrganization();
 294
 295                 return;
 296         }
 297
 298         ContactOrganizationPtr organization = m_abstractContact->getOrganization();
 299         if(organization == NULL)
 300         {
 301                 organization = ContactOrganizationPtr(new ContactOrganization());
 302                 m_abstractContact->setOrganization(organization);
 303         }
 304
 305         const char *charValue = NULL;
 306
 307         charValue = contacts_svc_value_get_str(ctsValue, CTS_COMPANY_VAL_NAME_STR);
 308         if (charValue)
 309                 organization->setName(charValue);
 310         else
 311         {
 312                 if(organization->getNameIsSet())
 313                         organization->unsetName();
 314         }
 315
 316         charValue = contacts_svc_value_get_str(ctsValue, CTS_COMPANY_VAL_DEPARTMENT_STR);
 317         if (charValue)
 318                 organization->setDepartment(charValue);
 319         else
 320         {
 321                 if(organization->getDepartmentIsSet())
 322                         organization->unsetDepartment();
 323         }
 324
 325         charValue = contacts_svc_value_get_str(ctsValue, CTS_COMPANY_VAL_JOB_TITLE_STR);
 326         if (charValue)
 327                 organization->setTitle(charValue);
 328         else
 329         {
 330                 if(organization->getTitleIsSet())
 331                         organization->unsetTitle();
 332         }
 333
 334         charValue = contacts_svc_value_get_str(ctsValue, CTS_COMPANY_VAL_ROLE_STR);
 335         if (charValue)
 336                 organization->setRole(charValue);
 337         else
 338         {
 339                 if(organization->getRoleIsSet())
 340                         organization->unsetRole();
 341         }
 342
 343 //      charValue = contacts_svc_value_get_str(ctsValue, CTS_COMPANY_VAL_LOGOURI_STR);
 344 //      if (charValue)
 345 //              organization->setLogoURI(charValue);
 346 //      else
 347 //      {
 348 //              if(organization->getLogoURIIsSet())
 349 //                      organization->unsetLogoURI();
 350 //      }
 351         if(organization->getLogoURIIsSet())
 352                 organization->unsetLogoURI();
 353 }
 354
 355 //void ContactObjectP2AConverter::exportNoteValue()
 356 //{
 357 //      int errorCode = 0;
 358 //      CTSvalue *ctsValue = NULL;
 359 //
 360 //      errorCode = contacts_svc_struct_get_value(m_platformContact, CTS_CF_NOTE_VALUE, &ctsValue);
 361 //      if(errorCode != CTS_SUCCESS && errorCode != CTS_ERR_NO_DATA)
 362 //              ThrowMsg(UnknownException, "getting note value : (err:" << errorCode << ")");
 363 //
 364 //      if(ctsValue == NULL || errorCode == CTS_ERR_NO_DATA)
 365 //      {
 366 //              //LogDebug("Platform contact don't have note value");
 367 //              if(m_abstractContact->getNoteIsSet())
 368 //                      m_abstractContact->unsetNote();
 369 //
 370 //              return;
 371 //      }
 372 //
 373 //      bool boolValue = false;
 374 //      const char *charValue = NULL;
 375 //
 376 //      boolValue = contacts_svc_value_get_bool(ctsValue, CTS_NOTE_VAL_DELETE_BOOL);
 377 //      charValue = contacts_svc_value_get_str(ctsValue, CTS_COMPANY_VAL_NAME_STR);
 378 //      if (charValue && boolValue != false)
 379 //              m_abstractContact->setNote(charValue);
 380 //      else
 381 //      {
 382 //              if(m_abstractContact->getNoteIsSet())
 383 //                      m_abstractContact->unsetNote();
 384 //      }
 385 //}
 386
 387 void ContactObjectP2AConverter::exportNumberList()
 388 {
 389         int errorCode = 0;
 390         GSList *numberList = NULL;
 391
 392         if(m_abstractContact->getPhoneNumbersNum() > 0)
 393                 m_abstractContact->clearPhoneNumbers();
 394
 395         errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_NUMBER_LIST, &numberList);
 396         if(errorCode != CTS_SUCCESS && errorCode != CTS_ERR_NO_DATA)
 397                 ThrowMsg(UnknownException, "getting number list (err:" << errorCode << ")");
 398
 399         if(numberList == NULL || errorCode == CTS_ERR_NO_DATA)
 400         {
 401                 //LogDebug("Platform contact don't have number list");
 402                 return;
 403         }
 404
 405         ContactPhoneNumberArrayPtr phoneNumbers = m_abstractContact->getPhoneNumbers();
 406
 407         for (; numberList; numberList = g_slist_next(numberList))
 408         {
 409                 ContactPhoneNumberPtr phoneNumber(new ContactPhoneNumber());
 410
 411                 const char *charValue = NULL;
 412                 bool boolValue = false;
 413                 int intValue = 0;
 414
 415                 boolValue = contacts_svc_value_get_bool(static_cast<CTSvalue*>(numberList->data), CTS_NUM_VAL_DELETE_BOOL);
 416                 if(boolValue)
 417                 {
 418                         //LogDebug("Platform contact have a phone number to be deleted");
 419                         continue;
 420                 }
 421
 422                 charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(numberList->data), CTS_NUM_VAL_NUMBER_STR);
 423                 if (charValue)
 424                 {
 425                         phoneNumber->setNumber(charValue);
 426                         phoneNumbers->push_back(phoneNumber);
 427                 }
 428                 else
 429                 {
 430                         //LogDebug("Platform contact have a empty phone number");
 431                         continue;
 432                 }
 433
 434                 boolValue = contacts_svc_value_get_bool(static_cast<CTSvalue*>(numberList->data), CTS_NUM_VAL_DEFAULT_BOOL);
 435                 if(boolValue)
 436                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_PREF);
 437
 438                 intValue = contacts_svc_value_get_int(static_cast<CTSvalue*>(numberList->data), CTS_NUM_VAL_TYPE_INT);
 439                 if(intValue & CTS_NUM_TYPE_HOME)
 440                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_HOME);
 441                 if(intValue & CTS_NUM_TYPE_WORK)
 442                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_WORK);
 443                 if(intValue & CTS_NUM_TYPE_VOICE)
 444                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_VOICE);
 445                 if(intValue & CTS_NUM_TYPE_FAX)
 446                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_FAX);
 447                 if(intValue & CTS_NUM_TYPE_MSG)
 448                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_MSG);
 449                 if(intValue & CTS_NUM_TYPE_CELL)
 450                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_CELL);
 451                 if(intValue & CTS_NUM_TYPE_PAGER)
 452                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_PAGER);
 453                 if(intValue & CTS_NUM_TYPE_BBS)
 454                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_BBS);
 455                 if(intValue & CTS_NUM_TYPE_MODEM)
 456                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_MODEM);
 457                 if(intValue & CTS_NUM_TYPE_CAR)
 458                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_CAR);
 459                 if(intValue & CTS_NUM_TYPE_ISDN)
 460                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_ISDN);
 461                 if(intValue & CTS_NUM_TYPE_VIDEO)
 462                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_VIDEO);
 463                 if(intValue & CTS_NUM_TYPE_PCS)
 464                         phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_PCS);
 465
 466                 // TODO Will be added after type changed to string
 467 //              if(intValue & CTS_NUM_TYPE_CUSTOM)
 468 //              {
 469 //                      charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(numberList->data), CTS_NUMBER_VAL_LABEL_STR);
 470 //                      if (charValue)
 471 //                              phoneNumber->addType(CUSTOM);
 472 //              }
 473         }
 474 }
 475
 476 void ContactObjectP2AConverter::exportEmailList()
 477 {
 478         int errorCode = 0;
 479         GSList *emailList = NULL;
 480
 481         if(m_abstractContact->getEmailsNum() > 0)
 482                 m_abstractContact->clearEmails();
 483
 484         errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_EMAIL_LIST, &emailList);
 485         if(errorCode != CTS_SUCCESS && errorCode != CTS_ERR_NO_DATA)
 486                 ThrowMsg(UnknownException, "getting email list (err:" << errorCode << ")");
 487
 488         if(emailList == NULL || errorCode == CTS_ERR_NO_DATA)
 489         {
 490                 //LogDebug("Platform contact don't have email list");
 491                 return;
 492         }
 493
 494         ContactEmailAddressArrayPtr emails = m_abstractContact->getEmails();
 495
 496         for (; emailList; emailList = g_slist_next(emailList))
 497         {
 498                 ContactEmailAddressPtr email(new ContactEmailAddress());
 499
 500                 const char *charValue = NULL;
 501                 bool boolValue = false;
 502                 int intValue = 0;
 503
 504                 boolValue = contacts_svc_value_get_bool(static_cast<CTSvalue*>(emailList->data), CTS_EMAIL_VAL_DELETE_BOOL);
 505                 if(boolValue)
 506                 {
 507                         //LogDebug("Platform contact have a email address to be deleted");
 508                         continue;
 509                 }
 510
 511                 charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(emailList->data), CTS_EMAIL_VAL_ADDR_STR);
 512                 if (charValue)
 513                 {
 514                         email->setEmail(charValue);
 515                         emails->push_back(email);
 516                 }
 517                 else
 518                 {
 519                         //LogDebug("Platform contact have a empty email address");
 520                         continue;
 521                 }
 522
 523                 boolValue = contacts_svc_value_get_bool(static_cast<CTSvalue*>(emailList->data), CTS_EMAIL_VAL_DEFAULT_BOOL);
 524                 if(boolValue)
 525                         email->addType(CONTACT_EMAIL_TYPE_PREF);
 526
 527                 intValue = contacts_svc_value_get_int(static_cast<CTSvalue*>(emailList->data), CTS_EMAIL_VAL_TYPE_INT);
 528                 if(intValue & CTS_EMAIL_TYPE_HOME)
 529                         email->addType(CONTACT_EMAIL_TYPE_HOME);
 530                 if(intValue & CTS_EMAIL_TYPE_WORK)
 531                         email->addType(CONTACT_EMAIL_TYPE_WORK);
 532
 533                 // TODO Will be added after type changed to string
 534 //              if(intValue & CTS_EMAIL_TYPE_CUSTOM)
 535 //              {
 536 //                      charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(emailList->data), CTS_EMAIL_VAL_LABEL_STR);
 537 //                      if (charValue)
 538 //                              email->addType(CUSTOM);
 539 //              }
 540         }
 541 }
 542
 543 void ContactObjectP2AConverter::exportGrouprelList()
 544 {
 545         int errorCode = 0;
 546         GSList *groupList = NULL;
 547
 548         if(m_abstractContact->getCategoriesNum() > 0)
 549                 m_abstractContact->clearCategories();
 550
 551         errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_GROUPREL_LIST, &groupList);
 552         if(errorCode != CTS_SUCCESS && errorCode != CTS_ERR_NO_DATA)
 553                 ThrowMsg(UnknownException, "getting group list (err:" << errorCode << ")");
 554
 555         if(groupList == NULL || errorCode == CTS_ERR_NO_DATA)
 556         {
 557                 //LogDebug("Platform contact don't have group list");
 558                 return;
 559         }
 560
 561         StringArrayPtr categories = m_abstractContact->getCategories();
 562
 563         for (; groupList; groupList = g_slist_next(groupList))
 564         {
 565                 const char *charValue = NULL;
 566                 bool boolValue = false;
 567
 568                 boolValue = contacts_svc_value_get_bool(static_cast<CTSvalue*>(groupList->data), CTS_GROUPREL_VAL_DELETE_BOOL);
 569                 if(boolValue)
 570                 {
 571                         //LogDebug("Platform contact have a group to be deleted");
 572                         continue;
 573                 }
 574
 575                 charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(groupList->data), CTS_GROUPREL_VAL_NAME_STR);
 576                 if (charValue)
 577                         categories->push_back(charValue);
 578         }
 579 }
 580
 581 void ContactObjectP2AConverter::exportEventList()
 582 {
 583         int errorCode = 0;
 584         GSList *eventList = NULL;
 585
 586         if(m_abstractContact->getAnniversariesNum() > 0)
 587                 m_abstractContact->clearAnniversaries();
 588
 589         if(m_abstractContact->getBirthdayIsSet())
 590                 m_abstractContact->unsetBirthday();
 591
 592         errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_EVENT_LIST, &eventList);
 593         if(errorCode != CTS_SUCCESS && errorCode != CTS_ERR_NO_DATA)
 594                 ThrowMsg(UnknownException, "getting event list (err:" << errorCode << ")");
 595
 596         if(eventList == NULL || errorCode == CTS_ERR_NO_DATA)
 597         {
 598                 //LogDebug("Platform contact don't have group list");
 599                 return;
 600         }
 601
 602         ContactAnniversaryArrayPtr anniversaries = m_abstractContact->getAnniversaries();
 603
 604         for (; eventList; eventList = g_slist_next(eventList))
 605         {
 606                 const char *charValue = NULL;
 607                 bool boolValue = false;
 608                 int intValueType = 0;
 609                 int intValueDate = 0;
 610
 611                 boolValue = contacts_svc_value_get_bool(static_cast<CTSvalue*>(eventList->data), CTS_GROUPREL_VAL_DELETE_BOOL);
 612                 if(boolValue)
 613                 {
 614                         //LogDebug("Platform contact have a event to be deleted");
 615                         continue;
 616                 }
 617
 618                 intValueDate = contacts_svc_value_get_int(static_cast<CTSvalue*>(eventList->data), CTS_EVENT_VAL_DATE_INT);
 619
 620                 struct tm tmDate = {0, };
 621
 622                 tmDate.tm_year = (intValueDate / 10000) - 1900;
 623                 tmDate.tm_mon = ((intValueDate - ((tmDate.tm_year + 1900) * 10000)) / 100) - 1;
 624                 tmDate.tm_mday = (intValueDate - ((tmDate.tm_year + 1900) * 10000) - tmDate.tm_mon * 100);
 625
 626                 intValueType = contacts_svc_value_get_int(static_cast<CTSvalue*>(eventList->data), CTS_EVENT_VAL_TYPE_INT);
 627                 if (intValueType == CTS_EVENT_TYPE_BIRTH)
 628                 {
 629                         m_abstractContact->setBirthday(tmDate);
 630                 }
 631                 else if(intValueType == CTS_EVENT_TYPE_ANNIVERSARY)
 632                 {
 633                         ContactAnniversaryPtr anniversary = ContactAnniversaryPtr(new ContactAnniversary());
 634
 635                         anniversary->setDate(tmDate);
 636                         anniversary->setLabel("Anniversary");
 637
 638                         anniversaries->push_back(anniversary);
 639                 }
 640 //              else if(intValueType == CTS_EVENT_TYPE_CUSTOM)
 641 //              {
 642 //                      ContactAnniversaryPtr anniversary = ContactAnniversaryPtr(new ContactAnniversary());
 643 //
 644 //                      anniversary->setDate(tmDate);
 645 //
 646 //                      charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(eventList->data), CTS_EVENT_VAL_LABEL_STR);
 647 //                      if(charValue)
 648 //                              anniversary->setLabel(charValue);
 649 //
 650 //                      anniversaries->push_back(anniversary);
 651 //              }
 652
 653                 // TODO Check the difference of CTS_EVENT_TYPE_CUSTOM and CTS_EVENT_TYPE_ANNIVERSARY
 654         }
 655 }
 656
 657 void ContactObjectP2AConverter::exportPostalList()
 658 {
 659         int errorCode = 0;
 660         GSList *addressList = NULL;
 661
 662         if(m_abstractContact->getAddressesNum() > 0)
 663                 m_abstractContact->clearAddresses();
 664
 665         errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_POSTAL_ADDR_LIST, &addressList);
 666         if(errorCode != CTS_SUCCESS && errorCode != CTS_ERR_NO_DATA)
 667                 ThrowMsg(UnknownException, "getting address list (err:" << errorCode << ")");
 668
 669         if(addressList == NULL || errorCode == CTS_ERR_NO_DATA)
 670         {
 671                 //LogDebug("Platform contact don't have address list");
 672                 return;
 673         }
 674
 675         ContactAddressArrayPtr addresss = m_abstractContact->getAddresses();
 676
 677         for (; addressList; addressList = g_slist_next(addressList))
 678         {
 679                 ContactAddressPtr address(new ContactAddress());
 680
 681                 const char *charValue = NULL;
 682                 bool boolValue = false;
 683                 int intValue = 0;
 684
 685                 boolValue = contacts_svc_value_get_bool(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_DELETE_BOOL);
 686                 if(boolValue)
 687                 {
 688                         //LogDebug("Platform contact have a address to be deleted");
 689                         continue;
 690                 }
 691
 692                 addresss->push_back(address);
 693
 694                 charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_POSTALCODE_STR);
 695                 if (charValue)
 696                         address->setPostalCode(charValue);
 697
 698                 charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_REGION_STR);
 699                 if (charValue)
 700                         address->setRegion(charValue);
 701
 702                 charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_LOCALITY_STR);
 703                 if (charValue)
 704                         address->setCity(charValue);
 705
 706                 charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_STREET_STR);
 707                 if (charValue)
 708                         address->setStreetAddress(charValue);
 709
 710                 charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_EXTENDED_STR);
 711                 if (charValue)
 712                         address->setAdditionalInformation(charValue);
 713
 714                 charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_COUNTRY_STR);
 715                 if (charValue)
 716                         address->setCountry(charValue);
 717
 718                 boolValue = contacts_svc_value_get_bool(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_DEFAULT_BOOL);
 719                 if(boolValue)
 720                         address->addType(CONTACT_ADDRESS_TYPE_PREF);
 721
 722                 intValue = contacts_svc_value_get_int(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_TYPE_INT);
 723                 if(intValue & CTS_ADDR_TYPE_HOME)
 724                         address->addType(CONTACT_ADDRESS_TYPE_HOME);
 725                 if(intValue & CTS_ADDR_TYPE_WORK)
 726                         address->addType(CONTACT_ADDRESS_TYPE_WORK);
 727
 728                 // TODO Will be added after type changed to string
 729 //              if(intValue & CTS_ADDR_TYPE_CUSTOM)
 730 //              {
 731 //                      charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_LABEL_STR);
 732 //                      if (charValue)
 733 //                              address->addType(CUSTOM);
 734 //              }
 735         }
 736 }
 737
 738 void ContactObjectP2AConverter::exportWebAddrList()
 739 {
 740         int errorCode = 0;
 741         GSList *webAddrList = NULL;
 742
 743         if(m_abstractContact->getUrlsNum() > 0)
 744                 m_abstractContact->clearUrls();
 745
 746         errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_WEB_ADDR_LIST, &webAddrList);
 747         if(errorCode != CTS_SUCCESS && errorCode != CTS_ERR_NO_DATA)
 748                 ThrowMsg(UnknownException, "getting address list (err:" << errorCode << ")");
 749
 750         if(webAddrList == NULL || errorCode == CTS_ERR_NO_DATA)
 751         {
 752                 //LogDebug("Platform contact don't have address list");
 753                 return;
 754         }
 755
 756         ContactWebSiteArrayPtr urls = m_abstractContact->getUrls();
 757
 758         for (; webAddrList; webAddrList = g_slist_next(webAddrList))
 759         {
 760                 ContactWebSitePtr url(new ContactWebSite());
 761
 762                 const char *charValue = NULL;
 763                 bool boolValue = false;
 764                 int intValue = 0;
 765
 766                 boolValue = contacts_svc_value_get_bool(static_cast<CTSvalue*>(webAddrList->data), CTS_WEB_VAL_DELETE_BOOL);
 767                 if(boolValue)
 768                 {
 769                         //LogDebug("Platform contact have a address to be deleted");
 770                         continue;
 771                 }
 772
 773                 urls->push_back(url);
 774
 775                 charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(webAddrList->data), CTS_WEB_VAL_ADDR_STR);
 776                 if (charValue)
 777                         url->setUrl(charValue);
 778
 779                 intValue = contacts_svc_value_get_int(static_cast<CTSvalue*>(webAddrList->data), CTS_WEB_VAL_TYPE_INT);
 780                 if(intValue == CTS_WEB_TYPE_HOME)
 781                         url->setType(WEBSITE_TYPE_HOMEPAGE);
 782                 if(intValue & CTS_WEB_TYPE_WORK)
 783                         url->setType(WEBSITE_TYPE_BLOG);
 784
 785                 // TODO Will be added after type changed to string
 786 //              if(intValue & CTS_WEB_TYPE_CUSTOM)
 787 //              {
 788 //                      charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(webAddrList->data), CTS_WEB_VAL_LABEL_STR);
 789 //                      if (charValue)
 790 //                              url->setType(CUSTOM);
 791 //              }
 792         }
 793 }
 794
 795 void ContactObjectP2AConverter::exportNicknameList()
 796 {
 797         int errorCode = 0;
 798         GSList *nicknameList = NULL;
 799
 800         ContactNamePtr contactName = m_abstractContact->getName();
 801         if(contactName == NULL)
 802         {
 803                 contactName = ContactNamePtr(new ContactName());
 804                 m_abstractContact->setName(contactName);
 805         }
 806
 807         if(contactName->getNicknamesNum() > 0)
 808                 contactName->clearNicknames();
 809
 810         errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_NICKNAME_LIST, &nicknameList);
 811         if(errorCode != CTS_SUCCESS && errorCode != CTS_ERR_NO_DATA)
 812                 ThrowMsg(UnknownException, "getting nickname list (err:" << errorCode << ")");
 813
 814         if(nicknameList == NULL || errorCode == CTS_ERR_NO_DATA)
 815         {
 816                 //LogDebug("Platform contact don't have nickname list");
 817                 return;
 818         }
 819
 820         StringArrayPtr nicknames = contactName->getNicknames();
 821
 822         for (; nicknameList; nicknameList = g_slist_next(nicknameList))
 823         {
 824                 const char *charValue = NULL;
 825                 bool boolValue = false;
 826
 827                 boolValue = contacts_svc_value_get_bool(static_cast<CTSvalue*>(nicknameList->data), CTS_NICKNAME_VAL_DELETE_BOOL);
 828                 if(boolValue)
 829                 {
 830                         //LogDebug("Platform contact have a nickname to be deleted");
 831                         continue;
 832                 }
 833
 834                 charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(nicknameList->data), CTS_NICKNAME_VAL_NAME_STR);
 835                 if (charValue)
 836                         nicknames->push_back(charValue);
 837         }
 838 }
 839
 840 } // Contact
 841 } // Platform
 842 } // TizenApis