src/platform/Tizen/Contact/ContactSearchEngine.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        ContactSearchEngine.cpp
  19  * @author      Kisub Song (kisubs.song@samsung.com)
  20  * @version     0.1
  21  * @brief
  22  */
  23
  24 #include "query-svc/query-service.h"
  25 #include "time.h"
  26
  27 #include <iomanip>
  28 #include <Commons/Exception.h>
  29 #include "ContactSearchEngine.h"
  30
  31 namespace TizenApis {
  32 namespace Platform {
  33 namespace Contact {
  34
  35 using namespace TizenApis::Api::Contact;
  36 using namespace TizenApis::Api::Tizen;
  37 using namespace WrtDeviceApis::Commons;
  38 using namespace std;
  39
  40 using TizenApis::Api::Contact::Contact;
  41
  42 map<string, int> ContactSearchEngine::attrEnumMap = {
  43                 {"id",                                          contact_attribute_e::CONTACT_ID},
  44                 {"readOnly",                            contact_attribute_e::ATTRIBUTE_MAX},
  45                 {"accountId",                           contact_attribute_e::ATTRIBUTE_MAX},
  46                 {"prefix",                                      contact_attribute_e::NAME_PREFIX},
  47                 {"name.firstName",                      contact_attribute_e::NAME_FIRST},
  48                 {"name.middleName",                     contact_attribute_e::NAME_MIDDLE},
  49                 {"name.lastName",                       contact_attribute_e::NAME_LAST},
  50                 {"name.nicknames",                      contact_attribute_e::NICKNAME_NAME},
  51                 {"name.phoneticName",           contact_attribute_e::NAME_PHONETIC},
  52                 {"name.displayName",            contact_attribute_e::NAME_DISPLAY},
  53                 {"addresses.country",           contact_attribute_e::ADDRESS_COUNTRY},
  54                 {"addresses.region",            contact_attribute_e::ADDRESS_REGION},
  55                 {"addresses.city",                      contact_attribute_e::ADDRESS_CITY},
  56                 {"addresses.streetAddress",     contact_attribute_e::ADDRESS_STREET},
  57                 {"addresses.additionalInformation",             contact_attribute_e::ADDRESS_ADDITIONAL},
  58                 {"addresses.postalCode",        contact_attribute_e::ADDRESS_POSTAL_CODE},
  59                 {"addresses.types",                     contact_attribute_e::ATTRIBUTE_MAX},
  60                 {"photoURI",                            contact_attribute_e::CONTACT_PHOTO_URI},
  61                 {"phoneNumbers.number",         contact_attribute_e::NUMBER_ADDRESS},
  62                 {"phoneNumbers.types",          contact_attribute_e::NUMBER_TYPES},
  63                 {"emails.email",                        contact_attribute_e::EMAIL_ADDRESS},
  64                 {"emails.types",                        contact_attribute_e::EMAIL_TYPE},
  65                 {"birthday",                            contact_attribute_e::EVENT_DATE},
  66                 {"anniversaries.date",          contact_attribute_e::EVENT_DATE},
  67                 {"organizations.name",          contact_attribute_e::ORGANIZATION_NAME},
  68                 {"organization.department",             contact_attribute_e::ORGANIZATION_DEPARTMENT},
  69                 {"organization.title",          contact_attribute_e::ORGANIZATION_TITLE},
  70                 {"organization.role",           contact_attribute_e::ORGANIZATION_ROLE},
  71                 {"organization.logoURI",        contact_attribute_e::ATTRIBUTE_MAX},
  72                 {"notes",                                       contact_attribute_e::CONTACT_NOTE},
  73                 {"urls.url",                            contact_attribute_e::URL_ADDRESS},
  74                 {"urls.type",                           contact_attribute_e::URL_TYPE},
  75                 {"lastUpdated",                         contact_attribute_e::CONTACT_LAST_UPDATED_TIME_STAMP},
  76                 {"isFavorite",                          contact_attribute_e::CONTACT_IS_FAVORITE},
  77                 {"ringtoneURI",                         contact_attribute_e::CONTACT_RINGTONE},
  78                 {"categories",                          contact_attribute_e::CATEGORY_INFO}
  79 };
  80
  81
  82 ContactSearchEngine::ContactSearchEngine(ContactQueryType type)
  83 {
  84         query_error error;
  85         query_type_e qtype = query_type_e::QUERY_TO_PERSON;
  86         if (type == CONTACT_QUERY)
  87                 qtype = query_type_e::QUERY_TO_CONTACT;
  88
  89         m_contact_query_service = query_init(&error, qtype);
  90         if (error != QUERY_SUCCESS)
  91                 m_contact_query_service = NULL;
  92 }
  93
  94 ContactSearchEngine::~ContactSearchEngine()
  95 {
  96         if (m_contact_query_service)
  97                 query_finalize(m_contact_query_service);
  98 }
  99
 100 void ContactSearchEngine::setCondition(FilterPtr filter)
 101 {
 102         if(!filter)
 103                 return;
 104
 105         IFilterVisitorPtr filterQuery = DPL::StaticPointerCast<IFilterVisitor>(SharedFromThis());
 106         filter->travel(filterQuery);
 107 }
 108
 109 void ContactSearchEngine::setSortMode(SortModePtr attr)
 110 {
 111         if(attr)
 112         {
 113                 order_e ord;
 114                 if (attr->getOrder() == ASCENDING_SORT_ORDER)
 115                         ord = ASC;
 116                 else
 117                         ord = DESC;
 118
 119                 query_set_order_by(m_contact_query_service, getPlatformAttr(attr->getAttributeName()), ord);
 120         }
 121         else
 122         {
 123                 query_set_order_by(m_contact_query_service, contact_attribute_e::CONTACT_ID, ASC);
 124         }
 125 }
 126
 127 void ContactSearchEngine::setAttributeOfInterest(StringArrayPtr attr)
 128 {
 129         if(attr)
 130         {
 131                 m_attributesOfInterest = attr;
 132                 for (StringArray::iterator it = attr->begin(); it!=attr->end(); ++it)
 133                 {
 134                         query_set_attribute(m_contact_query_service, getPlatformAttr(*it));
 135                 }
 136         }
 137         else
 138         {
 139                 m_attributesOfInterest = StringArrayPtr(new StringArray());
 140                 for (map<string, int>::iterator it=attrEnumMap.begin(); it!=attrEnumMap.end(); it++)
 141                 {
 142                         if(query_set_attribute(m_contact_query_service, static_cast<contact_attribute_e>(it->second)) == QUERY_SUCCESS)
 143                                 m_attributesOfInterest->push_back(it->first);
 144                 }
 145         }
 146 }
 147
 148 ContactArrayPtr ContactSearchEngine::getContactSearchResult()
 149 {
 150         ContactArrayPtr result = ContactArrayPtr(new ContactArray());
 151
 152         query_error err;
 153
 154         contact_attribute_e pattr;
 155
 156         bool nameAlreadyChecked = false;
 157         bool numberAlreadyChecked = false;
 158         bool emailAlreadyChecked = false;
 159         bool urlAlreadyChecked = false;
 160         bool addrAlreadyChecked = false;
 161         bool eventAlreadyChecked = false;
 162         bool organizationAlreadyChecked = false;
 163         bool nicknameAlreadyChecked = false;
 164         bool categoryAlreadyChecked = false;
 165
 166         LogDebug("Start generating result set");
 167
 168         while ( query_get_result_contact(m_contact_query_service) == QUERY_SUCCESS )
 169         {
 170                 ContactPtr contact = ContactPtr(new Contact());
 171
 172                 for (StringArray::iterator it = m_attributesOfInterest->begin(); it != m_attributesOfInterest->end(); it++)
 173                 {
 174                         pattr = getPlatformAttr(*it);
 175
 176                         err = QUERY_SUCCESS;
 177
 178                         if (!nameAlreadyChecked &&
 179                                         (pattr == CONTACT_ID || pattr == NAME_FIRST || pattr == NAME_LAST ||
 180                                                         pattr == NAME_MIDDLE || pattr == NAME_DISPLAY))
 181                         {
 182                                 char* str;
 183
 184                                 str = query_get_attribute(m_contact_query_service, CONTACT_ID, &err);
 185                                 if( str )
 186                                         contact->setId(str);
 187
 188                                 str = query_get_attribute(m_contact_query_service, ACCOUNT_ID, &err);
 189                                 if( str )
 190                                         contact->getAccount()->setAccountId(str);
 191
 192                                 str = query_get_attribute(m_contact_query_service, CONTACT_IS_FAVORITE, &err);
 193                                 if( str )
 194                                         contact->setIsFavorite(toBool(str));
 195
 196                                 str = query_get_attribute(m_contact_query_service, CONTACT_RINGTONE, &err);
 197                                 if( str )
 198                                         contact->setRingtoneURI(str);
 199
 200                                 str = query_get_attribute(m_contact_query_service, CONTACT_NOTE, &err);
 201                                 if( str )
 202                                 {
 203                                         StringArrayPtr notes(new StringArray());
 204                                         notes->push_back(str);
 205                                         contact->setNotes(notes);
 206                                 }
 207
 208                                 str = query_get_attribute(m_contact_query_service, CONTACT_PHOTO_URI, &err);
 209                                 if( str )
 210                                         contact->setPhotoURI(str);
 211
 212                                 str = query_get_attribute(m_contact_query_service, CONTACT_LAST_UPDATED_TIME_STAMP, &err);
 213                                 if( str )
 214                                 {
 215                                         tm time_stamp;
 216                                         time_t db_time_stamp = (time_t)atoi(str);
 217
 218                                         struct tm* tmp_time = gmtime(&db_time_stamp);
 219                                         memcpy(&time_stamp, tmp_time, sizeof(tm));
 220                                         contact->setLastUpdated(time_stamp);
 221                                 }
 222
 223                                 ContactNamePtr contactName = contact->getName();
 224
 225                                 str = query_get_attribute(m_contact_query_service, NAME_FIRST, &err);
 226                                 if( str )
 227                                         contactName->setFirstName(str);
 228
 229                                 str = query_get_attribute(m_contact_query_service, NAME_LAST, &err);
 230                                 if( str )
 231                                         contactName->setLastName(str);
 232
 233                                 str = query_get_attribute(m_contact_query_service, NAME_MIDDLE, &err);
 234                                 if( str )
 235                                         contactName->setMiddleName(str);
 236
 237                                 str = query_get_attribute(m_contact_query_service, NAME_DISPLAY, &err);
 238                                 if( str )
 239                                         contactName->setDisplayName(str);
 240
 241                                 str = query_get_attribute(m_contact_query_service, NAME_PREFIX, &err);
 242                                 if( str )
 243                                         contactName->setPrefix(str);
 244
 245                                 str = query_get_attribute(m_contact_query_service, NAME_PHONETIC, &err);
 246                                 if( str )
 247                                         contactName->setPhoneticName(str);
 248
 249                                 nameAlreadyChecked = true;
 250                         }
 251                         else if (!numberAlreadyChecked && (pattr == NUMBER_ADDRESS || pattr == NUMBER_TYPES))
 252                         {
 253                                 do
 254                                 {
 255                                         char *number = query_get_attribute(m_contact_query_service, NUMBER_ADDRESS, &err);
 256                                         char *numType = query_get_attribute(m_contact_query_service, NUMBER_TYPES, &err);
 257
 258                                         setPhoneNumber(contact, number, numType);
 259
 260                                 } while ( fetch_next_row(m_contact_query_service) == QUERY_SUCCESS );
 261
 262                                 numberAlreadyChecked = true;
 263                         }
 264                         else if (!emailAlreadyChecked && (pattr == EMAIL_ADDRESS || pattr == EMAIL_TYPE))
 265                         {
 266                                 do
 267                                 {
 268                                         char *email = query_get_attribute(m_contact_query_service, EMAIL_ADDRESS, &err);
 269                                         char *emailType = query_get_attribute(m_contact_query_service, EMAIL_TYPE, &err);
 270
 271                                         setEmailAddresses(contact, email, emailType);
 272
 273                                 } while ( fetch_next_row(m_contact_query_service) == QUERY_SUCCESS );
 274
 275                                 emailAlreadyChecked = true;
 276                         }
 277                         else if (!urlAlreadyChecked && (pattr == URL_ADDRESS || pattr == URL_TYPE))
 278                         {
 279                                 do
 280                                 {
 281                                         char *url = query_get_attribute(m_contact_query_service, URL_ADDRESS, &err);
 282                                         char *urlType = query_get_attribute(m_contact_query_service, URL_TYPE, &err);
 283
 284                                         setUrlAddresses(contact, url, urlType);
 285
 286                                 } while ( fetch_next_row(m_contact_query_service) == QUERY_SUCCESS );
 287
 288                                 urlAlreadyChecked = true;
 289                         }
 290                         else if (!addrAlreadyChecked &&
 291                                         (pattr == ADDRESS_COUNTRY || pattr == ADDRESS_REGION ||
 292                                                         pattr == ADDRESS_CITY || pattr == ADDRESS_STREET ||
 293                                                         pattr == ADDRESS_POSTAL_CODE || pattr == ADDRESS_ADDITIONAL) )
 294                         {
 295                                 do
 296                                 {
 297                                         char *country = query_get_attribute(m_contact_query_service, ADDRESS_COUNTRY, &err);
 298                                         char *region = query_get_attribute(m_contact_query_service, ADDRESS_REGION, &err);
 299                                         char *city = query_get_attribute(m_contact_query_service, ADDRESS_CITY, &err);
 300                                         char *street = query_get_attribute(m_contact_query_service, ADDRESS_STREET, &err);
 301                                         char *postal_code = query_get_attribute(m_contact_query_service, ADDRESS_POSTAL_CODE, &err);
 302                                         char *additional = query_get_attribute(m_contact_query_service, ADDRESS_ADDITIONAL, &err);
 303
 304                                         setAddresses(contact, country, region, city, NULL, street, postal_code, additional);
 305
 306                                 } while ( fetch_next_row(m_contact_query_service) == QUERY_SUCCESS );
 307
 308                                 addrAlreadyChecked = true;
 309                         }
 310                         else if (!eventAlreadyChecked && (pattr == EVENT_DATE || pattr == EVENT_TYPE))
 311                         {
 312                                 do
 313                                 {
 314                                         char *event = query_get_attribute(m_contact_query_service, EVENT_DATE, &err);
 315                                         char *eventType = query_get_attribute(m_contact_query_service, EVENT_TYPE, &err);
 316
 317                                         setEvent(contact, event, eventType);
 318
 319                                 } while ( fetch_next_row(m_contact_query_service) == QUERY_SUCCESS );
 320
 321                                 eventAlreadyChecked = true;
 322                         }
 323                         else if (!organizationAlreadyChecked &&
 324                                         (pattr == ORGANIZATION_NAME || pattr == ORGANIZATION_DEPARTMENT ||
 325                                                         pattr == ORGANIZATION_TITLE || pattr == ORGANIZATION_ROLE ) )
 326                         {
 327                                 do
 328                                 {
 329                                         char *orgname = query_get_attribute(m_contact_query_service, ORGANIZATION_NAME, &err);
 330                                         char *org_dept = query_get_attribute(m_contact_query_service, ORGANIZATION_DEPARTMENT, &err);
 331                                         char *org_title = query_get_attribute(m_contact_query_service, ORGANIZATION_TITLE, &err);
 332                                         char *org_role = query_get_attribute(m_contact_query_service, ORGANIZATION_ROLE, &err);
 333
 334                                         setOrganization(contact, orgname, org_dept, org_title, org_role);
 335
 336                                 } while ( fetch_next_row(m_contact_query_service) == QUERY_SUCCESS );
 337
 338                                 organizationAlreadyChecked = true;
 339                         }
 340                         else if (!nicknameAlreadyChecked && (pattr == NICKNAME_NAME))
 341                         {
 342                                 do
 343                                 {
 344                                         char *nickname = query_get_attribute(m_contact_query_service, NICKNAME_NAME, &err);
 345                                         if(nickname)
 346                                                 contact->getName()->addNickname(string(nickname));
 347
 348                                 } while ( fetch_next_row(m_contact_query_service) == QUERY_SUCCESS );
 349
 350                                 nicknameAlreadyChecked = true;
 351                         }
 352                         else if (!categoryAlreadyChecked && (pattr == CATEGORY_INFO))
 353                         {
 354                                 do
 355                                 {
 356                                         char *category = query_get_attribute(m_contact_query_service, CATEGORY_INFO, &err);
 357                                         if(category)
 358                                                 contact->addCategory(string(category));
 359
 360                                 } while ( fetch_next_row(m_contact_query_service) == QUERY_SUCCESS );
 361
 362                                 categoryAlreadyChecked = true;
 363                         }
 364
 365                 }
 366                 nameAlreadyChecked = false;
 367                 numberAlreadyChecked = false;
 368                 emailAlreadyChecked = false;
 369                 urlAlreadyChecked = false;
 370                 addrAlreadyChecked = false;
 371                 eventAlreadyChecked = false;
 372                 organizationAlreadyChecked = false;
 373                 nicknameAlreadyChecked = false;
 374                 categoryAlreadyChecked = false;
 375
 376                 result->push_back(contact);
 377         }
 378
 379         LogDebug("entered, end generating result set");
 380         return result;
 381 }
 382
 383 void ContactSearchEngine::visitPreComposite(FilterType& type, int depth)
 384 {
 385         query_set_condition_append(m_contact_query_service, LEFT_BRACKET);
 386 }
 387
 388 void ContactSearchEngine::visitInComposite(FilterType& type, int depth)
 389 {
 390         if(type == UNION_FILTER)
 391                 query_set_condition_append(m_contact_query_service, OR);
 392         else if(type == INTERSECTION_FILTER)
 393                 query_set_condition_append(m_contact_query_service, AND);
 394 }
 395
 396 void ContactSearchEngine::visitPostComposite(FilterType& type, int depth)
 397 {
 398         query_set_condition_append(m_contact_query_service, RIGHT_BRACKET);
 399 }
 400
 401 void ContactSearchEngine::visitAttribute(string& attrName, MatchFlag& matchFlag, AnyArrayPtr& matchValues, int depth)
 402 {
 403         contact_attribute_e attr;
 404         attr = getPlatformAttr(attrName);
 405
 406         string matchValueStr;
 407
 408         if(matchFlag == MATCH_EXISTS)
 409         {
 410                 query_set_condition(m_contact_query_service, attr, EXISTS, NULL);
 411         }
 412         else if(attrName == "id" && matchFlag == MATCH_EXACTLY)
 413         {
 414                 visitAttributeID(matchValues);
 415         }
 416         else if(matchValues->size() == 1)
 417         {
 418                 condition_e cond;
 419                 if(matchFlag == MATCH_EXACTLY)
 420                         cond = EQUAL;
 421                 else if (matchFlag == MATCH_STARTSWITH || matchFlag == MATCH_ENDSWITH)
 422                         cond = LIKE;
 423                 else
 424                         cond = EQUAL;
 425
 426                 AnyPtr matchValue = matchValues->at(0);
 427
 428                 visitAttributeEach(attr, matchValue, cond);
 429         }
 430         else if(matchValues->size() > 1)
 431         {
 432                 condition_e cond;
 433                 if(matchFlag == MATCH_EXACTLY)
 434                         cond = EQUAL;
 435                 else if (matchFlag == MATCH_STARTSWITH || matchFlag == MATCH_ENDSWITH)
 436                         cond = LIKE;
 437                 else
 438                         cond = EQUAL;
 439
 440                 query_set_condition_append(m_contact_query_service, LEFT_BRACKET);
 441
 442                 AnyArray::iterator iter;
 443                 for(iter = matchValues->begin(); iter != matchValues->end(); iter++)
 444                 {
 445                         AnyPtr matchValue = *iter;
 446                         if(iter != matchValues->begin())
 447                                 query_set_condition_append(m_contact_query_service, OR);
 448
 449                         visitAttributeEach(attr, matchValue, cond);
 450                 }
 451
 452                 query_set_condition_append(m_contact_query_service, RIGHT_BRACKET);
 453         }
 454 }
 455
 456 void ContactSearchEngine::visitAttributeRange(string& attrName, AnyPtr& initialValue, AnyPtr& endValue, int depth)
 457 {
 458         contact_attribute_e attr;
 459         string initialValueStr;
 460         string endValueStr;
 461
 462         if(initialValue->isType(PrimitiveType_Time))
 463         {
 464                 tm date = initialValue->getDateTm();
 465                 initialValueStr = toDateDbStr(date);
 466         }
 467         else
 468         {
 469                 initialValueStr = initialValue->toString();
 470         }
 471
 472         if(endValue->isType(PrimitiveType_Time))
 473         {
 474                 tm date = endValue->getDateTm();
 475                 endValueStr = toDateDbStr(date);
 476         }
 477         else
 478         {
 479                 endValueStr = endValue->toString();
 480         }
 481
 482         attr = getPlatformAttr(attrName);
 483         query_set_condition_append(m_contact_query_service, LEFT_BRACKET);
 484         query_set_condition(m_contact_query_service, attr, GREATER_THAN_OR_EQUAL, ("\"" + initialValueStr + "\"").c_str());
 485         query_set_condition_append(m_contact_query_service, AND);
 486         query_set_condition(m_contact_query_service, attr, LESS_THAN_OR_EQUAL, ("\"" + endValueStr + "\"").c_str());
 487         query_set_condition_append(m_contact_query_service, RIGHT_BRACKET);
 488 }
 489
 490 void ContactSearchEngine::visitAttributeEach(contact_attribute_e attr, AnyPtr& matchValue, condition_e flag)
 491 {
 492         string valueStr;
 493         if(matchValue->isType(PrimitiveType_Time))
 494         {
 495                 tm date = matchValue->getDateTm();
 496                 valueStr = toDateDbStr(date);
 497         }
 498         else
 499         {
 500                 valueStr = matchValue->toString();
 501         }
 502
 503         query_set_condition(m_contact_query_service, attr, flag, valueStr.c_str());
 504 }
 505
 506 void ContactSearchEngine::visitAttributeID(AnyArrayPtr &ids)
 507 {
 508         if (ids->size() == 1)
 509         {
 510                 query_set_condition(m_contact_query_service, getPlatformAttr("id"), EQUAL, ids->at(0)->toString().c_str());
 511         }
 512         else if (ids->size() > 1)
 513         {
 514                 query_set_condition_with_indices_begin(m_contact_query_service);
 515
 516                 for (AnyArray::iterator iter = ids->begin(); iter != ids->end(); iter++)
 517                         query_set_condition_with_indices(m_contact_query_service, (*iter)->toString().c_str());
 518
 519                 query_set_condition_with_indices_end(m_contact_query_service);
 520         }
 521 }
 522
 523 contact_attribute_e ContactSearchEngine::getPlatformAttr(string attrName)
 524 {
 525         contact_attribute_e platformAttr = contact_attribute_e::ATTRIBUTE_MAX;
 526
 527         platformAttr = (contact_attribute_e) attrEnumMap.find(attrName)->second;
 528         if (platformAttr >= ATTRIBUTE_MAX)
 529         {
 530                 ThrowMsg(UnsupportedException, "Attribute(" << attrName << ") is not supported.");
 531         }
 532
 533         return platformAttr;
 534 }
 535
 536 #if 0
 537 void ContactSearchEngine::setPlatformAttrValue(Contact& contact, contact_attribute_e attr, char* val)
 538 {
 539         if(!val)
 540                 return;
 541
 542         switch (attr)
 543         {
 544         case CONTACT_ID:
 545                 contact.setId(string(val));
 546                 break;
 547         case CONTACT_IS_FAVORITE:
 548                 contact.setIsFavorite(toBool(val));
 549                 break;
 550         case CONTACT_RINGTONE:
 551                 contact.setRingtoneURI(string(val));
 552                 break;
 553         case CONTACT_NOTE:
 554                 contact.addNote(string(val));
 555                 break;
 556         case CONTACT_PHOTO_URI:
 557                 contact.setPhotoURI(string(val));
 558                 break;
 559 //      CONTACT_READ_ONLY,
 560 //      CONTACT_SEND_TO_VOICE_MAIL,
 561         case CONTACT_LAST_UPDATED_TIME_STAMP:
 562                 contact.setLastUpdated(toDateTm(val));
 563                 break;
 564
 565 //      CONTACT_LATITUDE,
 566 //      CONTACT_LONGITUDE,
 567         case NAME_FIRST:
 568                 contact.setFirstName(string(val));
 569                 break;
 570         case NAME_MIDDLE:
 571                 contact.setMiddleName(string(val));
 572                 break;
 573         case NAME_LAST:
 574                 contact.setLastName(string(val));
 575                 break;
 576         case NAME_PREFIX:
 577                 contact.setPrefix(string(val));
 578                 break;
 579         case NAME_PHONETIC:
 580                 contact.setPhoneticName(string(val));
 581                 break;
 582         case NAME_DISPLAY:
 583                 contact.setDisplayName(string(val));
 584                 break;
 585         case NICKNAME_NAME:
 586                 contact.addNickname(string(val));
 587                 break;
 588         case NUMBER_ADDRESS:
 589         case NUMBER_TYPES:
 590                 break;
 591         case EMAIL_ADDRESS:
 592         case EMAIL_TYPE:
 593                 break;
 594
 595         case URL_ADDRESS:
 596         case URL_TYPE:
 597                 break;
 598
 599         case ADDRESS_COUNTRY:
 600         case ADDRESS_REGION:
 601 //      case ADDRESS_COUNTY:
 602         case ADDRESS_CITY:
 603         case ADDRESS_STREET:
 604         case ADDRESS_POSTAL_CODE:
 605         case ADDRESS_ADDITIONAL:
 606                 break;
 607
 608         case CATEGORY_INFO:
 609                 contact.addCategory(string(val));
 610                 break;
 611         case EVENT_DATE:
 612         case EVENT_TYPE:
 613                 break;
 614
 615 //      ORGANIZATION_NAME = 140,
 616 //      ORGANIZATION_DEPARTMENT,
 617 ////    ORGANIZATION_OFFICE,
 618 //      ORGANIZATION_TITLE,
 619 //      ORGANIZATION_ROLE,
 620 ////    ORGANIZATION_LOGO_URI,
 621
 622 // NOT COMPLETE YET
 623 //      PRESENCE_STATE = 160,
 624 //      PRESENCE_MESSAGE,
 625 //      PRESENCE_ICON_URI,
 626 //      PRESENCE_CAPABILITY,
 627 //      PRESENCE_IM_ADDR,
 628 //
 629 //      ATTRIBUTE_MAX = 1000
 630         default:
 631                 break;
 632         }
 633 }
 634 #endif
 635
 636 void ContactSearchEngine::setPhoneNumber(ContactPtr& contact, char *number, char *type)
 637 {
 638         if(number == NULL)
 639                 return;
 640
 641         ContactPhoneNumberPtr numberType = ContactPhoneNumberPtr(new ContactPhoneNumber());
 642
 643         if(number)
 644                 numberType->setNumber(string(number));
 645
 646         if(type)
 647         {
 648                 vector<string> tokens;
 649                 tokenize(type,tokens, ",");
 650
 651                 for (unsigned int i=0; i<tokens.size(); i++)
 652                         numberType->addType(tokens[i]);
 653         }
 654
 655         contact->addPhoneNumber(numberType);
 656 }
 657
 658 void ContactSearchEngine::setEmailAddresses(ContactPtr& contact, char *email, char *type)
 659 {
 660         if(email == NULL)
 661                 return;
 662
 663         ContactEmailAddressPtr emailAddr = ContactEmailAddressPtr(new ContactEmailAddress());
 664
 665         if(email)
 666                 emailAddr->setEmail(string(email));
 667
 668         if(type)
 669         {
 670                 vector<string> tokens;
 671                 tokenize(type,tokens, ",");
 672                 for (unsigned int i=0; i<tokens.size(); i++)
 673                 {
 674                         if (tokens[i].compare("WORK") == 0)
 675                                 emailAddr->addType(CONTACT_EMAIL_TYPE_WORK);
 676                         else if (tokens[i].compare("PREF"))
 677                                 emailAddr->addType(CONTACT_EMAIL_TYPE_PREF);
 678                         else if (tokens[i].compare("HOME"))
 679                                 emailAddr->addType(CONTACT_EMAIL_TYPE_HOME);
 680                 }
 681         }
 682
 683         contact->addEmail(emailAddr);
 684 }
 685
 686 void ContactSearchEngine::setUrlAddresses(ContactPtr& contact, char *url, char *type)
 687 {
 688         if(url == NULL)
 689                 return;
 690
 691         ContactWebSitePtr urlType = ContactWebSitePtr(new ContactWebSite());
 692
 693         if(url)
 694                 urlType->setUrl(string(url));
 695
 696         if(type)
 697         {
 698                 vector<string> tokens;
 699                 tokenize(type,tokens, ",");
 700                 for (unsigned int i=0; i<tokens.size(); i++)
 701                 {
 702                         if (tokens[i].compare("HOMEPAGE") == 0)
 703                                 urlType->setType(WEBSITE_TYPE_HOMEPAGE);
 704                         else if (tokens[i].compare("BLOG") == 0)
 705                                 urlType->setType(WEBSITE_TYPE_BLOG);
 706                 }
 707         }
 708
 709         contact->addUrl(urlType);
 710 }
 711
 712 void ContactSearchEngine::setAddresses(ContactPtr& contact,
 713                 char *country, char *region, char* city, char *county, char *street, char *postal_code, char *additional)
 714 {
 715         if(country == NULL && region == NULL && city == NULL && county == NULL &&
 716                         street == NULL && postal_code == NULL && additional == NULL)
 717                 return;
 718
 719         ContactAddressPtr addr = ContactAddressPtr(new ContactAddress());
 720
 721         if(country)
 722                 addr->setCountry(string(country));
 723
 724         if(region)
 725                 addr->setRegion(string(region));
 726
 727         if(city)
 728                 addr->setCity(string(city));
 729
 730         if(street)
 731                 addr->setStreetAddress(string(street));
 732
 733         if(postal_code)
 734                 addr->setPostalCode(string(postal_code));
 735
 736         if(additional)
 737                 addr->setAdditionalInformation(string(additional));
 738
 739         contact->addAddress(addr);
 740 }
 741
 742 void ContactSearchEngine::setEvent(ContactPtr& contact, char *date, char *type)
 743 {
 744         if(date == NULL)
 745                 return;
 746
 747         tm tm_date = toDateTmFromDateDbStr(date);
 748
 749         if(type != NULL)
 750         {
 751                 if(strcmp(type, "BIRTHDAY") == 0)
 752                 {
 753                         contact->setBirthday(tm_date);
 754                 }
 755                 else if(strcmp(type, "ANNIVERSARY") == 0)
 756                 {
 757                         ContactAnniversaryPtr anniv = ContactAnniversaryPtr(new ContactAnniversary());
 758
 759                         anniv->setDate(tm_date);
 760                         //if(type)
 761                         //      anniv->setLabel(string(type));
 762
 763                         contact->addAnniversary(anniv);
 764                 }
 765         }
 766         else
 767                 LogDebug("type is null");
 768 }
 769
 770 void ContactSearchEngine::setOrganization(ContactPtr& contact,
 771                 char* org_name, char* org_dept, char* org_title, char* org_role)
 772 {
 773         ContactOrganizationPtr org = ContactOrganizationPtr(new ContactOrganization());
 774
 775         if(org_name)
 776                 org->setName(string(org_name));
 777
 778         if(org_dept)
 779                 org->setDepartment(string(org_dept));
 780
 781         if(org_title)
 782                 org->setTitle(string(org_title));
 783
 784         if(org_role)
 785                 org->setRole(string(org_role));
 786
 787         contact->setOrganization(org);
 788 }
 789
 790 void ContactSearchEngine::tokenize(const string& str, vector<string>& tokens, const string& delimiters)
 791 {
 792         // Skip delimiters at beginning.
 793         string::size_type lastPos = str.find_first_not_of(delimiters, 0);
 794         // Find first "non-delimiter".
 795         string::size_type pos = str.find_first_of(delimiters, lastPos);
 796
 797         while (string::npos != pos || string::npos != lastPos)
 798         {
 799                 // Found a token, add it to the vector.
 800                 tokens.push_back(str.substr(lastPos, pos - lastPos));
 801                 // Skip delimiters.  Note the "not_of"
 802                 lastPos = str.find_first_not_of(delimiters, pos);
 803                 // Find next "non-delimiter"
 804                 pos = str.find_first_of(delimiters, lastPos);
 805         }
 806 }
 807
 808 bool ContactSearchEngine::toBool(char* val)
 809 {
 810         string boolStr(val);
 811
 812         if (boolStr == "true" || boolStr == "TRUE")
 813                 return true;
 814
 815         return false;
 816 }
 817
 818 tm ContactSearchEngine::toDateTm(char* arg)
 819 {
 820         // this code originated from Converter
 821         struct tm result;
 822         char* currentLocale = setlocale(LC_TIME, NULL);
 823         if (currentLocale == NULL) {
 824                 ThrowMsg(ConversionException, "Couldn't get current locale.");
 825         }
 826         DPL::ScopedFree<char> currentLocaleCopy(strdup(currentLocale));
 827         if (setlocale(LC_TIME, "C") == NULL) {
 828                 ThrowMsg(ConversionException, "Couldn't set POSIX locale.");
 829         }
 830         if (strptime(arg, "%a %b %d %Y %T", &result) == NULL) {
 831                 ThrowMsg(ConversionException, "Couldn't convert supplied date.");
 832         }
 833         if (setlocale(LC_TIME, currentLocaleCopy.Get()) == NULL) {
 834                 ThrowMsg(ConversionException, "Couldn't set previous locale back.");
 835         }
 836         return result;
 837 }
 838
 839 string ContactSearchEngine::toDateDbStr(const tm &date) const
 840 {
 841         stringstream ss;
 842         ss << setfill('0') << setiosflags(ios::right) << setw(4) << (date.tm_year + 1900);
 843         ss << setfill('0') << setiosflags(ios::right) << setw(2) << (date.tm_mon + 1);
 844         ss << setfill('0') << setiosflags(ios::right) << setw(2) << date.tm_mday;
 845
 846         return ss.str();
 847 }
 848
 849 tm ContactSearchEngine::toDateTmFromDateDbStr(const char* arg) const
 850 {
 851         tm date;
 852
 853         if(arg == NULL) {
 854                 ThrowMsg(InvalidArgumentException, "Invalid Date type");
 855         }
 856
 857         int dateDb;
 858         stringstream ss(arg);
 859         ss >> dateDb;
 860
 861         date.tm_year = (dateDb / 10000) - 1900;
 862         date.tm_mon = ((dateDb - ((date.tm_year + 1900) * 10000)) / 100) - 1;
 863         date.tm_mday = (dateDb - ((date.tm_year + 1900) * 10000) - date.tm_mon * 100);
 864
 865         return date;
 866 }
 867
 868 } // Contact
 869 } // Platform
 870 } // TizenApis