src/platform/Tizen/Contact/ContactWrapper.cpp

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