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