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