src/platform/Tizen/Contact/ContactWrapper.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 /**
  18  * @file        ContactWrapper.cpp
  19  * @author      Lukasz Marek(l.marek@samsung.com)
  20  * @author      Yujie Zeng(yj.zengk@samsung.com)
  21  * @version     0.1
  22  * @brief
  23  */
  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 "ContactWrapper.h"
  31 #include "AddressBook.h"
  32 #include "Contact.h"
  33 #include "query-svc/query-service.h"
  34
  35 #define CONTACT_ATTRIBUTE_PHONETIC_NAME "phoneticName"
  36
  37 namespace TizenApis
  38 {
  39 namespace Platform
  40 {
  41 namespace Contact
  42 {
  43
  44 using namespace TizenApis::Api::Contact;
  45 using namespace WrtDeviceApis::Commons;
  46 using namespace std;
  47
  48 ContactWrapper::ContactWrapper(IAddressBook::AddressBookType type) :
  49                 m_abstractContact(NULL),
  50                 m_platformContact(NULL)
  51 {
  52         //platform layer seems to not support different storage types yet
  53         /*
  54         if ( type == IAddressBook::PhoneBook )
  55         {
  56         }
  57         else if ( type == IAddressBook::SIMBook )
  58         {
  59         }
  60         else
  61         {
  62                 LogError("invalid storage type");
  63         }
  64         */
  65 }
  66
  67 ContactWrapper::~ContactWrapper()
  68 {
  69         freePlatformObject();
  70 }
  71
  72 void ContactWrapper::freePlatformObject()
  73 {
  74         if (m_platformContact)
  75         {
  76                 contacts_svc_struct_free(m_platformContact);
  77                 m_platformContact = NULL;
  78         }
  79 }
  80
  81 void ContactWrapper::freeAbstractObject()
  82 {
  83         m_abstractContact = ContactPtr(NULL);
  84 }
  85
  86 ContactPtr ContactWrapper::getAbstractContact() const
  87 {
  88         return m_abstractContact;
  89 }
  90
  91 void ContactWrapper::setAbstractContact(const ContactPtr &contact, bool isConvertingVCard)
  92 {
  93         m_abstractContact = contact;
  94         convertToPlatformObject(isConvertingVCard);
  95 }
  96
  97 CTSstruct* ContactWrapper::getPlatformContact() const
  98 {
  99         return m_platformContact;
 100 }
 101
 102 void ContactWrapper::setPlatformContact(CTSstruct* contact)
 103 {
 104         freePlatformObject();
 105         m_platformContact = contact;
 106         convertToAbstractObject();
 107 }
 108
 109 bool ContactWrapper::convertToPlatformObject(bool isConvertingVCard)
 110 {
 111         LogDebug("entered");
 112
 113         freePlatformObject();
 114
 115         if (!m_abstractContact)
 116         {
 117                 LogError("abstract object is not set");
 118                 return false;
 119         }
 120
 121         //if abstrat object has id set then we have to read existing object and update it
 122         if (m_abstractContact->getIdIsSet() && (isConvertingVCard == false))
 123         {
 124                 LogDebug("reading existing contact");
 125                 contacts_svc_get_contact(atoi(m_abstractContact->getId().c_str()), &m_platformContact);
 126         }
 127         else // if no id is set then create new platform object
 128         {
 129                 LogDebug("creating new contact");
 130                 m_platformContact = contacts_svc_struct_new(CTS_STRUCT_CONTACT);
 131         }
 132
 133         if (!m_platformContact)
 134         {
 135                 LogError("contact structure not created properly");
 136                 return false;
 137         }
 138
 139         Try
 140         {
 141                 if (!convertToPlatformBaseData())
 142                         ThrowMsg(UnknownException, "error during converting base data");
 143
 144                 if (!convertToPlatformAddressObject())
 145                         ThrowMsg(UnknownException, "error during converting address object");
 146
 147                 if (!convertToPlatformEmailObject())
 148                         ThrowMsg(UnknownException, "error during converting email object");
 149
 150                 if (!convertToPlatformPhoneObject())
 151                         ThrowMsg(UnknownException, "error during converting phone object");
 152
 153                 if (!convertToPlatformNicknameObject())
 154                         ThrowMsg(UnknownException, "error during converting nickname object");
 155
 156                 if (!convertToPlatformPhoneticnameObject())
 157                         ThrowMsg(UnknownException, "error during converting Phoneticname object");
 158
 159                 if (!convertToPlatformGroupObject())
 160                         ThrowMsg(UnknownException, "error during converting group object");
 161
 162                 if (!convertToPlatformUrlObject())
 163                         ThrowMsg(UnknownException, "error during converting url object");
 164
 165                 if (!convertToPlatformOrganizationObject())
 166                         ThrowMsg(UnknownException, "error during converting organization object");
 167
 168                 if (!convertToPlatformAnniversaryObject())
 169                         ThrowMsg(UnknownException, "error during converting anniversary object");
 170
 171                 if (!convertToPlatformbirthdayObject())
 172                         ThrowMsg(UnknownException, "error during converting birthday object");
 173         }
 174         Catch (Exception)
 175         {
 176                 LogError("Error converting to platform object : " << _rethrown_exception.GetMessage());
 177
 178                 freePlatformObject();
 179
 180                 return false;
 181         }
 182
 183         return true;
 184 }
 185
 186 bool ContactWrapper::convertToAbstractObject()
 187 {
 188         LogDebug("entered");
 189
 190         freeAbstractObject();
 191
 192         if (!m_platformContact)
 193                 return false;
 194
 195         CTSvalue *value = NULL;
 196         //store id
 197         if (CTS_SUCCESS != contacts_svc_struct_get_value(m_platformContact, CTS_CF_BASE_INFO_VALUE, &value))
 198                 return false;
 199
 200         m_abstractContact = ContactPtr(new Contact());
 201         m_abstractContact->setId(contacts_svc_value_get_int(value, CTS_BASE_VAL_ID_INT));
 202
 203         const char *charValue;
 204
 205         charValue = contacts_svc_value_get_str(value, CTS_BASE_VAL_IMG_PATH_STR);
 206         if (charValue)
 207                 m_abstractContact->setPhotoURI(convertPathToUri(charValue));
 208
 209         charValue = contacts_svc_value_get_str(value, CTS_BASE_VAL_RINGTONE_PATH_STR);
 210         if (charValue)
 211                 m_abstractContact->setRingtoneURI(convertPathToUri(charValue));
 212
 213         charValue = contacts_svc_value_get_str(value, CTS_BASE_VAL_NOTE_STR);
 214         if (charValue)
 215         {
 216                 StringArrayPtr notes(new StringArray());
 217                 notes->push_back(charValue);
 218                 m_abstractContact->setNotes(notes);
 219         }
 220
 221         Try
 222         {
 223                 if (!convertToAbstractBaseData())
 224                         ThrowMsg(UnknownException, "error during converting base data");
 225
 226                 if (!convertToAbstractAddressObject())
 227                         ThrowMsg(UnknownException, "error during converting address object");
 228
 229                 if (!convertToAbstractEmailObject())
 230                         ThrowMsg(UnknownException, "error during converting email object");
 231
 232                 if (!convertToAbstractPhoneObject())
 233                         ThrowMsg(UnknownException, "error during converting phone object");
 234
 235                 if (!convertToAbstractNicknameObject())
 236                         ThrowMsg(UnknownException, "error during converting nickname object");
 237
 238                 if (!convertToAbstractPhoneticnameObject())
 239                         ThrowMsg(UnknownException, "error during converting phoneticName object");
 240
 241                 if (!convertToAbstractGroupObject())
 242                         ThrowMsg(UnknownException, "error during converting group object");
 243
 244                 if (!convertToAbstractUrlObject())
 245                         ThrowMsg(UnknownException, "error during converting url object");
 246
 247                 if (!convertToAbstractOrganizationObject())
 248                         ThrowMsg(UnknownException, "error during converting organization object");
 249
 250                 if (!convertToAbstractAnniversaryObject())
 251                         ThrowMsg(UnknownException, "error during converting anniversary object");
 252
 253                 if (!convertToAbstractBirthdayObject())
 254                         ThrowMsg(UnknownException, "error during converting birthday object");
 255         }
 256         Catch (Exception)
 257         {
 258                 LogError("Error converting to abstract object : " << _rethrown_exception.GetMessage());
 259                 freeAbstractObject();
 260
 261                 return false;
 262         }
 263
 264         return true;
 265 }
 266
 267 bool ContactWrapper::convertToAbstractBaseData()
 268 {
 269         if (NULL == m_abstractContact)
 270         {
 271                 LogError("you should create empty abstract contact object first");
 272                 return false;
 273         }
 274
 275         if (NULL == m_platformContact)
 276         {
 277                 LogError("you should provide platform contact object first");
 278                 return false;
 279         }
 280
 281         CTSvalue *value = NULL;
 282
 283         int errorCode;
 284         errorCode = contacts_svc_struct_get_value(m_platformContact, CTS_CF_NAME_VALUE, &value);
 285         if (CTS_SUCCESS == errorCode && value != NULL)
 286         {
 287                 const char *charValue = NULL;
 288                 ContactNamePtr contactName(new ContactName);
 289
 290                 charValue = contacts_svc_value_get_str(value, CTS_NAME_VAL_FIRST_STR);
 291                 if (charValue)
 292                         contactName->setFirstName(charValue);
 293
 294                 charValue = contacts_svc_value_get_str(value, CTS_NAME_VAL_ADDITION_STR);
 295                 if (charValue)
 296                         contactName->setMiddleName(charValue);
 297
 298                 charValue = contacts_svc_value_get_str(value, CTS_NAME_VAL_LAST_STR);
 299                 if (charValue)
 300                         contactName->setLastName(charValue);
 301
 302                 charValue = contacts_svc_value_get_str(value, CTS_NAME_VAL_DISPLAY_STR);
 303                 if (charValue)
 304                         contactName->setDisplayName(charValue);
 305
 306                 charValue = contacts_svc_value_get_str(value, CTS_NAME_VAL_PREFIX_STR);
 307                 if (charValue)
 308                         contactName->setPrefix(charValue);
 309
 310                 //charValue = contacts_svc_value_get_str(value, CTS_NAME_VAL_SUFFIX_STR);
 311                 //if (charValue)
 312                 //      contactName->setPhoneticName(charValue);
 313
 314                 m_abstractContact->setName(contactName);
 315         }
 316         else if (errorCode != CTS_ERR_NO_DATA || value == NULL)
 317         {
 318                 return false;
 319         }
 320
 321 //      errorCode = contacts_svc_struct_get_value(m_platformContact, CTS_CF_BASE_INFO_VALUE, &value);
 322 //      if (CTS_SUCCESS == errorCode && value != NULL)
 323 //      {
 324 //              const char *charValue = NULL;
 325 //
 326 //              charValue = contacts_svc_value_get_str(value, CTS_BASE_VAL_IMG_PATH_STR);
 327 //              if (charValue)
 328 //                      m_abstractContact->setPhotoURI(convertPathToUri(charValue));
 329 //
 330 //              charValue = contacts_svc_value_get_str(value, CTS_BASE_VAL_RINGTONE_PATH_STR);
 331 //              if (charValue)
 332 //                      m_abstractContact->setRingtoneURI(convertPathToUri(charValue));
 333 //
 334 //              bool boolValue = contacts_svc_value_get_bool(value, CTS_BASE_VAL_FAVORITE_BOOL);
 335 //              if (boolValue)
 336 //                      m_abstractContact->setIsFavorite(boolValue);
 337 //
 338 //              charValue = contacts_svc_value_get_str(value, CTS_BASE_VAL_NOTE_STR);
 339 //              if (charValue)
 340 //                      m_abstractContact->addNote(charValue);
 341 //      }
 342 //      else if (errorCode != CTS_ERR_NO_DATA || value == NULL)
 343 //      {
 344 //              return false;
 345 //      }
 346
 347         return true;
 348 }
 349
 350 bool ContactWrapper::convertToAbstractAddressObject()
 351 {
 352         if (NULL == m_abstractContact)
 353         {
 354                 LogError("you should create empty abstract contact object first");
 355                 return false;
 356         }
 357
 358         if (NULL == m_platformContact)
 359         {
 360                 LogError("you should provide platform contact object first");
 361                 return false;
 362         }
 363
 364         ContactAddressArrayPtr addresses = ContactAddressArrayPtr(new ContactAddressArray());
 365
 366         GSList *addressList = NULL;
 367         int errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_POSTAL_ADDR_LIST, &addressList);
 368         if (CTS_SUCCESS == errorCode)
 369         {
 370                 for (; addressList; addressList = g_slist_next(addressList))
 371                 {
 372                         ContactAddressPtr address(new ContactAddress());
 373                         addresses->push_back(address);
 374
 375                         int type = contacts_svc_value_get_int(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_TYPE_INT);
 376                         if(type & CTS_ADDR_TYPE_POSTAL) // TODO to be checked
 377                                 address->addType(CONTACT_ADDRESS_TYPE_PREF);
 378                         if(type & CTS_ADDR_TYPE_HOME)
 379                                 address->addType(CONTACT_ADDRESS_TYPE_HOME);
 380                         if(type & CTS_ADDR_TYPE_WORK)
 381                                 address->addType(CONTACT_ADDRESS_TYPE_WORK);
 382
 383                         const char *charValue = NULL;
 384
 385                         charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_COUNTRY_STR);
 386                         if (charValue)
 387                                 address->setCountry(charValue);
 388
 389                         charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_REGION_STR);
 390                         if (charValue)
 391                                 address->setRegion(charValue);
 392
 393                         charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_LOCALITY_STR);
 394                         if (charValue)
 395                                 address->setCity(charValue);
 396
 397                         charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_STREET_STR);
 398                         if (charValue)
 399                                 address->setStreetAddress(charValue);
 400
 401                         charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_POSTALCODE_STR);
 402                         if (charValue)
 403                                 address->setPostalCode(charValue);
 404
 405                         charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_EXTENDED_STR);
 406                         if (charValue)
 407                                 address->setAdditionalInformation(charValue);
 408
 409                 }
 410         }
 411         else if (errorCode != CTS_ERR_NO_DATA)
 412         {
 413                 return false;
 414         }
 415
 416         m_abstractContact->setAddresses(addresses);
 417
 418         return true;
 419 }
 420
 421 bool ContactWrapper::convertToAbstractUrlObject()
 422 {
 423         if (NULL == m_abstractContact)
 424         {
 425                 LogError("you should create empty abstract contact object first");
 426                 return false;
 427         }
 428
 429         if (NULL == m_platformContact)
 430         {
 431                 LogError("you should provide platform contact object first");
 432                 return false;
 433         }
 434
 435         ContactWebSiteArrayPtr urls = ContactWebSiteArrayPtr(new ContactWebSiteArray());
 436
 437         GSList *urlList = NULL;
 438         int errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_WEB_ADDR_LIST, &urlList);
 439         if (CTS_SUCCESS == errorCode)
 440         {
 441                 for (; urlList; urlList = g_slist_next(urlList))
 442                 {
 443                         ContactWebSitePtr url(new ContactWebSite());
 444                         urls->push_back(url);
 445
 446                         int type = contacts_svc_value_get_int(static_cast<CTSvalue*>(urlList->data), CTS_WEB_VAL_TYPE_INT);
 447                         switch (type)
 448                         {
 449                         case CTS_WEB_TYPE_NONE:
 450                                 url->setType(WEBSITE_TYPE_HOMEPAGE);
 451                                 break;
 452                         case CTS_WEB_TYPE_HOME:
 453                                 url->setType(WEBSITE_TYPE_HOMEPAGE);
 454                                 break;
 455                         case CTS_WEB_TYPE_WORK:
 456                                 url->setType(WEBSITE_TYPE_BLOG);
 457                                 break;
 458                         default:
 459                                 LogError("invalid url type");
 460                                 url->setType(WEBSITE_TYPE_HOMEPAGE);
 461                                 break;
 462                         }
 463
 464                         const char *charValue = NULL;
 465
 466                         charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(urlList->data), CTS_WEB_VAL_ADDR_STR);
 467                         if (charValue)
 468                                 url->setUrl(charValue);
 469
 470                 }
 471         }
 472         else if (errorCode != CTS_ERR_NO_DATA)
 473         {
 474                 return false;
 475         }
 476
 477         m_abstractContact->setUrls(urls);
 478
 479         return true;
 480 }
 481
 482 bool ContactWrapper::convertToAbstractOrganizationObject()
 483 {
 484         if (NULL == m_abstractContact)
 485         {
 486                 LogError("you should create empty abstract contact object first");
 487                 return false;
 488         }
 489
 490         if (NULL == m_platformContact)
 491         {
 492                 LogError("you should provide platform contact object first");
 493                 return false;
 494         }
 495
 496         CTSvalue *value = NULL;
 497         int errorCode;
 498
 499         ContactOrganizationPtr organization(new ContactOrganization());
 500
 501         errorCode = contacts_svc_struct_get_value(m_platformContact, CTS_CF_COMPANY_VALUE, &value);
 502         if (CTS_SUCCESS == errorCode)
 503         {
 504                 const char *charValue = NULL;
 505
 506                 charValue = contacts_svc_value_get_str(value, CTS_COMPANY_VAL_NAME_STR);
 507                 if (charValue)
 508                         organization->setName(charValue);
 509
 510                 charValue = contacts_svc_value_get_str(value, CTS_COMPANY_VAL_DEPARTMENT_STR);
 511                 if (charValue)
 512                         organization->setDepartment(charValue);
 513
 514                 charValue = contacts_svc_value_get_str(value, CTS_COMPANY_VAL_JOB_TITLE_STR);
 515                 if (charValue)
 516                         organization->setTitle(charValue);
 517
 518                 charValue = contacts_svc_value_get_str(value, CTS_COMPANY_VAL_ROLE_STR);
 519                 if (charValue)
 520                         organization->setRole(charValue);
 521
 522         }
 523         else if (errorCode != CTS_ERR_NO_DATA)
 524         {
 525                 return false;
 526         }
 527
 528         m_abstractContact->setOrganization(organization);
 529
 530         return true;
 531 }
 532
 533 bool ContactWrapper::convertToAbstractAnniversaryObject()
 534 {
 535         if (NULL == m_abstractContact)
 536         {
 537                 LogError("you should create empty abstract contact object first");
 538                 return false;
 539         }
 540
 541         if (NULL == m_platformContact)
 542         {
 543                 LogError("you should provide platform contact object first");
 544                 return false;
 545         }
 546
 547         ContactAnniversaryArrayPtr anniversaries(new ContactAnniversaryArray());
 548
 549         GSList *eventList = NULL;
 550         int errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_EVENT_LIST, &eventList);
 551         if (CTS_SUCCESS == errorCode)
 552         {
 553                 for (; eventList; eventList = g_slist_next(eventList))
 554                 {
 555                         int type = contacts_svc_value_get_int(static_cast<CTSvalue*>(eventList->data), CTS_EVENT_VAL_TYPE_INT);
 556                         int db_date = contacts_svc_value_get_int(static_cast<CTSvalue*>(eventList->data), CTS_EVENT_VAL_DATE_INT);
 557
 558                         if (type == CTS_EVENT_TYPE_ANNIVERSARY)
 559                         {
 560                                 ContactAnniversaryPtr anniversary = ContactAnniversaryPtr(new ContactAnniversary());
 561
 562                                 tm tm_date;
 563
 564                                 tm_date.tm_year = (db_date / 10000) - 1900;
 565                                 tm_date.tm_mon = ((db_date - ((tm_date.tm_year + 1900) * 10000)) / 100) - 1;
 566                                 tm_date.tm_mday = (db_date - ((tm_date.tm_year + 1900) * 10000) - tm_date.tm_mon * 100);
 567
 568                                 anniversary->setDate(tm_date);
 569
 570                                 //if (type)
 571                                 //      anniv->setLabel(string("ANNIVERSARY"));
 572
 573                                 anniversaries->push_back(anniversary);
 574                         }
 575                 }
 576         }
 577         else if (errorCode != CTS_ERR_NO_DATA)
 578         {
 579                 return false;
 580         }
 581
 582         m_abstractContact->setAnniversaries(anniversaries);
 583
 584         return true;
 585 }
 586
 587 bool ContactWrapper::convertToAbstractBirthdayObject()
 588 {
 589         if (NULL == m_abstractContact)
 590         {
 591                 LogError("you should create empty abstract contact object first");
 592                 return false;
 593         }
 594
 595         if (NULL == m_platformContact)
 596         {
 597                 LogError("you should provide platform contact object first");
 598                 return false;
 599         }
 600
 601         GSList *eventList = NULL;
 602         int errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_EVENT_LIST, &eventList);
 603         if (CTS_SUCCESS == errorCode)
 604         {
 605                 for (; eventList; eventList = g_slist_next(eventList))
 606                 {
 607                         int type = contacts_svc_value_get_int(static_cast<CTSvalue*>(eventList->data), CTS_EVENT_VAL_TYPE_INT);
 608                         int db_date = contacts_svc_value_get_int(static_cast<CTSvalue*>(eventList->data), CTS_EVENT_VAL_DATE_INT);
 609
 610                         if (type == CTS_EVENT_TYPE_BIRTH)
 611                         {
 612                                 tm tm_date;
 613
 614                                 tm_date.tm_year = (db_date / 10000) - 1900;
 615                                 tm_date.tm_mon = ((db_date - ((tm_date.tm_year + 1900) * 10000)) / 100) - 1;
 616                                 tm_date.tm_mday = (db_date - ((tm_date.tm_year + 1900) * 10000) - tm_date.tm_mon * 100);
 617
 618                                 m_abstractContact->setBirthday(tm_date);
 619                                 break;
 620                         }
 621                 }
 622         }
 623         else if (errorCode != CTS_ERR_NO_DATA)
 624         {
 625                 return false;
 626         }
 627
 628         return true;
 629 }
 630
 631 bool ContactWrapper::convertToAbstractEmailObject()
 632 {
 633         if (NULL == m_abstractContact)
 634         {
 635                 LogError("you should create empty abstract contact object first");
 636                 return false;
 637         }
 638
 639         if (NULL == m_platformContact)
 640         {
 641                 LogError("you should provide platform contact object first");
 642                 return false;
 643         }
 644
 645         ContactEmailAddressArrayPtr emailAddresses(new ContactEmailAddressArray());
 646
 647         GSList *emailList = NULL;
 648         int errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_EMAIL_LIST, &emailList);
 649         if (CTS_SUCCESS == errorCode)
 650         {
 651                 for (; emailList; emailList = g_slist_next(emailList))
 652                 {
 653                         ContactEmailAddressPtr email(new ContactEmailAddress());
 654
 655                         emailAddresses->push_back(email);
 656
 657                         int type = contacts_svc_value_get_int(static_cast<CTSvalue*>(emailList->data), CTS_EMAIL_VAL_TYPE_INT);
 658
 659                         if(type | CTS_EMAIL_TYPE_NONE)
 660                                 email->addType(CONTACT_EMAIL_TYPE_PREF);
 661                         if(type | CTS_EMAIL_TYPE_HOME)
 662                                 email->addType(CONTACT_EMAIL_TYPE_HOME);
 663                         if(type | CTS_EMAIL_TYPE_WORK)
 664                                 email->addType(CONTACT_EMAIL_TYPE_WORK);
 665
 666                         const char *charValue = NULL;
 667
 668                         charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(emailList->data), CTS_EMAIL_VAL_ADDR_STR);
 669                         if (charValue)
 670                                 email->setEmail(charValue);
 671                 }
 672         }
 673         else if (errorCode != CTS_ERR_NO_DATA)
 674         {
 675                 return false;
 676         }
 677
 678         m_abstractContact->setEmails(emailAddresses);
 679
 680         return true;
 681 }
 682
 683 bool ContactWrapper::convertToAbstractPhoneObject()
 684 {
 685         if (NULL == m_abstractContact)
 686         {
 687                 LogError("you should create empty abstract contact object first");
 688                 return false;
 689         }
 690
 691         if (NULL == m_platformContact)
 692         {
 693                 LogError("you should provide platform contact object first");
 694                 return false;
 695         }
 696
 697         ContactPhoneNumberArrayPtr phoneNumbers(new ContactPhoneNumberArray());
 698
 699         GSList *phoneList = NULL;
 700         int errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_NUMBER_LIST, &phoneList);
 701         if (CTS_SUCCESS == errorCode)
 702         {
 703                 for (; phoneList; phoneList = g_slist_next(phoneList))
 704                 {
 705                         ContactPhoneNumberPtr phoneNumber(new ContactPhoneNumber());
 706                         phoneNumbers->push_back(phoneNumber);
 707
 708                         int type = contacts_svc_value_get_int(static_cast<CTSvalue*>(phoneList->data), CTS_NUM_VAL_TYPE_INT);
 709                         if(type & CTS_NUM_TYPE_WORK)
 710                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_WORK);
 711                         if(type & CTS_NUM_TYPE_NONE)
 712                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_PREF);
 713                         if(type & CTS_NUM_TYPE_HOME)
 714                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_HOME);
 715                         if(type & CTS_NUM_TYPE_FAX)
 716                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_FAX);
 717                         if(type & CTS_NUM_TYPE_CELL)
 718                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_CELL);
 719                         if(type & CTS_NUM_TYPE_PAGER)
 720                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_PAGER);
 721                         if(type & CTS_NUM_TYPE_CAR)
 722                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_CAR);
 723                         if(type & CTS_NUM_TYPE_VOICE)
 724                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_VOICE);
 725                         if(type & CTS_NUM_TYPE_MSG)
 726                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_MSG);
 727                         if(type & CTS_NUM_TYPE_BBS)
 728                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_BBS);
 729                         if(type & CTS_NUM_TYPE_ISDN)
 730                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_ISDN);
 731                         if(type & CTS_NUM_TYPE_VIDEO)
 732                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_VIDEO);
 733                         if(type & CTS_NUM_TYPE_PCS)
 734                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_PCS);
 735                         if(type & CTS_NUM_TYPE_WORK)
 736                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_WORK);
 737                         if(type & CTS_NUM_TYPE_WORK)
 738                                 phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_WORK);
 739
 740                         const char *charValue = NULL;
 741
 742                         charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(phoneList->data), CTS_NUM_VAL_NUMBER_STR);
 743                         if (charValue)
 744                                 phoneNumber->setNumber(charValue);
 745                 }
 746         }
 747         else if (errorCode != CTS_ERR_NO_DATA)
 748         {
 749                 return false;
 750         }
 751
 752         m_abstractContact->setPhoneNumbers(phoneNumbers);
 753
 754         return true;
 755 }
 756
 757 bool ContactWrapper::convertToAbstractNicknameObject()
 758 {
 759         if (NULL == m_abstractContact)
 760         {
 761                 LogError("you should create empty abstract contact object first");
 762                 return false;
 763         }
 764
 765         if (NULL == m_platformContact)
 766         {
 767                 LogError("you should provide platform contact object first");
 768                 return false;
 769         }
 770
 771         StringArrayPtr nickNames(new StringArray());
 772
 773         GSList *nicknNameList = NULL;
 774         int errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_NICKNAME_LIST, &nicknNameList);
 775         if (CTS_SUCCESS == errorCode)
 776         {
 777                 for (; nicknNameList; nicknNameList = g_slist_next(nicknNameList))
 778                 {
 779                         const char *charValue = NULL;
 780                         charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(nicknNameList->data), CTS_NICKNAME_VAL_NAME_STR);
 781                         if (charValue)
 782                                 nickNames->push_back(charValue);
 783                 }
 784         }
 785         else if (errorCode != CTS_ERR_NO_DATA)
 786         {
 787                 return false;
 788         }
 789
 790         m_abstractContact->getName()->setNicknames(nickNames);
 791
 792         return true;
 793 }
 794
 795 bool ContactWrapper::convertToAbstractPhoneticnameObject()
 796 {
 797         if (NULL == m_abstractContact)
 798         {
 799                 LogError("you should create empty abstract contact object first");
 800                 return false;
 801         }
 802
 803         if (NULL == m_platformContact)
 804         {
 805                 LogError("you should provide platform contact object first");
 806                 return false;
 807         }
 808
 809         int structFieldType = 0;
 810         structFieldType = getCustomTypeInContactsSvc(CONTACT_ATTRIBUTE_PHONETIC_NAME);
 811         if (structFieldType < CTS_SUCCESS)
 812         {
 813                 LogError("Phonetic name struct type is not found!!");
 814                 return false;
 815         }
 816
 817         CTSvalue *value = NULL;
 818         int errorCode;
 819         errorCode = contacts_svc_struct_get_value(m_platformContact, static_cast<cts_struct_field>(structFieldType), &value);
 820         if (CTS_SUCCESS == errorCode)
 821         {
 822                 if (value)
 823                 {
 824                         const char *charValue = NULL;
 825                         charValue = contacts_svc_value_get_str(value, CTS_EXTEND_VAL_DATA2_STR);
 826                         if (charValue)
 827                                 m_abstractContact->getName()->setPhoneticName(charValue);
 828                 }
 829                 else
 830                 {
 831                         return false;
 832                 }
 833         }
 834         else if (errorCode != CTS_ERR_NO_DATA)
 835         {
 836                 return false;
 837         }
 838
 839         return true;
 840 }
 841
 842 bool ContactWrapper::convertToAbstractGroupObject()
 843 {
 844         if (NULL == m_abstractContact)
 845         {
 846                 LogError("you should create empty abstract contact object first");
 847                 return false;
 848         }
 849
 850         if (NULL == m_platformContact)
 851         {
 852                 LogError("you should provide platform contact object first");
 853                 return false;
 854         }
 855
 856         StringArrayPtr categories(new StringArray());
 857
 858         GSList *groupList = NULL;
 859         int errorCode = contacts_svc_struct_get_list(m_platformContact, CTS_CF_GROUPREL_LIST, &groupList);
 860         if (CTS_SUCCESS == errorCode)
 861         {
 862                 for (; groupList; groupList = g_slist_next(groupList))
 863                 {
 864                         const char *charValue = NULL;
 865                         charValue = contacts_svc_value_get_str(static_cast<CTSvalue*>(groupList->data), CTS_GROUPREL_VAL_NAME_STR);
 866                         if (charValue)
 867                                 categories->push_back(charValue);
 868                 }
 869         }
 870         else if (errorCode != CTS_ERR_NO_DATA)
 871         {
 872                 return false;
 873         }
 874
 875         m_abstractContact->setCategories(categories);
 876
 877         return true;
 878 }
 879
 880 bool ContactWrapper::convertToPlatformNicknameObject()
 881 {
 882         if (NULL == m_abstractContact)
 883         {
 884                 LogError("you should create empty abstract contact object first");
 885                 return false;
 886         }
 887
 888         if (NULL == m_platformContact)
 889         {
 890                 LogError("you should provide platform contact object first");
 891                 return false;
 892         }
 893
 894         StringArrayPtr nicknames = m_abstractContact->getName()->getNicknames();
 895
 896         bool properlyCreated = true;
 897
 898         GSList *nicknameList = NULL;
 899         if (CTS_SUCCESS == contacts_svc_struct_get_list(m_platformContact, CTS_CF_NICKNAME_LIST, &nicknameList))
 900         {
 901                 GSList *nicknameListSave = nicknameList;
 902                 for (; nicknameList; nicknameList = g_slist_next(nicknameList))
 903                 {
 904                         CTSvalue* nickname = static_cast<CTSvalue*>(nicknameList->data);
 905                         contacts_svc_value_set_bool(nickname, CTS_NICKNAME_VAL_DELETE_BOOL, true);
 906                 }
 907                 nicknameList = nicknameListSave;
 908         }
 909
 910         if (nicknames->size() == 0 && nicknameList == NULL)
 911                 return true;
 912
 913         //add new items
 914         for (size_t i = 0; i < nicknames->size(); ++i)
 915         {
 916                 CTSvalue *nickname = NULL;
 917                 nickname = contacts_svc_value_new(CTS_VALUE_NICKNAME);
 918                 if (nickname)
 919                 {
 920                         if (CTS_SUCCESS == contacts_svc_value_set_str(nickname, CTS_NICKNAME_VAL_NAME_STR, nicknames->at(i).c_str()))
 921                         {
 922                                 nicknameList = g_slist_append(nicknameList, nickname);
 923                         }
 924                         else
 925                         {
 926                                 contacts_svc_value_free(nickname);
 927                                 properlyCreated = false;
 928                                 break;
 929                         }
 930                 }
 931                 else
 932                 {
 933                         properlyCreated = false;
 934                         break;
 935                 }
 936         }
 937
 938         if (properlyCreated)
 939         {
 940                 if (CTS_SUCCESS != contacts_svc_struct_store_list(m_platformContact, CTS_CF_NICKNAME_LIST, nicknameList))
 941                 {
 942                         properlyCreated = false;
 943                 }
 944         }
 945
 946         return properlyCreated;
 947 }
 948
 949 bool ContactWrapper::convertToPlatformPhoneticnameObject()
 950 {
 951         if (NULL == m_abstractContact)
 952         {
 953                 LogError("you should create empty abstract contact object first");
 954                 return false;
 955         }
 956
 957         if (NULL == m_platformContact)
 958         {
 959                 LogError("you should provide platform contact object first");
 960                 return false;
 961         }
 962
 963         int structFieldType = 0;
 964         structFieldType = getCustomTypeInContactsSvc(CONTACT_ATTRIBUTE_PHONETIC_NAME);
 965         if (structFieldType < CTS_SUCCESS)
 966         {
 967                 LogError("Phonetic name struct type is not found!!");
 968                 return false;
 969         }
 970
 971         /**
 972          *If phonetic name information is not existed, add phonetic name information
 973          *If phonetic name information is existed,update phonetic name information
 974          */
 975         CTSvalue *value = NULL;
 976         if (CTS_SUCCESS != contacts_svc_struct_get_value(m_platformContact, static_cast<cts_struct_field>(structFieldType), &value))
 977         {
 978                 value = contacts_svc_value_new(CTS_VALUE_EXTEND);
 979                 if (!value)
 980                         return false;
 981
 982         }
 983
 984         if (CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_EXTEND_VAL_DATA2_STR, m_abstractContact->getName()->getPhoneticName().c_str())
 985                         || CTS_SUCCESS != contacts_svc_struct_store_value(m_platformContact, static_cast<cts_struct_field>(structFieldType), value))
 986         {
 987                 contacts_svc_value_free(value);
 988                 return false;
 989         }
 990
 991         contacts_svc_value_free(value);
 992
 993 //      LogDebug("RETURN TRUE!!!");
 994         return true;
 995 }
 996
 997 bool ContactWrapper::convertToPlatformGroupObject()
 998 {
 999 //      LogDebug("entered");
1000         if (NULL == m_abstractContact)
1001         {
1002                 LogError("you should create empty abstract contact object first");
1003                 return false;
1004         }
1005
1006         if (NULL == m_platformContact)
1007         {
1008                 LogError("you should provide platform contact object first");
1009                 return false;
1010         }
1011
1012         StringArrayPtr groups = m_abstractContact->getCategories();
1013         CTSvalue *group = NULL;
1014         bool properlyCreated = true;
1015         GSList *groupList = NULL;
1016         //mark existing items to delete them.
1017         if (CTS_SUCCESS == contacts_svc_struct_get_list(m_platformContact, CTS_CF_GROUPREL_LIST, &groupList))
1018         {
1019                 GSList *groupListSave = groupList;
1020                 for (; groupList; groupList = g_slist_next(groupList))
1021                 {
1022 //                      LogDebug("clearing group list");
1023                         CTSvalue* delgroup = static_cast<CTSvalue*>(groupList->data);
1024                         contacts_svc_value_set_bool(delgroup, CTS_GROUPREL_VAL_DELETE_BOOL, true);
1025                 }
1026                 groupList = groupListSave;
1027         }
1028         if (groups->size() == 0 && groupList == NULL
1029                 )
1030                 return true;
1031
1032         //add new items
1033         query_error error_code = QUERY_SUCCESS;
1034         GSList *groups_list = NULL;
1035         int accountId;
1036
1037         try {
1038                 string accountIdStr = m_abstractContact->getAccount()->getAccountServiceId();
1039                 stringstream ss(accountIdStr);
1040                 ss >> accountId;
1041         } catch (...) {
1042                 LogError("Wrong account id");
1043                 return false;
1044         }
1045
1046         int addressBookId = find_addressbook_id(accountId, &error_code);
1047         if (error_code != QUERY_SUCCESS)
1048                 addressBookId = 0;
1049
1050         CTSiter* group_iter;
1051         bool is_new_group = true;
1052
1053         for (size_t i = 0; i < groups->size(); ++i)
1054         {
1055                 if (CTS_SUCCESS == contacts_svc_get_list(CTS_LIST_ALL_GROUP, &group_iter))
1056                 {
1057                         while (CTS_SUCCESS == contacts_svc_iter_next(group_iter))
1058                         {
1059                                 CTSvalue *findgroup = contacts_svc_iter_get_info(group_iter);
1060                                 if (findgroup)
1061                                 {
1062                                         group_info_t* group_info = g_new0(group_info_t, 1);
1063
1064                                         group_info->group_name = g_strdup(contacts_svc_value_get_str(findgroup, CTS_LIST_GROUP_NAME_STR));
1065                                         group_info->addressbook_id = contacts_svc_value_get_int(findgroup, CTS_GROUP_VAL_ADDRESSBOOK_ID_INT);
1066                                         group_info->group_id = contacts_svc_value_get_int(findgroup, CTS_GROUP_VAL_ID_INT);
1067                                         groups_list = g_slist_append(groups_list, group_info);
1068                                 }
1069                         }
1070                 }
1071
1072                 group = contacts_svc_value_new(CTS_VALUE_GROUP_RELATION);
1073                 if (group)
1074                 {
1075                         int groupId = -1;
1076                         //groupId = AddressBook::getGroupId(groups[i]);
1077
1078                         is_new_group = true;
1079                         GSList* tmp_list = groups_list;
1080                         while (tmp_list)
1081                         {
1082                                 group_info_t* info = (group_info_t*) tmp_list->data;
1083
1084                                 if ((info->group_name != NULL) && (groups->at(i).compare(info->group_name) == 0)
1085                                                 && (info->addressbook_id == addressBookId))
1086                                 {
1087                                         is_new_group = false;
1088                                         groupId = info->group_id;
1089                                 }
1090                                 if (info->group_name)
1091                                         free(info->group_name);
1092                                 free(info);
1093                                 tmp_list = g_slist_next(tmp_list);
1094                         }
1095                         g_slist_free(groups_list);
1096                         groups_list = NULL;
1097
1098                         if (is_new_group)
1099                         {
1100                                 CTSvalue *new_group;
1101                                 new_group = contacts_svc_value_new(CTS_VALUE_GROUP);
1102
1103                                 contacts_svc_value_set_str(new_group, CTS_GROUP_VAL_NAME_STR, (const char*) (groups->at(i).c_str()));
1104                                 contacts_svc_value_set_int(new_group, CTS_GROUP_VAL_ADDRESSBOOK_ID_INT, addressBookId);
1105                                 groupId = contacts_svc_insert_group(addressBookId, new_group);
1106                                 if (groupId < 0)
1107                                         return false;
1108                                 contacts_svc_value_free(new_group);
1109                         }
1110 //                      LogDebug("group id " << groupId);
1111                         if (groupId != -1)
1112                         {
1113                                 if (CTS_SUCCESS == contacts_svc_value_set_int(group, CTS_GROUPREL_VAL_ID_INT, groupId))
1114                                 {
1115                                         groupList = g_slist_append(groupList, group);
1116                                 }
1117                                 else
1118                                 {
1119                                         contacts_svc_value_free(group);
1120                                         properlyCreated = false;
1121                                         break;
1122                                 }
1123                         }
1124                         else
1125                         {
1126                                 contacts_svc_value_free(group);
1127                                 properlyCreated = false;
1128                                 break;
1129                         }
1130                 }
1131                 else
1132                 {
1133                         properlyCreated = false;
1134                         break;
1135                 }
1136         }
1137         if (properlyCreated)
1138         {
1139 //              LogDebug("storing group list");
1140                 if (CTS_SUCCESS != contacts_svc_struct_store_list(m_platformContact, CTS_CF_GROUPREL_LIST, groupList))
1141                 {
1142                         properlyCreated = false;
1143                 }
1144         }
1145         for (; groupList; groupList = g_slist_next(groupList))
1146         {
1147                 contacts_svc_value_free(static_cast<CTSvalue*>(groupList->data));
1148         }
1149         g_slist_free(groupList);
1150         return properlyCreated;
1151 }
1152
1153 bool ContactWrapper::convertToPlatformUrlObject()
1154 {
1155 //      LogDebug("entered");
1156         if (NULL == m_abstractContact)
1157         {
1158                 LogError("you should create empty abstract contact object first");
1159                 return false;
1160         }
1161
1162         if (NULL == m_platformContact)
1163         {
1164                 LogError("you should provide platform contact object first");
1165                 return false;
1166         }
1167
1168         int type = 0;
1169         ContactWebSiteArrayPtr urls = m_abstractContact->getUrls();
1170         CTSvalue *url = NULL;
1171         bool properlyCreated = true;
1172         GSList *urlList = NULL;
1173         //mark existing items to delete them.
1174         if (CTS_SUCCESS == contacts_svc_struct_get_list(m_platformContact, CTS_CF_WEB_ADDR_LIST, &urlList))
1175         {
1176                 GSList *urlListSave = urlList;
1177                 for (; urlList; urlList = g_slist_next(urlList))
1178                 {
1179 //                      LogDebug("clearing url list");
1180                         CTSvalue* tmp_email = static_cast<CTSvalue*>(urlList->data);
1181                         contacts_svc_value_set_bool(tmp_email, CTS_WEB_VAL_DELETE_BOOL, true);
1182                 }
1183                 urlList = urlListSave;
1184         }
1185         if (urls->size() == 0 && urlList == NULL
1186                 )
1187                 return true;
1188
1189         //add new items
1190         for (size_t i = 0; i < urls->size(); ++i)
1191         {
1192                 ContactWebSiteType types = urls->at(i)->getType();
1193                 url = contacts_svc_value_new(CTS_VALUE_WEB);
1194                 if (url)
1195                 {
1196                         switch (types)
1197                         {
1198                         case WEBSITE_TYPE_HOMEPAGE:
1199                                 type = CTS_WEB_TYPE_HOME;
1200                                 break;
1201                         case WEBSITE_TYPE_BLOG:
1202                                 type = CTS_WEB_TYPE_WORK;
1203                                 break;
1204                         default:
1205                                 LogError("invalid phone type");
1206                                 type = CTS_WEB_TYPE_NONE;
1207                                 break;
1208                         }
1209                         if (CTS_SUCCESS == contacts_svc_value_set_int(url, CTS_WEB_VAL_TYPE_INT, type)
1210                                         && CTS_SUCCESS == contacts_svc_value_set_str(url, CTS_WEB_VAL_ADDR_STR, urls->at(i)->getUrl().c_str()))
1211                         {
1212                                 urlList = g_slist_append(urlList, url);
1213                         }
1214                         else
1215                         {
1216                                 contacts_svc_value_free(url);
1217                                 properlyCreated = false;
1218                                 break;
1219                         }
1220                 }
1221                 else
1222                 {
1223                         properlyCreated = false;
1224                         break;
1225                 }
1226
1227                 if (!properlyCreated)
1228                 {
1229                         break;
1230                 }
1231         }
1232
1233         if (properlyCreated)
1234         {
1235                 if (CTS_SUCCESS != contacts_svc_struct_store_list(m_platformContact, CTS_CF_WEB_ADDR_LIST, urlList))
1236                 {
1237                         properlyCreated = false;
1238                 }
1239         }
1240         for (; urlList; urlList = g_slist_next(urlList))
1241         {
1242                 contacts_svc_value_free(static_cast<CTSvalue*>(urlList->data));
1243         }
1244         g_slist_free(urlList);
1245         return properlyCreated;
1246 }
1247
1248 bool ContactWrapper::convertToPlatformOrganizationObject()
1249 {
1250 //      LogDebug("entered");
1251         if (NULL == m_abstractContact)
1252         {
1253                 LogError("you should create empty abstract contact object first");
1254                 return false;
1255         }
1256
1257         if (NULL == m_platformContact)
1258         {
1259                 LogError("you should provide platform contact object first");
1260                 return false;
1261         }
1262
1263         ContactOrganizationPtr org = m_abstractContact->getOrganization();
1264         CTSvalue *organization = NULL;
1265
1266         //mark existing items to delete them.
1267         if (CTS_SUCCESS != contacts_svc_struct_get_value(m_platformContact, CTS_CF_COMPANY_VALUE, &organization))
1268         {
1269                 CTSvalue *value = contacts_svc_value_new(CTS_VALUE_COMPANY);
1270                 if (value)
1271                 {
1272                         if (CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_COMPANY_VAL_NAME_STR, org->getName().c_str())
1273                                         || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_COMPANY_VAL_DEPARTMENT_STR, org->getDepartment().c_str())
1274                                         || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_COMPANY_VAL_JOB_TITLE_STR, org->getTitle().c_str())
1275                                         || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_COMPANY_VAL_ROLE_STR, org->getRole().c_str())
1276                                         || CTS_SUCCESS != contacts_svc_struct_store_value(m_platformContact, CTS_CF_COMPANY_VALUE, value))
1277                         {
1278                                 contacts_svc_value_free(value);
1279                                 return false;
1280                         }
1281                         contacts_svc_value_free(value);
1282                 }
1283                 else
1284                 {
1285                         return false;
1286                 }
1287         }
1288         else
1289         {
1290                 contacts_svc_value_set_str(organization, CTS_COMPANY_VAL_NAME_STR, org->getName().c_str());
1291                 contacts_svc_value_set_str(organization, CTS_COMPANY_VAL_DEPARTMENT_STR, org->getDepartment().c_str());
1292                 contacts_svc_value_set_str(organization, CTS_COMPANY_VAL_JOB_TITLE_STR, org->getTitle().c_str());
1293                 contacts_svc_value_set_str(organization, CTS_COMPANY_VAL_ROLE_STR, org->getRole().c_str());
1294                 contacts_svc_struct_store_value(m_platformContact, CTS_CF_COMPANY_VALUE, organization);
1295                 contacts_svc_value_free(organization);
1296         }
1297
1298         return true;
1299 }
1300
1301 bool ContactWrapper::convertToPlatformAnniversaryObject()
1302 {
1303 //      LogDebug("entered");
1304         if (NULL == m_abstractContact)
1305         {
1306                 LogError("you should create empty abstract contact object first");
1307                 return false;
1308         }
1309
1310         if (NULL == m_platformContact)
1311         {
1312                 LogError("you should provide platform contact object first");
1313                 return false;
1314         }
1315
1316         ContactAnniversaryArrayPtr anniversaries = m_abstractContact->getAnniversaries();
1317         CTSvalue *anniversary = NULL;
1318         bool properlyCreated = true;
1319         GSList *anniversaryList = NULL;
1320
1321         //mark existing items to delete them.
1322         if (CTS_SUCCESS == contacts_svc_struct_get_list(m_platformContact, CTS_CF_EVENT_LIST, &anniversaryList))
1323         {
1324                 GSList *anniversaryListSave = anniversaryList;
1325                 for (; anniversaryList; anniversaryList = g_slist_next(anniversaryList))
1326                 {
1327 //                      LogDebug("clearing anniversary list");
1328                         CTSvalue* tmp_anniversary = static_cast<CTSvalue*>(anniversaryList->data);
1329                         contacts_svc_value_set_bool(tmp_anniversary, CTS_EVENT_VAL_DELETE_BOOL, true);
1330                 }
1331                 anniversaryList = anniversaryListSave;
1332         }
1333         if (anniversaries->size() == 0 && anniversaryList == NULL
1334                 )
1335                 return true;
1336
1337         //add new items
1338         int date = 0;
1339         for (size_t i = 0; i < anniversaries->size(); ++i)
1340         {
1341                 date = 0;
1342                 std::tm abstract_date = anniversaries->at(i)->getDate();
1343
1344                 date = (abstract_date.tm_year + 1900) * 10000 + (abstract_date.tm_mon+1) * 100  + abstract_date.tm_mday;
1345                 anniversary = contacts_svc_value_new(CTS_VALUE_EVENT);
1346                 if (anniversary)
1347                 {
1348                         if (CTS_SUCCESS == contacts_svc_value_set_int(anniversary, CTS_EVENT_VAL_TYPE_INT, CTS_EVENT_TYPE_ANNIVERSARY)
1349                                         && CTS_SUCCESS == contacts_svc_value_set_int(anniversary, CTS_EVENT_VAL_DATE_INT, date))
1350                         {
1351                                 anniversaryList = g_slist_append(anniversaryList, anniversary);
1352                         }
1353                         else
1354                         {
1355                                 contacts_svc_value_free(anniversary);
1356                                 properlyCreated = false;
1357                                 break;
1358                         }
1359                 }
1360                 else
1361                 {
1362                         properlyCreated = false;
1363                         break;
1364                 }
1365
1366                 if (!properlyCreated)
1367                 {
1368                         break;
1369                 }
1370         }
1371
1372         if (properlyCreated)
1373         {
1374                 if (CTS_SUCCESS != contacts_svc_struct_store_list(m_platformContact, CTS_CF_EVENT_LIST, anniversaryList))
1375                 {
1376                         properlyCreated = false;
1377                 }
1378         }
1379         for (; anniversaryList; anniversaryList = g_slist_next(anniversaryList))
1380         {
1381                 contacts_svc_value_free(static_cast<CTSvalue*>(anniversaryList->data));
1382         }
1383         g_slist_free(anniversaryList);
1384         return properlyCreated;
1385 }
1386
1387 bool ContactWrapper::convertToPlatformbirthdayObject()
1388 {
1389 //      LogDebug("entered");
1390         if (NULL == m_abstractContact)
1391         {
1392                 LogError("you should create empty abstract contact object first");
1393                 return false;
1394         }
1395
1396         if (NULL == m_platformContact)
1397         {
1398                 LogError("you should provide platform contact object first");
1399                 return false;
1400         }
1401
1402         tm birth_date = m_abstractContact->getBirthday();
1403
1404         CTSvalue *birthday = NULL;
1405         bool properlyCreated = true;
1406         GSList *anniversaryList = NULL;
1407
1408         //mark existing items to delete them.
1409         if (CTS_SUCCESS == contacts_svc_struct_get_list(m_platformContact, CTS_CF_EVENT_LIST, &anniversaryList))
1410         {
1411                 GSList *anniversaryListSave = anniversaryList;
1412                 for (; anniversaryList; anniversaryList = g_slist_next(anniversaryList))
1413                 {
1414 //                      LogDebug("clearing anniversary list");
1415                         CTSvalue* tmp_anniversary = static_cast<CTSvalue*>(anniversaryList->data);
1416                         int type = contacts_svc_value_get_int(tmp_anniversary, CTS_EVENT_VAL_TYPE_INT);
1417                         if (type == CTS_EVENT_TYPE_BIRTH)
1418                                 contacts_svc_value_set_bool(tmp_anniversary, CTS_EVENT_VAL_DELETE_BOOL, true);
1419                 }
1420                 anniversaryList = anniversaryListSave;
1421         }
1422         if (birth_date.tm_year == 0 && birth_date.tm_mon == 0 && birth_date.tm_mday == 0 && anniversaryList == NULL
1423                 )
1424                 return true;
1425
1426         //add new items
1427         int date = 0;
1428         date = (birth_date.tm_year + 1900) * 10000 + (birth_date.tm_mon+1) * 100 + birth_date.tm_mday;
1429 //      for (size_t i = 0; i < anniversaries->size(); ++i) {
1430         birthday = contacts_svc_value_new(CTS_VALUE_EVENT);
1431         if (birthday)
1432         {
1433
1434                 if (CTS_SUCCESS == contacts_svc_value_set_int(birthday, CTS_EVENT_VAL_TYPE_INT, CTS_EVENT_TYPE_BIRTH)
1435                                 && CTS_SUCCESS == contacts_svc_value_set_int(birthday, CTS_EVENT_VAL_DATE_INT, date))
1436                 {
1437                         anniversaryList = g_slist_append(anniversaryList, birthday);
1438                 }
1439                 else
1440                 {
1441                         contacts_svc_value_free(birthday);
1442                         properlyCreated = false;
1443 //                              break;
1444                 }
1445         }
1446         else
1447         {
1448                 properlyCreated = false;
1449 //                      break;
1450         }
1451
1452 //              if (!properlyCreated) {
1453 //                      break;
1454 //              }
1455 //      }
1456
1457         if (properlyCreated)
1458         {
1459                 if (CTS_SUCCESS != contacts_svc_struct_store_list(m_platformContact, CTS_CF_EVENT_LIST, anniversaryList))
1460                 {
1461                         properlyCreated = false;
1462                 }
1463         }
1464         for (; anniversaryList; anniversaryList = g_slist_next(anniversaryList))
1465         {
1466                 contacts_svc_value_free(static_cast<CTSvalue*>(anniversaryList->data));
1467         }
1468         g_slist_free(anniversaryList);
1469         return properlyCreated;
1470 }
1471
1472 bool ContactWrapper::convertToPlatformPhoneObject()
1473 {
1474 //      LogDebug("entered");
1475         if (NULL == m_abstractContact)
1476         {
1477                 LogError("you should create empty abstract contact object first");
1478                 return false;
1479         }
1480
1481         if (NULL == m_platformContact)
1482         {
1483                 LogError("you should provide platform contact object first");
1484                 return false;
1485         }
1486
1487         int type = 0;
1488         ContactPhoneNumberArrayPtr phoneNumbers = m_abstractContact->getPhoneNumbers();
1489         bool properlyCreated = true;
1490         CTSvalue *number = NULL;
1491         GSList *numberList = NULL;
1492         //mark existing items to delete them.
1493         if (CTS_SUCCESS == contacts_svc_struct_get_list(m_platformContact, CTS_CF_NUMBER_LIST, &numberList))
1494         {
1495                 GSList *numberListSave = numberList;
1496                 for (; numberList; numberList = g_slist_next(numberList))
1497                 {
1498 //                      LogDebug("clearing phone list");
1499                         CTSvalue* number = static_cast<CTSvalue*>(numberList->data);
1500                         contacts_svc_value_set_bool(number, CTS_NUM_VAL_DELETE_BOOL, true);
1501                 }
1502                 numberList = numberListSave;
1503         }
1504         if (phoneNumbers->size() == 0 && numberList == NULL )
1505                 return true;
1506
1507         //add new items
1508         for (size_t i = 0; i < phoneNumbers->size(); ++i)
1509         {
1510                 ContactPhoneNumberTypeArrayPtr types = phoneNumbers->at(i)->getTypes();
1511                 number = contacts_svc_value_new(CTS_VALUE_NUMBER);
1512                 type = 0;
1513                 if (number)
1514                 {
1515                         for (size_t j = 0; j < types->size(); ++j)
1516                         {
1517                                 if (types->at(j) == CONTACT_PHONE_NUMBER_TYPE_WORK)
1518                                         type = type | CTS_NUM_TYPE_WORK;
1519                                 else if (types->at(j) == CONTACT_PHONE_NUMBER_TYPE_PREF)
1520                                         type = type | CTS_NUM_TYPE_NONE;
1521                                 else if (types->at(j) == CONTACT_PHONE_NUMBER_TYPE_HOME)
1522                                         type = type | CTS_NUM_TYPE_HOME;
1523                                 else if (types->at(j) == CONTACT_PHONE_NUMBER_TYPE_FAX)
1524                                         type = type | CTS_NUM_TYPE_FAX;
1525                                 else if (types->at(j) == CONTACT_PHONE_NUMBER_TYPE_CELL)
1526                                         type = type | CTS_NUM_TYPE_CELL;
1527                                 else if (types->at(j) == CONTACT_PHONE_NUMBER_TYPE_PAGER)
1528                                         type = type | CTS_NUM_TYPE_PAGER;
1529                                 else if (types->at(j) == CONTACT_PHONE_NUMBER_TYPE_CAR)
1530                                         type = type | CTS_NUM_TYPE_CAR;
1531                                 else if (types->at(j) == CONTACT_PHONE_NUMBER_TYPE_BBS)
1532                                         type = type | CTS_NUM_TYPE_BBS;
1533                                 else if (types->at(j) == CONTACT_PHONE_NUMBER_TYPE_MODEM)
1534                                         type = type | CTS_NUM_TYPE_MODEM;
1535                                 else if (types->at(j) == CONTACT_PHONE_NUMBER_TYPE_ISDN)
1536                                         type = type | CTS_NUM_TYPE_ISDN;
1537                                 else if (types->at(j) == CONTACT_PHONE_NUMBER_TYPE_VIDEO)
1538                                         type = type | CTS_NUM_TYPE_VIDEO;
1539                                 else if (types->at(j) == CONTACT_PHONE_NUMBER_TYPE_VOICE)
1540                                         type = type | CTS_NUM_TYPE_VOICE;
1541                                 else if (types->at(j) == CONTACT_PHONE_NUMBER_TYPE_MSG)
1542                                         type = type | CTS_NUM_TYPE_MSG;
1543                                 else
1544                                 {
1545                                         LogError("invalid phone type");
1546                                         type = CTS_NUM_TYPE_NONE;
1547                                 }
1548                         }
1549                         if (CTS_SUCCESS == contacts_svc_value_set_str(number, CTS_NUM_VAL_NUMBER_STR, phoneNumbers->at(i)->getNumber().c_str())
1550                                         && CTS_SUCCESS == contacts_svc_value_set_bool(number, CTS_NUM_VAL_DEFAULT_BOOL, type == CTS_NUM_TYPE_NONE)
1551                                         && CTS_SUCCESS == contacts_svc_value_set_int(number, CTS_NUM_VAL_TYPE_INT, type))
1552                         {
1553                                 numberList = g_slist_append(numberList, number);
1554                         }
1555                         else
1556                         {
1557                                 contacts_svc_value_free(number);
1558                                 properlyCreated = false;
1559                                 break;
1560                         }
1561                 }
1562                 else
1563                 {
1564                         properlyCreated = false;
1565                         break;
1566                 }
1567                 if (!properlyCreated)
1568                 {
1569                         break;
1570                 }
1571         }
1572         if (properlyCreated)
1573         {
1574                 if (CTS_SUCCESS != contacts_svc_struct_store_list(m_platformContact, CTS_CF_NUMBER_LIST, numberList))
1575                 {
1576                         properlyCreated = false;
1577                 }
1578         }
1579         for (; numberList; numberList = g_slist_next(numberList))
1580         {
1581                 contacts_svc_value_free(static_cast<CTSvalue*>(numberList->data));
1582         }
1583         g_slist_free(numberList);
1584         return properlyCreated;
1585 }
1586
1587 bool ContactWrapper::convertToPlatformEmailObject()
1588 {
1589 //      LogDebug("entered");
1590         if (NULL == m_abstractContact)
1591         {
1592                 LogError("you should create empty abstract contact object first");
1593                 return false;
1594         }
1595
1596         if (NULL == m_platformContact)
1597         {
1598                 LogError("you should provide platform contact object first");
1599                 return false;
1600         }
1601
1602         int type = 0;
1603         ContactEmailAddressArrayPtr emails = m_abstractContact->getEmails();
1604         CTSvalue *email = NULL;
1605         bool properlyCreated = true;
1606         GSList *emailList = NULL;
1607         //mark existing items to delete them.
1608         if (CTS_SUCCESS == contacts_svc_struct_get_list(m_platformContact, CTS_CF_EMAIL_LIST, &emailList))
1609         {
1610                 GSList *emailListSave = emailList;
1611                 for (; emailList; emailList = g_slist_next(emailList))
1612                 {
1613 //                      LogDebug("clearing email list");
1614                         CTSvalue* email = static_cast<CTSvalue*>(emailList->data);
1615                         contacts_svc_value_set_bool(email, CTS_EMAIL_VAL_DELETE_BOOL, true);
1616                 }
1617                 emailList = emailListSave;
1618         }
1619         if (emails->size() == 0 && emailList == NULL)
1620                 return true;
1621
1622         //add new items
1623         for (size_t i = 0; i < emails->size(); ++i)
1624         {
1625                 ContactEmailAddressTypeArrayPtr types = emails->at(i)->getTypes();
1626                 email = contacts_svc_value_new(CTS_VALUE_EMAIL);
1627                 type = 0;
1628                 if (email)
1629                 {
1630                         for (size_t j = 0; j < types->size(); ++j)
1631                         {
1632                                 switch (types->at(j))
1633                                 {
1634                                 case CONTACT_EMAIL_TYPE_HOME:
1635                                         type = type | CTS_EMAIL_TYPE_HOME;
1636                                         break;
1637                                 case CONTACT_EMAIL_TYPE_WORK:
1638                                         type = type | CTS_EMAIL_TYPE_WORK;
1639                                         break;
1640                                 case CONTACT_EMAIL_TYPE_PREF:
1641                                         type = type | CTS_EMAIL_TYPE_NONE;
1642                                         break;
1643                                 default:
1644                                         LogError("invalid phone type");
1645                                         type = CTS_EMAIL_TYPE_NONE;
1646                                         break;
1647                                 }
1648                         }
1649                         if (CTS_SUCCESS == contacts_svc_value_set_int(email, CTS_EMAIL_VAL_TYPE_INT, type)
1650                                         && CTS_SUCCESS == contacts_svc_value_set_str(email, CTS_EMAIL_VAL_ADDR_STR, emails->at(i)->getEmail().c_str()))
1651                         {
1652                                 emailList = g_slist_append(emailList, email);
1653                         }
1654                         else
1655                         {
1656                                 contacts_svc_value_free(email);
1657                                 properlyCreated = false;
1658                                 break;
1659                         }
1660                 }
1661                 else
1662                 {
1663                         properlyCreated = false;
1664                         break;
1665                 }
1666
1667                 if (!properlyCreated)
1668                 {
1669                         break;
1670                 }
1671         }
1672         if (properlyCreated)
1673         {
1674                 if (CTS_SUCCESS != contacts_svc_struct_store_list(m_platformContact, CTS_CF_EMAIL_LIST, emailList))
1675                 {
1676                         properlyCreated = false;
1677                 }
1678         }
1679         for (; emailList; emailList = g_slist_next(emailList))
1680         {
1681                 contacts_svc_value_free(static_cast<CTSvalue*>(emailList->data));
1682         }
1683         g_slist_free(emailList);
1684         return properlyCreated;
1685 }
1686
1687 bool ContactWrapper::convertToPlatformAddressObject()
1688 {
1689 //      LogDebug("entered");
1690         if (NULL == m_abstractContact)
1691         {
1692                 LogError("you should create empty abstract contact object first");
1693                 return false;
1694         }
1695
1696         if (NULL == m_platformContact)
1697         {
1698                 LogError("you should provide platform contact object first");
1699                 return false;
1700         }
1701
1702         int type = 0;
1703         ContactAddressArrayPtr addresses = m_abstractContact->getAddresses();
1704         bool properlyCreated = true;
1705
1706         GSList *addressList = NULL;
1707         if (CTS_SUCCESS == contacts_svc_struct_get_list(m_platformContact, CTS_CF_POSTAL_ADDR_LIST, &addressList))
1708         {
1709                 GSList *addressListSave = addressList;
1710                 for (; addressList; addressList = g_slist_next(addressList))
1711                 {
1712 //                      LogDebug("clearing address list");
1713                         CTSvalue* address = static_cast<CTSvalue*>(addressList->data);
1714                         contacts_svc_value_set_bool(address, CTS_POSTAL_VAL_DELETE_BOOL, true);
1715                 }
1716                 addressList = addressListSave;
1717         }
1718         if (addresses->size() == 0 && addressList == NULL)
1719                 return true;
1720
1721         //add new items
1722         for (size_t i = 0; i < addresses->size(); ++i)
1723         {
1724                 ContactAddressTypeArrayPtr types = addresses->at(i)->getTypes();
1725
1726                 CTSvalue *address = NULL;
1727                 address = contacts_svc_value_new(CTS_VALUE_POSTAL);
1728                 if (address)
1729                 {
1730                         type = 0;
1731                         for (size_t j = 0; j < types->size(); ++j)
1732                         {
1733                                 switch (types->at(j))
1734                                 {
1735                                 case CONTACT_ADDRESS_TYPE_PREF:
1736                                         type |= CTS_ADDR_TYPE_POSTAL;   // TODO To be checked
1737                                         break;
1738                                 case CONTACT_ADDRESS_TYPE_WORK:
1739                                         type |= CTS_ADDR_TYPE_WORK;
1740                                         break;
1741                                 case CONTACT_ADDRESS_TYPE_HOME:
1742                                         type |= CTS_ADDR_TYPE_HOME;
1743                                         break;
1744                                 default:
1745                                         LogError("invalid address type");
1746                                         type |= CTS_EMAIL_TYPE_NONE;
1747                                         break;
1748                                 }
1749                         }
1750                         if (CTS_SUCCESS == contacts_svc_value_set_int(address, CTS_POSTAL_VAL_TYPE_INT, type)
1751                                         && CTS_SUCCESS == contacts_svc_value_set_str(address, CTS_POSTAL_VAL_COUNTRY_STR, addresses->at(i)->getCountry().c_str())
1752                                         && CTS_SUCCESS == contacts_svc_value_set_str(address, CTS_POSTAL_VAL_REGION_STR, addresses->at(i)->getRegion().c_str())
1753                                         && CTS_SUCCESS == contacts_svc_value_set_str(address, CTS_POSTAL_VAL_LOCALITY_STR, addresses->at(i)->getCity().c_str())
1754                                         && CTS_SUCCESS == contacts_svc_value_set_str(address, CTS_POSTAL_VAL_STREET_STR, addresses->at(i)->getStreetAddress().c_str())
1755                                         && CTS_SUCCESS == contacts_svc_value_set_str(address, CTS_POSTAL_VAL_POBOX_STR, addresses->at(i)->getAdditionalInformation().c_str())
1756                                         && CTS_SUCCESS == contacts_svc_value_set_str(address, CTS_POSTAL_VAL_POSTALCODE_STR, addresses->at(i)->getPostalCode().c_str())
1757                                         && CTS_SUCCESS == contacts_svc_value_set_str(address, CTS_POSTAL_VAL_EXTENDED_STR, addresses->at(i)->getAdditionalInformation().c_str()))
1758                         {
1759                                 addressList = g_slist_append(addressList, address);
1760                         }
1761                         else
1762                         {
1763                                 contacts_svc_value_free(address);
1764                                 properlyCreated = false;
1765                                 break;
1766                         }
1767                 }
1768                 else
1769                 {
1770                         properlyCreated = false;
1771                         break;
1772                 }
1773
1774                 if (!properlyCreated)
1775                 {
1776                         break;
1777                 }
1778         }
1779
1780         if (properlyCreated)
1781         {
1782                 if (CTS_SUCCESS != contacts_svc_struct_store_list(m_platformContact, CTS_CF_POSTAL_ADDR_LIST, addressList))
1783                 {
1784                         properlyCreated = false;
1785                 }
1786         }
1787         for (; addressList; addressList = g_slist_next(addressList))
1788         {
1789                 contacts_svc_value_free(static_cast<CTSvalue*>(addressList->data));
1790         }
1791
1792         g_slist_free(addressList);
1793
1794         return properlyCreated;
1795 }
1796
1797 bool ContactWrapper::convertToPlatformBaseData()
1798 {
1799         if (NULL == m_abstractContact)
1800         {
1801                 LogError("you should create empty abstract contact object first");
1802                 return false;
1803         }
1804
1805         if (NULL == m_platformContact)
1806         {
1807                 LogError("you should provide platform contact object first");
1808                 return false;
1809         }
1810
1811         /**
1812          *If name information is not existed, add name information
1813          * If  name information is existed,update name information
1814          */
1815         CTSvalue *value = NULL;
1816
1817         if (CTS_SUCCESS != contacts_svc_struct_get_value(m_platformContact, CTS_CF_NAME_VALUE, &value))
1818         {
1819                 CTSvalue *value = contacts_svc_value_new(CTS_VALUE_NAME);
1820                 if (value)
1821                 {
1822                         ContactNamePtr contactName = m_abstractContact->getName();
1823                         if (CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_FIRST_STR, contactName->getFirstName().c_str())
1824                                         || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_LAST_STR, contactName->getLastName().c_str())
1825                                         || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_ADDITION_STR, contactName->getMiddleName().c_str())
1826                                         || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_DISPLAY_STR, contactName->getDisplayName().c_str())
1827                                         || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_PREFIX_STR, contactName->getPrefix().c_str())
1828                                         // || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_SUFFIX_STR, contactName->getPhoneticName().c_str())
1829                                         || CTS_SUCCESS != contacts_svc_struct_store_value(m_platformContact, CTS_CF_NAME_VALUE, value))
1830                         {
1831                                 contacts_svc_value_free(value);
1832                                 return false;
1833                         }
1834                         contacts_svc_value_free(value);
1835                 }
1836                 else
1837                 {
1838                         return false;
1839                 }
1840         }
1841         else
1842         {
1843                 ContactNamePtr contactName = m_abstractContact->getName();
1844                 if (CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_FIRST_STR, contactName->getFirstName().c_str())
1845                                 || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_LAST_STR, contactName->getLastName().c_str())
1846                                 || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_ADDITION_STR, contactName->getMiddleName().c_str())
1847                                 || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_DISPLAY_STR, contactName->getDisplayName().c_str())
1848                                 // || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_SUFFIX_STR, contactName->getPhoneticName().c_str())
1849                                 || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_PREFIX_STR, contactName->getPrefix().c_str()))
1850                 {
1851                         contacts_svc_value_free(value);
1852                         return false;
1853                 }
1854                 contacts_svc_value_free(value);
1855         }
1856
1857         /**
1858          *If photo and ringtone uri information is not existed, add the information
1859          * If photo and ringtone uri is existed,update the information
1860          */
1861         CTSvalue *baseinfo = NULL;
1862         if (CTS_SUCCESS != contacts_svc_struct_get_value(m_platformContact, CTS_CF_BASE_INFO_VALUE, &baseinfo))
1863         {
1864
1865                 baseinfo = contacts_svc_value_new(CTS_VALUE_CONTACT_BASE_INFO);
1866                 if (baseinfo)
1867                 {
1868                         if (m_abstractContact->getPhotoURIIsSet())
1869                         {
1870                                 if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_IMG_PATH_STR, convertUriToPath(m_abstractContact->getPhotoURI()).c_str()))
1871                                 {
1872                                         contacts_svc_value_free(baseinfo);
1873                                         return false;
1874                                 }
1875                         }
1876
1877                         if (m_abstractContact->getRingtoneURIIsSet())
1878                         {
1879                                 if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_RINGTONE_PATH_STR, convertUriToPath(m_abstractContact->getRingtoneURI()).c_str()))
1880                                 {
1881                                         contacts_svc_value_free(baseinfo);
1882                                         return false;
1883                                 }
1884                         }
1885
1886                         if (CTS_SUCCESS != contacts_svc_value_set_bool(baseinfo, CTS_BASE_VAL_FAVORITE_BOOL, m_abstractContact->getIsFavorite()))
1887                         {
1888                                 contacts_svc_value_free(baseinfo);
1889                                 return false;
1890                         }
1891
1892                         if(m_abstractContact->getNotesNum() > 0)
1893                         {
1894                                 if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_NOTE_STR, m_abstractContact->getNotes()->at(0).c_str()))
1895                                 {
1896                                         contacts_svc_value_free(baseinfo);
1897                                         return false;
1898                                 }
1899                         }
1900
1901                         contacts_svc_struct_store_value(m_platformContact, CTS_CF_BASE_INFO_VALUE, baseinfo);
1902                         contacts_svc_value_free(baseinfo);
1903                 }
1904                 else
1905                 {
1906                         return false;
1907                 }
1908         }
1909         else
1910         {
1911                 const char * oldimgpath = NULL;
1912                 oldimgpath = contacts_svc_value_get_str(baseinfo, CTS_BASE_VAL_IMG_PATH_STR);
1913
1914                 string strOldImagePath = "";
1915                 if (NULL != oldimgpath)
1916                 {
1917                         strOldImagePath = static_cast<string>(oldimgpath);
1918                 }
1919
1920                 string strNewImagePath = convertUriToPath(m_abstractContact->getPhotoURI());
1921                 if (strOldImagePath != strNewImagePath)
1922                 {
1923                         if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_IMG_PATH_STR, strNewImagePath.c_str()))
1924                         {
1925                                 contacts_svc_value_free(baseinfo);
1926                                 return false;
1927                         }
1928                 }
1929
1930                 const char * oldringtonepath = NULL;
1931                 oldringtonepath = contacts_svc_value_get_str(baseinfo, CTS_BASE_VAL_IMG_PATH_STR);
1932
1933                 string strOldRingtonePath = "";
1934                 if (NULL != oldringtonepath)
1935                 {
1936                         strOldRingtonePath = static_cast<string>(oldringtonepath);
1937                 }
1938
1939                 string strNewRingtonePath = convertUriToPath(m_abstractContact->getRingtoneURI());
1940                 if (strOldRingtonePath != strNewRingtonePath)
1941                 {
1942                         if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_RINGTONE_PATH_STR, strNewRingtonePath.c_str()))
1943                         {
1944                                 contacts_svc_value_free(baseinfo);
1945                                 return false;
1946                         }
1947                 }
1948
1949                 if(m_abstractContact->getNotesNum() > 0)
1950                 {
1951                         if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_NOTE_STR, m_abstractContact->getNotes()->at(0).c_str()))
1952                         {
1953                                 contacts_svc_value_free(baseinfo);
1954                                 return false;
1955                         }
1956                 }
1957                 else
1958                 {
1959                         if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_NOTE_STR, ""))
1960                         {
1961                                 contacts_svc_value_free(baseinfo);
1962                                 return false;
1963                         }
1964                 }
1965
1966                 contacts_svc_struct_store_value(m_platformContact, CTS_CF_BASE_INFO_VALUE, baseinfo);
1967                 contacts_svc_value_free(baseinfo);
1968         }
1969         /*
1970          //save company information
1971          CTSvalue *company = NULL;
1972          company = contacts_svc_value_new(CTS_VALUE_COMPANY);
1973          if (company) {
1974          if (m_abstractContact->getOrganizations()->size() > 0) {
1975          if (CTS_SUCCESS !=
1976          contacts_svc_value_set_str(company, CTS_COMPANY_VAL_NAME_STR,
1977          m_abstractContact->getOrganizations()->at(0)->getName().c_str())
1978          ||
1979          CTS_SUCCESS !=
1980          contacts_svc_struct_store_value(m_platformContact,
1981          CTS_CF_COMPANY_VALUE, company))
1982          {
1983          contacts_svc_value_free(company);
1984          return false;
1985          }
1986          }
1987          contacts_svc_value_free(value);
1988          } else {
1989          return false;
1990          }
1991          */
1992         return true;
1993 }
1994
1995 int ContactWrapper::getCustomTypeInContactsSvc(const string &typeName) const
1996 {
1997         int structFieldType = -1;
1998         structFieldType = contacts_svc_find_custom_type(CTS_TYPE_CLASS_EXTEND_DATA, const_cast<char*>(typeName.c_str()));
1999         if ( CTS_ERR_DB_RECORD_NOT_FOUND == structFieldType)
2000         {
2001                 LogDebug("CTS_ERR_DB_RECORD_NOT_FOUND!!");
2002
2003                 structFieldType = contacts_svc_insert_custom_type( CTS_TYPE_CLASS_EXTEND_DATA, const_cast<char*>(typeName.c_str()));
2004                 if (CTS_SUCCESS > structFieldType)
2005                 {
2006                         LogDebug("Create fail");
2007                 }
2008         }
2009         else if (CTS_SUCCESS > structFieldType)
2010         {
2011                 LogDebug("contacts_svc_find_custom_type is fail");
2012         }
2013
2014         return structFieldType;
2015 }
2016
2017 void ContactWrapper::printPlatformObject()
2018 {
2019 }
2020
2021 void ContactWrapper::printAbstractObject()
2022 {
2023 }
2024
2025 string ContactWrapper::convertUriToPath(string str) const
2026 {
2027         string result;
2028
2029         if(validate("^file\\:///[a-zA-Z]{2,3}(/\\S*)?$", str, VALIDATE_MATCH_CASELESS))
2030                 result = str.substr(string("file://").size());
2031         else if(validate("^/[a-zA-Z]{2,3}(/\\S*)?$", str, VALIDATE_MATCH_CASELESS))
2032                 result = str;
2033
2034         return result;
2035 }
2036
2037 string ContactWrapper::convertPathToUri(string str) const
2038 {
2039         string result;
2040
2041         if(validate("^/[a-zA-Z]{2,3}(/\\S*)?$", str, VALIDATE_MATCH_CASELESS))
2042                 result = "file://" + str;
2043         else if(validate("^file\\:///[a-zA-Z]{2,3}(/\\S*)?$", str, VALIDATE_MATCH_CASELESS))
2044                 result = str;
2045
2046         return result;
2047 }
2048
2049 } // Contact
2050 } // Platform
2051 } // TizenApis