server/db/ctsvc_db_plugin_contact_helper.c

   1 /*
   2  * Contacts Service
   3  *
   4  * Copyright (c) 2010 - 2015 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19 #include <ctype.h>
  20 #include <fcntl.h>
  21 #include <unistd.h>
  22
  23 #include "contacts.h"
  24 #include "ctsvc_internal.h"
  25 #include "ctsvc_db_sqlite.h"
  26 #include "ctsvc_db_schema.h"
  27 #include "ctsvc_db_init.h"
  28 #include "ctsvc_db_utils.h"
  29 #include "ctsvc_record.h"
  30 #include "ctsvc_normalize.h"
  31 #include "ctsvc_server_setting.h"
  32 #include "ctsvc_localize.h"
  33 #include "ctsvc_localize_utils.h"
  34 #include "ctsvc_localize_ch.h"
  35 #include "ctsvc_notification.h"
  36 #include "ctsvc_notify.h"
  37 #include "ctsvc_db_access_control.h"
  38
  39 #include "ctsvc_db_plugin_contact_helper.h"
  40 #include "ctsvc_db_plugin_company_helper.h"
  41 #include "ctsvc_db_plugin_name_helper.h"
  42 #include "ctsvc_db_plugin_number_helper.h"
  43 #include "ctsvc_db_plugin_email_helper.h"
  44 #include "ctsvc_db_plugin_event_helper.h"
  45 #include "ctsvc_db_plugin_url_helper.h"
  46 #include "ctsvc_db_plugin_note_helper.h"
  47 #include "ctsvc_db_plugin_profile_helper.h"
  48 #include "ctsvc_db_plugin_address_helper.h"
  49 #include "ctsvc_db_plugin_nickname_helper.h"
  50 #include "ctsvc_db_plugin_messenger_helper.h"
  51 #include "ctsvc_db_plugin_relationship_helper.h"
  52 #include "ctsvc_db_plugin_image_helper.h"
  53 #include "ctsvc_db_plugin_extension_helper.h"
  54 #include "ctsvc_db_plugin_sip_helper.h"
  55
  56 #include "ctsvc_server_person.h"
  57 #include "ctsvc_server_group.h"
  58
  59 #ifdef ENABLE_LOG_FEATURE
  60 #include "ctsvc_server_phonelog.h"
  61 #endif /* ENABLE_LOG_FEATURE */
  62
  63 #define CTSVC_CONTACT_INITIAL_DATA_MAX_LEN 128
  64
  65 int ctsvc_contact_add_image_file(int parent_id, int img_id,
  66                 char *src_img, char *dest, int dest_size)
  67 {
  68         int ret;
  69         int version;
  70         char *ext;
  71         char *temp;
  72         char *lower_ext;
  73
  74         RETV_IF(NULL == src_img, CONTACTS_ERROR_INVALID_PARAMETER);
  75
  76         ext = strrchr(src_img, '.');
  77         if (NULL == ext || strchr(ext, '/'))
  78                 ext = "";
  79
  80         lower_ext = strdup(ext);
  81         temp = lower_ext;
  82         if (NULL == temp) {
  83                 ERR("strdup() Fail");
  84                 return CONTACTS_ERROR_OUT_OF_MEMORY;
  85         }
  86         while (*temp) {
  87                 *temp = tolower(*temp);
  88                 temp++;
  89         }
  90
  91         version = ctsvc_get_next_ver();
  92         snprintf(dest, dest_size, "%d_%d-%d%s", parent_id, img_id, version, lower_ext);
  93         free(lower_ext);
  94
  95         ret = ctsvc_utils_copy_image(CTSVC_CONTACT_IMG_FULL_LOCATION, src_img, dest);
  96         if (CONTACTS_ERROR_NONE != ret) {
  97                 ERR("ctsvc_utils_copy_image() Fail(%d)", ret);
  98                 dest[0] = '\0';
  99                 return ret;
 100         }
 101
 102         return CONTACTS_ERROR_NONE;
 103 }
 104
 105 static int __ctsvc_contact_get_current_image_file(int image_id, char *dest, int dest_size)
 106 {
 107         int ret;
 108         cts_stmt stmt;
 109         char *tmp_path;
 110         char query[CTS_SQL_MIN_LEN] = {0};
 111
 112         snprintf(query, sizeof(query), "SELECT data3 FROM %s WHERE id = %d", CTS_TABLE_DATA, image_id);
 113         ret = ctsvc_query_prepare(query, &stmt);
 114         RETVM_IF(NULL == stmt, ret, "ctsvc_query_prepare() Fail(%d)", ret);
 115
 116         ret = ctsvc_stmt_step(stmt);
 117         if (1 /*CTS_TRUE*/ != ret) {
 118                 ERR("DB error: ctsvc_stmt_step() Fail(%d)", ret);
 119                 ctsvc_stmt_finalize(stmt);
 120                 if (CONTACTS_ERROR_NONE == ret)
 121                         return CONTACTS_ERROR_NO_DATA;
 122                 else
 123                         return ret;
 124         }
 125
 126         tmp_path = ctsvc_stmt_get_text(stmt, 0);
 127         if (tmp_path)
 128                 snprintf(dest, dest_size, "%s/%s", CTSVC_CONTACT_IMG_FULL_LOCATION, tmp_path);
 129
 130         ctsvc_stmt_finalize(stmt);
 131         return CONTACTS_ERROR_NONE;
 132 }
 133
 134 /*
 135  * check that the image file under location or not
 136  * we should check CTSVC_CONTACT_IMG_FULL_LOCATION, CTSVC_VCARD_IMAGE_LOCATION,
 137  * CTS_GROUP_IMAGE_LOCATION, CTS_LOGO_IMAGE_LOCATION
 138  */
 139 bool ctsvc_contact_check_image_location(const char *path)
 140 {
 141         int len;
 142         char *slash;
 143
 144         if (path == NULL || *path == '\0')
 145                 return false;
 146
 147         slash = strrchr(path, '/');
 148         if (slash == NULL || slash == path)
 149                 return false;
 150
 151         len = (int)(slash-path);
 152         if (len != strlen(CTSVC_CONTACT_IMG_FULL_LOCATION))
 153                 return false;
 154
 155         if (STRING_EQUAL == strncmp(path, CTSVC_CONTACT_IMG_FULL_LOCATION, len))
 156                 return true;
 157
 158         return false;
 159 }
 160
 161 int ctsvc_contact_update_image_file(int parent_id, int img_id,
 162                 char *src_img, char *dest_name, int dest_size)
 163 {
 164         int ret;
 165         char dest[CTSVC_IMG_FULL_PATH_SIZE_MAX] = {0};
 166
 167         ret = __ctsvc_contact_get_current_image_file(img_id, dest, sizeof(dest));
 168
 169         WARN_IF(CONTACTS_ERROR_NONE != ret && CONTACTS_ERROR_NO_DATA != ret,
 170                         "__ctsvc_contact_get_current_image_file() Fail(%d)", ret);
 171         if (*dest) {
 172                 if (src_img && STRING_EQUAL == strcmp(dest, src_img)) {
 173                         snprintf(dest_name, dest_size, "%s", src_img + strlen(CTSVC_CONTACT_IMG_FULL_LOCATION) + 1);
 174                         return CONTACTS_ERROR_NONE;
 175                 }
 176
 177                 ret = unlink(dest);
 178                 if (ret < 0)
 179                         WARN("unlink() Fail(%d)", errno);
 180         }
 181
 182         if (src_img) {
 183                 ret = ctsvc_contact_add_image_file(parent_id, img_id, src_img, dest_name, dest_size);
 184                 RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "ctsvc_contact_add_image_file() Fail(%d)", ret);
 185         }
 186
 187         return ret;
 188 }
 189
 190 int ctsvc_db_contact_update_changed_time(int contact_id)
 191 {
 192         int ret;
 193         char query[CTS_SQL_MIN_LEN] = {0};
 194
 195         snprintf(query, sizeof(query),
 196                         "UPDATE %s SET changed_ver=%d, changed_time=%d WHERE contact_id=%d AND deleted = 0",
 197                         CTS_TABLE_CONTACTS, ctsvc_get_next_ver(), (int)time(NULL), contact_id);
 198
 199         ret = ctsvc_query_exec(query);
 200         RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "ctsvc_query_exec() Fail(%d)", ret);
 201
 202         ctsvc_set_contact_noti();
 203
 204         return CONTACTS_ERROR_NONE;
 205 }
 206
 207 int ctsvc_contact_delete_image_file_with_path(const unsigned char *image_path)
 208 {
 209         int ret;
 210
 211         if (image_path) {
 212                 char full_path[CTSVC_IMG_FULL_PATH_SIZE_MAX] = {0};
 213                 snprintf(full_path, sizeof(full_path), "%s/%s", CTSVC_CONTACT_IMG_FULL_LOCATION, image_path);
 214                 ret = unlink(full_path);
 215                 if (ret < 0)
 216                         WARN("unlink() Fail(%d)", errno);
 217         }
 218
 219         return CONTACTS_ERROR_NONE;
 220 }
 221
 222 int ctsvc_db_contact_delete(int contact_id)
 223 {
 224         CTS_FN_CALL;
 225         int ret, rel_changed;
 226         int addressbook_id;
 227         int person_id;
 228         int link_count = 0;
 229         char query[CTS_SQL_MAX_LEN] = {0};
 230         cts_stmt stmt = NULL;
 231         int version;
 232
 233         ret = ctsvc_begin_trans();
 234         RETVM_IF(ret, ret, "ctsvc_begin_trans() Fail(%d)", ret);
 235
 236         snprintf(query, sizeof(query),
 237                         "SELECT addressbook_id, person_id "
 238                         "FROM "CTS_TABLE_CONTACTS" WHERE contact_id = %d AND deleted = 0", contact_id);
 239
 240         ret = ctsvc_query_prepare(query, &stmt);
 241         if (NULL == stmt) {
 242                 ERR("ctsvc_query_prepare() Fail(%d)", ret);
 243                 ctsvc_end_trans(false);
 244                 return ret;
 245         }
 246
 247         ret = ctsvc_stmt_step(stmt);
 248         if (1 != ret) {
 249                 ERR("ctsvc_stmt_step() Fail(%d)", ret);
 250                 ctsvc_stmt_finalize(stmt);
 251                 ctsvc_end_trans(false);
 252                 if (CONTACTS_ERROR_NONE == ret)
 253                         return CONTACTS_ERROR_NO_DATA;
 254                 else
 255                         return ret;
 256         }
 257
 258         addressbook_id = ctsvc_stmt_get_int(stmt, 0);
 259         person_id = ctsvc_stmt_get_int(stmt, 1);
 260         DBG("addressbook_id : %d, person_id : %d", addressbook_id, person_id);
 261         ctsvc_stmt_finalize(stmt);
 262         stmt = NULL;
 263
 264         if (false == ctsvc_have_ab_write_permission(addressbook_id, false)) {
 265                 ERR("No permission in this addresbook_id(%d)", addressbook_id);
 266                 ctsvc_end_trans(false);
 267                 return CONTACTS_ERROR_PERMISSION_DENIED;
 268         }
 269
 270         version = ctsvc_get_next_ver();
 271         snprintf(query, sizeof(query),
 272                         "UPDATE %s SET member_changed_ver=%d "
 273                         "WHERE group_id IN (SELECT group_id FROM %s WHERE contact_id = %d AND deleted = 0) ",
 274                         CTS_TABLE_GROUPS, version, CTS_TABLE_GROUP_RELATIONS, contact_id);
 275         ret = ctsvc_query_exec(query);
 276         if (CONTACTS_ERROR_NONE != ret) {
 277                 ERR("ctsvc_query_exec() Fail(%d)", ret);
 278                 ctsvc_end_trans(false);
 279                 return ret;
 280         }
 281         rel_changed = ctsvc_db_change();
 282
 283         snprintf(query, sizeof(query),
 284                         "UPDATE %s SET deleted = 1, person_id = 0, changed_ver=%d WHERE contact_id = %d",
 285                         CTS_TABLE_CONTACTS, version, contact_id);
 286         ret = ctsvc_query_exec(query);
 287         if (CONTACTS_ERROR_NONE != ret) {
 288                 ERR("ctsvc_query_exec() Fail(%d)", ret);
 289                 ctsvc_end_trans(false);
 290                 return ret;
 291         }
 292
 293         snprintf(query, sizeof(query), "SELECT link_count FROM "CTS_TABLE_PERSONS" WHERE person_id = %d", person_id);
 294         ret = ctsvc_query_get_first_int_result(query, &link_count);
 295         WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_query_get_first_int_result() Fail(%d)", ret);
 296         /*
 297          * set dirty bit to person by trigger
 298          * : person will be aggregated in ctsvc_person_aggregate
 299          */
 300
 301         if (1 < link_count) {
 302                 ctsvc_person_aggregate(person_id);
 303
 304 #ifdef ENABLE_LOG_FEATURE
 305                 /* update phonelog */
 306                 ctsvc_db_phone_log_update_person_id(NULL, person_id, -1, false);
 307 #endif /* ENABLE_LOG_FEATURE */
 308         } else {
 309                 ctsvc_set_person_noti();
 310         }
 311
 312         ctsvc_set_contact_noti();
 313         if (0 < rel_changed)
 314                 ctsvc_set_group_rel_noti();
 315
 316         ret = ctsvc_end_trans(true);
 317         if (ret < CONTACTS_ERROR_NONE) {
 318                 ERR("ctsvc_end_trans() Fail(%d)", ret);
 319                 return ret;
 320         } else {
 321                 return CONTACTS_ERROR_NONE;
 322         }
 323 }
 324
 325 static inline void __ctsvc_contact_get_initial(char *src, char *dest, int dest_size, bool pinyin)
 326 {
 327         int i, j = 0;
 328         bool bFirst = true;
 329         int len = strlen(src);
 330         for (i = 0; i < len && j < (dest_size-1);) {
 331                 if (src[i] == ' ') {
 332                         bFirst = true;
 333                         i++;
 334                 } else if (bFirst) {
 335                         int char_len = ctsvc_check_utf8(src[i]);
 336                         int k;
 337                         for (k = 0; k < char_len && j < (dest_size-1); k++)
 338                                 dest[j++] = src[i++];
 339                         if (false == pinyin && j < (dest_size-1))
 340                                 dest[j++] = ' ';
 341                         bFirst = false;
 342                 } else {
 343                         i++;
 344                 }
 345         }
 346 }
 347
 348 static inline void __ctsvc_remove_space(char *src, char *dest, int dest_size)
 349 {
 350         int len = strlen(src);
 351         int i, j = 0;
 352
 353         for (i = 0; i < len && i < dest_size; i++) {
 354                 if (src[i] && src[i] != ' ') {
 355                         dest[j] = src[i];
 356                         j++;
 357                 }
 358         }
 359         dest[j] = '\0';
 360 }
 361
 362 /* make search name to insert search_index table name column
 363  * korean : display_name, chosung, phonetic
 364  * japanese : dislay_name(hiragana), phonetic
 365  *                              if display_name is chinese and sort_name(phonetic) is japanese,
 366  *                                      then search_name is normalized_name and sort_name (phonetic)
 367  * chinese : display_name, pinyin name, pinyin initial, phonetic
 368  * others : display_name, phonetic
 369  */
 370 int ctsvc_contact_make_search_name(ctsvc_contact_s *contact, char **search_name)
 371 {
 372         char *name = NULL;
 373         char *temp_name = NULL;
 374         int buf_size, ret;
 375
 376         RETV_IF(NULL == contact, CONTACTS_ERROR_NO_DATA);
 377
 378         if (contact->display_name) {
 379                 if (ctsvc_has_chinese(contact->display_name)) {
 380                         if (CTSVC_LANG_JAPANESE == ctsvc_check_language_type(contact->sort_name)) {
 381                                 char *normalized_display_name = NULL;
 382
 383                                 ctsvc_normalize_str(contact->display_name, &normalized_display_name);
 384                                 if (normalized_display_name) {
 385                                         buf_size = SAFE_STRLEN(normalized_display_name) + strlen(contact->sort_name) + 2;
 386                                         name = calloc(1, buf_size);
 387                                         if (NULL == name) {
 388                                                 ERR("calloc() Fail");
 389                                                 free(normalized_display_name);
 390                                                 return CONTACTS_ERROR_OUT_OF_MEMORY;
 391                                         }
 392                                         snprintf(name, buf_size, "%s %s", normalized_display_name, contact->sort_name);
 393                                         free(normalized_display_name);
 394                                 }
 395                         } else {
 396                                 char *langset = ctsvc_get_langset();
 397                                 if (STRING_EQUAL == strncmp(langset, "zh_CN", strlen("zh_CN"))) {
 398                                         pinyin_name_s *pinyinname;
 399                                         int size, i, len;
 400
 401                                         ret = ctsvc_convert_chinese_to_pinyin(contact->display_name, &pinyinname, &size);
 402                                         if (CONTACTS_ERROR_NONE == ret) {
 403                                                 int name_len = (CHINESE_PINYIN_SPELL_MAX_LEN*strlen(contact->display_name)+1)  *sizeof(char);
 404                                                 char *name_nospace = calloc(1, name_len);
 405                                                 if (NULL == name_nospace) {
 406                                                         ERR("calloc() Fail");
 407                                                         ctsvc_pinyin_free(pinyinname, size);
 408                                                         return CONTACTS_ERROR_OUT_OF_MEMORY;
 409                                                 }
 410                                                 char *temp_name = NULL;
 411
 412                                                 ctsvc_normalize_str(contact->display_name, &name);
 413                                                 if (name) {
 414                                                         for (i = 0; i < size; i++) {
 415                                                                 __ctsvc_remove_space(pinyinname[i].pinyin_name, name_nospace, name_len);
 416
 417                                                                 buf_size = SAFE_STRLEN(name)
 418                                                                         + SAFE_STRLEN(pinyinname[i].pinyin_name)
 419                                                                         + SAFE_STRLEN(name_nospace)
 420                                                                         + SAFE_STRLEN(pinyinname[i].pinyin_initial)
 421                                                                         + 4;
 422                                                                 temp_name = calloc(1, buf_size);
 423                                                                 if (NULL == temp_name) {
 424                                                                         ERR("calloc() Fail");
 425                                                                         free(name_nospace);
 426                                                                         ctsvc_pinyin_free(pinyinname, size);
 427                                                                         free(name);
 428                                                                         return CONTACTS_ERROR_OUT_OF_MEMORY;
 429                                                                 }
 430                                                                 snprintf(temp_name, buf_size, "%s %s %s %s",
 431                                                                                 name, pinyinname[i].pinyin_name, name_nospace, pinyinname[i].pinyin_initial);
 432                                                                 free(name);
 433                                                                 name = temp_name;
 434                                                         }
 435                                                 }
 436
 437                                                 len = ctsvc_check_utf8(contact->display_name[0]);
 438                                                 for (i = len; i < strlen(contact->display_name); i += len) {
 439                                                         len = ctsvc_check_utf8(contact->display_name[i]);
 440
 441                                                         buf_size = SAFE_STRLEN(name) + SAFE_STRLEN(&contact->display_name[i]) + 2;
 442                                                         temp_name = calloc(1, buf_size);
 443                                                         if (NULL == temp_name) {
 444                                                                 ERR("calloc() Fail");
 445                                                                 free(name_nospace);
 446                                                                 ctsvc_pinyin_free(pinyinname, size);
 447                                                                 free(name);
 448                                                                 return CONTACTS_ERROR_OUT_OF_MEMORY;
 449                                                         }
 450                                                         snprintf(temp_name, buf_size, "%s %s", name, &contact->display_name[i]);
 451
 452                                                         free(name);
 453                                                         name = temp_name;
 454                                                 }
 455
 456                                                 free(name_nospace);
 457                                                 ctsvc_pinyin_free(pinyinname, size);
 458                                         } else {
 459                                                 char initial[CTSVC_CONTACT_INITIAL_DATA_MAX_LEN] = {0,};
 460                                                 char *normalized_display_name = NULL;
 461
 462                                                 ctsvc_normalize_str(contact->display_name, &normalized_display_name);
 463                                                 if (normalized_display_name) {
 464                                                         __ctsvc_contact_get_initial(contact->display_name, initial, sizeof(initial), false);
 465                                                         buf_size = SAFE_STRLEN(normalized_display_name) + strlen(initial) + 2;
 466                                                         name = calloc(1, buf_size);
 467                                                         if (NULL == name) {
 468                                                                 ERR("calloc() Fail");
 469                                                                 free(normalized_display_name);
 470                                                                 return CONTACTS_ERROR_OUT_OF_MEMORY;
 471                                                         }
 472                                                         snprintf(name, buf_size, "%s %s", normalized_display_name, initial);
 473
 474                                                         free(normalized_display_name);
 475                                                 }
 476                                         }
 477                                 } else {
 478                                         char initial[CTSVC_CONTACT_INITIAL_DATA_MAX_LEN] = {0,};
 479                                         char *normalized_display_name = NULL;
 480
 481                                         ctsvc_normalize_str(contact->display_name, &normalized_display_name);
 482                                         if (normalized_display_name) {
 483                                                 __ctsvc_contact_get_initial(contact->display_name, initial, sizeof(initial), false);
 484                                                 buf_size = SAFE_STRLEN(normalized_display_name) + strlen(initial) + 2;
 485                                                 name = calloc(1, buf_size);
 486                                                 if (NULL == name) {
 487                                                         ERR("calloc() Fail");
 488                                                         free(normalized_display_name);
 489                                                         return CONTACTS_ERROR_OUT_OF_MEMORY;
 490                                                 }
 491                                                 snprintf(name, buf_size, "%s %s", normalized_display_name, initial);
 492
 493                                                 free(normalized_display_name);
 494                                         }
 495                                 }
 496                         }
 497                 } else if (ctsvc_has_korean(contact->display_name)) {
 498                         /* 'a가' should be searched by 'ㄱ' */
 499                         int count, i, j;
 500                         int full_len, chosung_len;
 501                         char *chosung = calloc(1, strlen(contact->display_name) * 5);
 502                         if (NULL == chosung) {
 503                                 ERR("calloc() Fail");
 504                                 return CONTACTS_ERROR_OUT_OF_MEMORY;
 505                         }
 506                         int total_len = strlen(contact->display_name);
 507
 508                         count = ctsvc_get_chosung(contact->display_name, chosung, strlen(contact->display_name) * 5);
 509
 510                         ctsvc_normalize_str(contact->display_name, &name);
 511
 512                         if (0 < count) {
 513                                 for (i = 0, j = 0; i < total_len; i += full_len, j += chosung_len) {
 514                                         full_len = ctsvc_check_utf8(contact->display_name[i]);
 515                                         chosung_len = ctsvc_check_utf8(chosung[j]);
 516
 517                                         buf_size = SAFE_STRLEN(name) + SAFE_STRLEN(&contact->display_name[i]) + SAFE_STRLEN(&chosung[j]) + 3;
 518                                         temp_name = calloc(1, buf_size);
 519                                         if (NULL == temp_name) {
 520                                                 ERR("calloc() Fail");
 521                                                 free(chosung);
 522                                                 free(name);
 523                                                 return CONTACTS_ERROR_OUT_OF_MEMORY;
 524                                         }
 525
 526                                         snprintf(temp_name, buf_size, "%s %s %s", name, &contact->display_name[i], &chosung[j]);
 527
 528                                         free(name);
 529                                         name = temp_name;
 530                                 }
 531                         }
 532                         free(chosung);
 533                 } else if (CTSVC_LANG_JAPANESE == ctsvc_check_language_type(contact->display_name)) {
 534                         ctsvc_convert_japanese_to_hiragana(contact->display_name, &name);
 535                 } else {
 536                         /* Insert 'ABO Â' for 'ÂBC' */
 537                         char initial[CTSVC_CONTACT_INITIAL_DATA_MAX_LEN] = {0};
 538                         char *normalized_display_name = NULL;
 539
 540                         ctsvc_normalize_str(contact->display_name, &normalized_display_name);
 541                         if (normalized_display_name) {
 542                                 __ctsvc_contact_get_initial(contact->display_name, initial, sizeof(initial), false);
 543                                 buf_size = SAFE_STRLEN(normalized_display_name) + strlen(initial) + 2;
 544                                 name = calloc(1, buf_size);
 545                                 if (NULL == name) {
 546                                         ERR("calloc() Fail");
 547                                         free(normalized_display_name);
 548                                         return CONTACTS_ERROR_OUT_OF_MEMORY;
 549                                 }
 550                                 snprintf(name, buf_size, "%s %s", normalized_display_name, initial);
 551
 552                                 free(normalized_display_name);
 553                         }
 554                 }
 555         }
 556
 557         /* append phonetic name */
 558         if (contact->name) {
 559                 contacts_list_h name_list = (contacts_list_h)contact->name;
 560                 ctsvc_name_s *name_record;
 561                 contacts_list_first(name_list);
 562                 char *phonetic = NULL;
 563                 int temp_len = 0;
 564
 565                 contacts_list_get_current_record_p(name_list, (contacts_record_h*)&name_record);
 566                 if (name_record) {
 567                         buf_size = SAFE_STRLEN(name_record->phonetic_first) + SAFE_STRLEN(name_record->phonetic_last) + SAFE_STRLEN(name_record->phonetic_middle);
 568                         if (0 < buf_size) {
 569                                 buf_size += 3; /* for space and null string */
 570                                 phonetic = calloc(1, buf_size);
 571                                 if (NULL == phonetic) {
 572                                         ERR("calloc() Fail");
 573                                         free(name);
 574                                         return CONTACTS_ERROR_OUT_OF_MEMORY;
 575                                 }
 576
 577                                 if (name_record->phonetic_first)
 578                                         temp_len += snprintf(phonetic, buf_size, "%s", name_record->phonetic_first);
 579                                 if (name_record->phonetic_middle) {
 580                                         if (temp_len)
 581                                                 temp_len += snprintf(phonetic + temp_len, buf_size - temp_len, " ");
 582                                         temp_len += snprintf(phonetic + temp_len, buf_size - temp_len, "%s", name_record->phonetic_middle);
 583                                 }
 584                                 if (name_record->phonetic_last) {
 585                                         if (temp_len)
 586                                                 temp_len += snprintf(phonetic + temp_len, buf_size - temp_len, " ");
 587                                         temp_len += snprintf(phonetic + temp_len, buf_size - temp_len, "%s", name_record->phonetic_last);
 588                                 }
 589
 590                                 if (name) {
 591                                         buf_size = SAFE_STRLEN(name) + SAFE_STRLEN(phonetic) + 2;
 592                                         temp_name = calloc(1, buf_size);
 593                                         if (NULL == temp_name) {
 594                                                 ERR("calloc() Fail");
 595                                                 free(phonetic);
 596                                                 free(name);
 597                                                 return CONTACTS_ERROR_OUT_OF_MEMORY;
 598                                         }
 599                                         snprintf(temp_name, buf_size, "%s %s", name, phonetic);
 600                                         free(name);
 601                                         name = temp_name;
 602                                         free(phonetic);
 603                                 } else {
 604                                         name = phonetic;
 605                                 }
 606                         }
 607                 }
 608         }
 609
 610         *search_name = name;
 611         return CONTACTS_ERROR_NONE;
 612 }
 613
 614 static int __ctsvc_make_phonetic_name(ctsvc_name_s *name, char **phonetic, contacts_name_display_order_e order)
 615 {
 616         int len = SAFE_STRLEN(name->phonetic_first) + SAFE_STRLEN(name->phonetic_last) + SAFE_STRLEN(name->phonetic_middle);
 617         if (0 < len) {
 618                 len += 3; /* for space and null string */
 619                 *phonetic = calloc(1, len);
 620                 if (NULL == *phonetic) {
 621                         ERR("calloc() Fail");
 622                         return CONTACTS_ERROR_OUT_OF_MEMORY;
 623                 }
 624
 625                 int temp_len = 0;
 626                 if (order == CONTACTS_NAME_DISPLAY_ORDER_FIRSTLAST) {
 627                         if (name->phonetic_first)
 628                                 temp_len += snprintf(*phonetic, len, "%s", name->phonetic_first);
 629                         if (name->phonetic_middle) {
 630                                 if (temp_len)
 631                                         temp_len += snprintf(*phonetic + temp_len, len - temp_len, " ");
 632                                 temp_len += snprintf(*phonetic + temp_len, len - temp_len, "%s", name->phonetic_middle);
 633                         }
 634                         if (name->phonetic_last) {
 635                                 if (temp_len)
 636                                         temp_len += snprintf(*phonetic + temp_len, len - temp_len, " ");
 637                                 temp_len += snprintf(*phonetic + temp_len, len - temp_len, "%s", name->phonetic_last);
 638                         }
 639                 } else {
 640                         if (name->phonetic_last)
 641                                 temp_len += snprintf(*phonetic, len, "%s", name->phonetic_last);
 642                         if (name->phonetic_middle) {
 643                                 if (temp_len)
 644                                         temp_len += snprintf(*phonetic + temp_len, len - temp_len, " ");
 645                                 temp_len += snprintf(*phonetic + temp_len, len - temp_len, "%s", name->phonetic_middle);
 646                         }
 647                         if (name->phonetic_first) {
 648                                 if (temp_len)
 649                                         temp_len += snprintf(*phonetic + temp_len, len - temp_len, " ");
 650                                 temp_len += snprintf(*phonetic + temp_len, len - temp_len, "%s", name->phonetic_first);
 651                         }
 652                 }
 653         }
 654
 655         return CONTACTS_ERROR_NONE;
 656 }
 657
 658 static inline int __ctsvc_get_sort_name_to_pinyin(const char *display_name, char **sort_name)
 659 {
 660         int ret;
 661         int size;
 662         pinyin_name_s *pinyinname = NULL;
 663         *sort_name = NULL;
 664
 665         if (false == ctsvc_has_chinese(display_name))
 666                 return CONTACTS_ERROR_INVALID_PARAMETER;
 667
 668         ret = ctsvc_convert_chinese_to_pinyin(display_name, &pinyinname, &size);
 669
 670         if (ret == CONTACTS_ERROR_NONE) {
 671                 char temp[strlen(display_name) * 2 + strlen(pinyinname[0].pinyin_name)];
 672                 int pinyin_index = 0;
 673                 int name_index = 0;
 674                 int temp_index = 0;
 675
 676                 while (1) {
 677                         int pinyin_len = 0;
 678                         int name_len = 0;
 679
 680                         if (pinyinname[0].pinyin_name[pinyin_index] == '\0') {
 681                                 if (display_name[name_index] != '\0') {
 682                                         temp[temp_index] = ' ';
 683                                         temp_index++;
 684                                         name_len = ctsvc_check_utf8(display_name[name_index]);
 685                                         if (0 < name_len) {
 686                                                 memcpy(&(temp[temp_index]), &(display_name[name_index]), name_len);
 687                                                 temp_index += name_len;
 688                                                 name_index += name_len;
 689                                         }
 690                                 }
 691                                 break;
 692                         }
 693                         pinyin_len = ctsvc_check_utf8(pinyinname[0].pinyin_name[pinyin_index]);
 694                         if (pinyin_len <= 0)
 695                                 break;
 696                         memcpy(&(temp[temp_index]), &(pinyinname[0].pinyin_name[pinyin_index]), pinyin_len);
 697                         temp_index += pinyin_len;
 698
 699                         if (pinyinname[0].pinyin_name[pinyin_index] == ' ') {
 700                                 name_len = ctsvc_check_utf8(display_name[name_index]);
 701                                 if (name_len <= 0)
 702                                         break;
 703
 704                                 if (name_len == 1 && display_name[name_index] == ' ') {
 705                                         temp[temp_index] = ' ';
 706                                         temp_index++;
 707                                         pinyin_index++;
 708                                 }
 709                                 memcpy(&(temp[temp_index]), &(display_name[name_index]), name_len);
 710                                 temp_index += name_len;
 711                                 name_index += name_len;
 712                                 temp[temp_index] = ' ';
 713                                 temp_index++;
 714                         }
 715
 716                         pinyin_index += pinyin_len;
 717                 }
 718                 temp[temp_index] = '\0';
 719                 *sort_name = strdup(temp);
 720                 ctsvc_pinyin_free(pinyinname, size);
 721         }
 722         return ret;
 723 }
 724
 725 void ctsvc_contact_make_sortkey(ctsvc_contact_s *contact)
 726 {
 727         char *sortkey = NULL;
 728         char *phonetic = NULL;
 729         int sort_type = -1;
 730
 731         if (contact->display_source_type == CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NAME) {
 732                 if (0 < contact->name->count && contact->name->records
 733                                 && contact->name->records->data) {
 734                         ctsvc_name_s *name = (ctsvc_name_s*)contact->name->records->data;
 735                         __ctsvc_make_phonetic_name(name, &phonetic, CONTACTS_NAME_DISPLAY_ORDER_FIRSTLAST);
 736                 }
 737         }
 738
 739         if (phonetic)
 740                 sort_type = ctsvc_get_name_sort_type(phonetic);
 741         else if (contact->sort_name)
 742                 sort_type = ctsvc_get_name_sort_type(contact->sort_name);
 743         else
 744                 sort_type = CTSVC_SORT_OTHERS;
 745
 746         WARN_IF(sort_type < 0, "ctsvc_get_name_sort_type Fail(%d)", sort_type);
 747         char *langset = ctsvc_get_langset();
 748
 749         switch (sort_type) {
 750         case CTSVC_SORT_CJK:
 751                 {
 752                         if (STRING_EQUAL == strncmp(langset, "zh_CN", strlen("zh_CN"))) {
 753                                 /* chinese to pinyin */
 754                                 char *pinyin = NULL;
 755                                 if (phonetic)
 756                                         __ctsvc_get_sort_name_to_pinyin(phonetic, &pinyin);
 757                                 else
 758                                         __ctsvc_get_sort_name_to_pinyin(contact->sort_name, &pinyin);
 759
 760                                 if (pinyin) {
 761                                         free(contact->sort_name);
 762                                         contact->sort_name = pinyin;
 763                                         sort_type = CTSVC_SORT_WESTERN;
 764                                 }
 765                         } else if (STRING_EQUAL == strncmp(langset, "ko_KR", strlen("ko_KR"))) {
 766                                 sort_type = CTSVC_SORT_KOREAN;
 767                         }
 768                 }
 769                 break;
 770         case CTSVC_SORT_JAPANESE:
 771                 {
 772                         char *hiragana = NULL;
 773                         ctsvc_convert_japanese_to_hiragana(contact->sort_name, &hiragana);
 774
 775                         if (hiragana) {
 776                                 free(contact->sort_name);
 777                                 contact->sort_name = hiragana;
 778                         }
 779                         break;
 780                 }
 781         default:
 782                 {
 783                         if (phonetic)
 784                                 FREEandSTRDUP(contact->sort_name, phonetic);
 785                 }
 786                 break;
 787         }
 788
 789         free(phonetic);
 790         phonetic = NULL;
 791
 792         if (ctsvc_get_primary_sort() == sort_type)
 793                 contact->display_name_language = CTSVC_SORT_PRIMARY;
 794         else if (ctsvc_get_secondary_sort() == sort_type)
 795                 contact->display_name_language = CTSVC_SORT_SECONDARY;
 796         else if (sort_type < 0)
 797                 contact->display_name_language = CTSVC_SORT_OTHERS;
 798         else
 799                 contact->display_name_language = sort_type;
 800
 801         /*
 802          * check reverse sort_name, reverser_display_name_language
 803          * make reverse phonetic name
 804          */
 805         if (contact->display_source_type == CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NAME) {
 806                 if (0 < contact->name->count && contact->name->records
 807                                 && contact->name->records->data) {
 808                         ctsvc_name_s *name = (ctsvc_name_s*)contact->name->records->data;
 809                         __ctsvc_make_phonetic_name(name, &phonetic, CONTACTS_NAME_DISPLAY_ORDER_LASTFIRST);
 810                 }
 811         }
 812
 813         if (phonetic)
 814                 sort_type = ctsvc_get_name_sort_type(phonetic);
 815         else if (contact->reverse_sort_name)
 816                 sort_type = ctsvc_get_name_sort_type(contact->reverse_sort_name);
 817         else
 818                 sort_type = CTSVC_SORT_OTHERS;
 819
 820         WARN_IF(sort_type < 0, "ctsvc_get_name_sort_type Fail(%d)", sort_type);
 821
 822         switch (sort_type) {
 823         case CTSVC_SORT_CJK:
 824                 {
 825                         if (STRING_EQUAL == strncmp(langset, "zh_CN", strlen("zh_CN"))) {
 826                                 char *pinyin = NULL;
 827                                 if (phonetic)
 828                                         __ctsvc_get_sort_name_to_pinyin(phonetic, &pinyin);
 829                                 else
 830                                         __ctsvc_get_sort_name_to_pinyin(contact->reverse_sort_name, &pinyin);
 831
 832                                 if (pinyin) {
 833                                         free(contact->reverse_sort_name);
 834                                         contact->reverse_sort_name = pinyin;
 835                                         sort_type = CTSVC_SORT_WESTERN;
 836                                 }
 837                         } else if (STRING_EQUAL == strncmp(langset, "ko_KR", strlen("ko_KR"))) {
 838                                 sort_type = CTSVC_SORT_KOREAN;
 839                         }
 840                 }
 841                 break;
 842         case CTSVC_SORT_JAPANESE:
 843                 {
 844                         char *hiragana = NULL;
 845                         ctsvc_convert_japanese_to_hiragana(contact->reverse_sort_name, &hiragana);
 846
 847                         if (hiragana) {
 848                                 free(contact->reverse_sort_name);
 849                                 contact->reverse_sort_name = hiragana;
 850                         }
 851                 }
 852                 break;
 853         default:
 854                 {
 855                         if (phonetic)
 856                                 FREEandSTRDUP(contact->reverse_sort_name, phonetic);
 857                 }
 858                 break;
 859         }
 860
 861         free(phonetic);
 862         phonetic = NULL;
 863
 864         if (ctsvc_get_primary_sort() == sort_type)
 865                 contact->reverse_display_name_language = CTSVC_SORT_PRIMARY;
 866         else if (ctsvc_get_secondary_sort() == sort_type)
 867                 contact->reverse_display_name_language = CTSVC_SORT_SECONDARY;
 868         else if (sort_type < 0)
 869                 contact->reverse_display_name_language = CTSVC_SORT_OTHERS;
 870         else
 871                 contact->reverse_display_name_language = sort_type;
 872
 873         if (contact->sort_name) {
 874                 sort_type = ctsvc_collation_str(contact->sort_name, &sortkey);
 875                 if (CONTACTS_ERROR_NONE == sort_type)
 876                         contact->sortkey = sortkey;
 877                 else
 878                         free(sortkey);
 879         }
 880
 881         sortkey = NULL;
 882
 883         if (contact->reverse_sort_name) {
 884                 sort_type = ctsvc_collation_str(contact->reverse_sort_name, &sortkey);
 885                 if (CONTACTS_ERROR_NONE == sort_type)
 886                         contact->reverse_sortkey = sortkey;
 887                 else
 888                         free(sortkey);
 889         }
 890 }
 891
 892 static bool __ctsvc_contact_check_name_has_korean(const ctsvc_name_s *name)
 893 {
 894         if (name->first && ctsvc_has_korean(name->first))
 895                 return true;
 896         else if (name->last && ctsvc_has_korean(name->last))
 897                 return true;
 898         else if (name->addition && ctsvc_has_korean(name->addition))
 899                 return true;
 900         else if (name->prefix && ctsvc_has_korean(name->prefix))
 901                 return true;
 902         else if (name->suffix && ctsvc_has_korean(name->suffix))
 903                 return true;
 904
 905         return false;
 906 }
 907
 908 static bool __ctsvc_contact_check_name_has_japanese(const ctsvc_name_s *name)
 909 {
 910         if (name->first && ctsvc_check_language_type(name->first) == CTSVC_LANG_JAPANESE)
 911                 return true;
 912         else if (name->addition && ctsvc_check_language_type(name->addition) == CTSVC_LANG_JAPANESE)
 913                 return true;
 914         else if (name->last && ctsvc_check_language_type(name->last) == CTSVC_LANG_JAPANESE)
 915                 return true;
 916
 917         return false;
 918 }
 919
 920 static bool __ctsvc_contact_check_name_has_chinese(const ctsvc_name_s *name)
 921 {
 922         if (name->first && ctsvc_check_language_type(name->first) == CTSVC_LANG_CHINESE)
 923                 return true;
 924         else if (name->addition && ctsvc_check_language_type(name->addition) == CTSVC_LANG_CHINESE)
 925                 return true;
 926         else if (name->last && ctsvc_check_language_type(name->last) == CTSVC_LANG_CHINESE)
 927                 return true;
 928
 929         return false;
 930 }
 931
 932 int ctsvc_contact_get_name_language(const ctsvc_name_s *name)
 933 {
 934         int lang = -1;
 935         if (__ctsvc_contact_check_name_has_korean(name))
 936                 lang = CTSVC_LANG_KOREAN;
 937         else if (__ctsvc_contact_check_name_has_japanese(name))
 938                 lang = CTSVC_LANG_JAPANESE;
 939         else if (__ctsvc_contact_check_name_has_chinese(name))
 940                 lang = CTSVC_LANG_CHINESE;
 941         else {
 942                 if (name->last)
 943                         lang =  ctsvc_check_language_type(name->last);
 944                 else if (name->first)
 945                         lang =  ctsvc_check_language_type(name->first);
 946                 else if (name->addition)
 947                         lang =  ctsvc_check_language_type(name->addition);
 948         }
 949
 950         return lang;
 951 }
 952
 953 char* __ctsvc_remove_first_space(char *src)
 954 {
 955         if (src == NULL || SAFE_STRLEN(src) == 0)
 956                 return NULL;
 957
 958         int name_len = (SAFE_STRLEN(src)+1)*sizeof(char);
 959         char *name_nospace = NULL;
 960         name_nospace = calloc(1, name_len);
 961         if (NULL == name_nospace) {
 962                 ERR("calloc() Fail");
 963                 return NULL;
 964         }
 965
 966         int len = strlen(src);
 967         int i = 0;
 968
 969         for (i = 0; i < len && i < name_len; i++) {
 970                 if (src[i] && src[i] != ' ') {
 971                         strncpy(name_nospace, src+i, name_len);
 972                         break;
 973                 }
 974         }
 975         return name_nospace;
 976 }
 977 /*
 978  * Make display_name, sort_name, sortkey of the contact by name record
 979  * If the contact record does not have name record,
 980  * we use company, nickname, number, email record in order
 981  */
 982 void ctsvc_contact_make_display_name(ctsvc_contact_s *contact)
 983 {
 984         int len;
 985         ctsvc_name_s *name = NULL;
 986
 987         free(contact->display_name);
 988         contact->display_name = NULL;
 989
 990         free(contact->reverse_display_name);
 991         contact->reverse_display_name = NULL;
 992
 993         free(contact->sort_name);
 994         contact->sort_name = NULL;
 995
 996         free(contact->reverse_sort_name);
 997         contact->reverse_sort_name = NULL;
 998
 999         free(contact->sortkey);
1000         contact->sortkey = NULL;
1001
1002         free(contact->reverse_sortkey);
1003         contact->reverse_sortkey = NULL;
1004
1005         contact->display_name_language = CTSVC_SORT_OTHERS;
1006         contact->reverse_display_name_language = CTSVC_SORT_OTHERS;
1007
1008         contact->display_source_type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_INVALID;
1009
1010         if (0 < contact->name->count && contact->name->records
1011                         && contact->name->records->data) {
1012                 name = (ctsvc_name_s*)contact->name->records->data;
1013         }
1014
1015         if (name && (name->first || name->last || name->prefix || name->addition
1016                                 || name->suffix)) {
1017                 int reverse_lang_type = -1;
1018                 int display_len;
1019                 int temp_display_len;
1020                 char *display = NULL;
1021                 char *temp_display = NULL;
1022
1023                 /*
1024                  * Make reverse display name (Last name first)
1025                  * Default         : Prefix Last, First Middle(addition), Suffix
1026                  * Korean, Chinese : Prefix LastMiddleFirstSuffix
1027                  * Japanese        : Prefix Last Middle First Suffix
1028                  * reverse sort name does not include prefix
1029                  *    But, if there is only prefix, reverse sort_name is prefix
1030                  */
1031                 temp_display_len = SAFE_STRLEN(name->first)
1032                         + SAFE_STRLEN(name->addition)
1033                         + SAFE_STRLEN(name->last)
1034                         + SAFE_STRLEN(name->suffix);
1035                 if (0 < temp_display_len) {
1036                         temp_display_len += 7;
1037                         temp_display = calloc(1, temp_display_len);
1038                         if (NULL == temp_display) {
1039                                 ERR("calloc() Fail");
1040                                 return;
1041                         }
1042                         len = 0;
1043
1044                         /* get language type */
1045                         reverse_lang_type = ctsvc_contact_get_name_language(name);
1046                         if (name->last) {
1047                                 char  *temp = __ctsvc_remove_first_space(name->last);
1048                                 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1049                                 free(temp);
1050                                 if (reverse_lang_type != CTSVC_LANG_KOREAN &&
1051                                                 reverse_lang_type != CTSVC_LANG_CHINESE &&
1052                                                 reverse_lang_type != CTSVC_LANG_JAPANESE) {
1053                                         if (name->first || name->addition)
1054                                                 len += snprintf(temp_display + len, temp_display_len - len, ",");
1055                                 }
1056                         }
1057
1058                         if (reverse_lang_type == CTSVC_LANG_JAPANESE) {
1059                                 /* make temp_display name Prefix - Last - Middle - First - Suffix */
1060                                 if (name->addition) {
1061                                         char  *temp = __ctsvc_remove_first_space(name->addition);
1062                                         if (*temp_display)
1063                                                 len += snprintf(temp_display + len, temp_display_len - len, " ");
1064                                         len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1065                                         free(temp);
1066                                 }
1067
1068                                 if (name->first) {
1069                                         char  *temp = __ctsvc_remove_first_space(name->first);
1070                                         if (*temp_display)
1071                                                 len += snprintf(temp_display + len, temp_display_len - len, " ");
1072                                         len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1073                                         free(temp);
1074                                 }
1075                         } else if (reverse_lang_type == CTSVC_LANG_CHINESE || reverse_lang_type == CTSVC_LANG_KOREAN) {
1076                                 if (name->addition) {
1077                                         char  *temp = __ctsvc_remove_first_space(name->addition);
1078                                         len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1079                                         free(temp);
1080                                 }
1081
1082                                 if (name->first) {
1083                                         char  *temp = __ctsvc_remove_first_space(name->first);
1084                                         len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1085                                         free(temp);
1086                                 }
1087                         } else {
1088                                 /* make temp_display name Prefix - Last - First - Middle - Suffix */
1089                                 if (name->first) {
1090                                         if (*temp_display) {
1091                                                 if (reverse_lang_type < 0)
1092                                                         reverse_lang_type = ctsvc_check_language_type(temp_display);
1093
1094                                                 if (reverse_lang_type != CTSVC_LANG_KOREAN &&
1095                                                                 reverse_lang_type != CTSVC_LANG_CHINESE)
1096                                                         len += snprintf(temp_display + len, temp_display_len - len, " ");
1097                                         }
1098                                         char  *temp = __ctsvc_remove_first_space(name->first);
1099                                         len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1100                                         free(temp);
1101                                 }
1102
1103                                 if (name->addition) {
1104                                         if (*temp_display) {
1105                                                 if (reverse_lang_type < 0)
1106                                                         reverse_lang_type = ctsvc_check_language_type(temp_display);
1107
1108                                                 if (reverse_lang_type != CTSVC_LANG_KOREAN &&
1109                                                                 reverse_lang_type != CTSVC_LANG_CHINESE)
1110                                                         len += snprintf(temp_display + len, temp_display_len - len, " ");
1111                                         }
1112                                         char  *temp = __ctsvc_remove_first_space(name->addition);
1113                                         len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1114                                         free(temp);
1115                                 }
1116                         }
1117
1118                         if (name->suffix) {
1119                                 if (*temp_display) {
1120                                         if (reverse_lang_type < 0)
1121                                                 reverse_lang_type = ctsvc_check_language_type(temp_display);
1122
1123                                         if (reverse_lang_type == CTSVC_LANG_JAPANESE)
1124                                                 len += snprintf(temp_display + len, temp_display_len - len, " ");
1125                                         else if (reverse_lang_type != CTSVC_LANG_KOREAN &&
1126                                                         reverse_lang_type != CTSVC_LANG_CHINESE)
1127                                                 len += snprintf(temp_display + len, temp_display_len - len, ", ");
1128                                 }
1129                                 char  *temp = __ctsvc_remove_first_space(name->suffix);
1130                                 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1131                                 free(temp);
1132                         }
1133                 }
1134
1135                 if (name->prefix && temp_display) {
1136                         display_len = SAFE_STRLEN(name->prefix) + temp_display_len + 2;
1137                         display = calloc(1, display_len);
1138                         if (NULL == display) {
1139                                 ERR("calloc() Fail");
1140                                 free(temp_display);
1141                                 return;
1142                         }
1143                         char  *temp = __ctsvc_remove_first_space(name->prefix);
1144                         snprintf(display, display_len, "%s %s", temp, temp_display);
1145                         free(temp);
1146                         contact->reverse_display_name = display;
1147                         contact->reverse_sort_name = temp_display;
1148                 } else if (temp_display) {
1149                         contact->reverse_display_name = temp_display;
1150                         contact->reverse_sort_name = strdup(temp_display);
1151                 } else if (name->prefix) {
1152                         contact->reverse_display_name = strdup(name->prefix);
1153                         contact->reverse_sort_name = strdup(name->prefix);
1154                 }
1155
1156                 /*
1157                  * Make display name (First name first)
1158                  * Default         : Prefix First Middle Last, Suffix
1159                  * Korean, Chinese : Prefix LastFirstMiddleSuffix (Same as reverse display name)
1160                  * Japanese        : Prefix First Middle Last Suffix
1161                  * sort name does not include prefix
1162                  *    But, if there is only prefix, sort_name is prefix
1163                  */
1164                 if (reverse_lang_type == CTSVC_LANG_KOREAN ||
1165                                 reverse_lang_type == CTSVC_LANG_CHINESE ||
1166                                 reverse_lang_type == CTSVC_LANG_JAPANESE) {
1167                         contact->display_name = strdup(contact->reverse_display_name);
1168                         contact->sort_name = SAFE_STRDUP(contact->reverse_sort_name);
1169                 } else {
1170                         int lang_type = -1;
1171                         temp_display = NULL;
1172                         temp_display_len = SAFE_STRLEN(name->first)
1173                                 + SAFE_STRLEN(name->addition)
1174                                 + SAFE_STRLEN(name->last)
1175                                 + SAFE_STRLEN(name->suffix);
1176                         if (0 < temp_display_len) {
1177                                 temp_display_len += 6;
1178                                 /* make reverse_temp_display_name */
1179                                 temp_display = calloc(1, temp_display_len);
1180                                 if (NULL == temp_display) {
1181                                         ERR("calloc() Fail");
1182                                         return;
1183                                 }
1184                                 len = 0;
1185
1186                                 if (name->first) {
1187                                         char  *temp = __ctsvc_remove_first_space(name->first);
1188                                         len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1189                                         free(temp);
1190                                 }
1191
1192                                 if (name->addition) {
1193                                         char  *temp = __ctsvc_remove_first_space(name->addition);
1194                                         if (*temp_display)
1195                                                 len += snprintf(temp_display + len, temp_display_len - len, " ");
1196                                         len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1197                                         free(temp);
1198                                 }
1199
1200                                 if (name->last) {
1201                                         char  *temp = __ctsvc_remove_first_space(name->last);
1202                                         if (*temp_display)
1203                                                 len += snprintf(temp_display + len, temp_display_len - len, " ");
1204                                         len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1205                                         free(temp);
1206                                 }
1207
1208                                 if (name->suffix) {
1209                                         if (*temp_display) {
1210                                                 lang_type = ctsvc_check_language_type(temp_display);
1211                                                 if (lang_type == CTSVC_LANG_JAPANESE)
1212                                                         len += snprintf(temp_display + len, temp_display_len - len, " ");
1213                                                 else
1214                                                         len += snprintf(temp_display + len, temp_display_len - len, ", ");
1215                                         }
1216                                         char  *temp = __ctsvc_remove_first_space(name->suffix);
1217                                         len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1218                                         free(temp);
1219                                 }
1220                         }
1221
1222                         if (name->prefix && temp_display) {
1223                                 display_len = SAFE_STRLEN(name->prefix) + temp_display_len + 2;
1224                                 display = calloc(1, display_len);
1225                                 if (NULL == display) {
1226                                         ERR("calloc() Fail");
1227                                         free(temp_display);
1228                                         return;
1229                                 }
1230                                 snprintf(display, display_len, "%s %s", name->prefix, temp_display);
1231                                 contact->display_name = display;
1232                                 contact->sort_name = temp_display;
1233                         } else if (temp_display) {
1234                                 contact->display_name = temp_display;
1235                                 contact->sort_name = strdup(temp_display);
1236                         } else if (name->prefix) {
1237                                 contact->display_name = strdup(name->prefix);
1238                                 contact->sort_name = strdup(name->prefix);
1239                         }
1240                 }
1241
1242                 ctsvc_record_set_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY);
1243                 contact->display_source_type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NAME;
1244         } else {
1245                 GList *cur;
1246                 if (contact->company && contact->company->records) {
1247                         for (cur = contact->company->records; cur; cur = cur->next) {
1248                                 ctsvc_company_s *company = cur->data;
1249                                 if (company && company->name) {
1250                                         ctsvc_record_set_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY);
1251                                         contact->display_name = SAFE_STRDUP(company->name);
1252                                         contact->display_source_type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_COMPANY;
1253                                         break;
1254                                 }
1255                         }
1256                 }
1257
1258                 if (false == ctsvc_record_check_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY) &&
1259                                 contact->nicknames && contact->nicknames->records) {
1260                         for (cur = contact->nicknames->records; cur; cur = cur->next) {
1261                                 ctsvc_nickname_s *nickname = cur->data;
1262                                 if (nickname && nickname->nickname) {
1263                                         ctsvc_record_set_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY);
1264                                         free(contact->display_name);
1265                                         contact->display_name = SAFE_STRDUP(nickname->nickname);
1266                                         contact->display_source_type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NICKNAME;
1267                                         break;
1268                                 }
1269                         }
1270                 }
1271
1272                 if (false == ctsvc_record_check_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY) &&
1273                                 contact->numbers && contact->numbers->records) {
1274                         for (cur = contact->numbers->records; cur; cur = cur->next) {
1275                                 ctsvc_number_s *number = cur->data;
1276                                 if (number && number->number) {
1277                                         ctsvc_record_set_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY);
1278                                         free(contact->display_name);
1279                                         contact->display_name = SAFE_STRDUP(number->number);
1280                                         contact->display_source_type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NUMBER;
1281                                         break;
1282                                 }
1283                         }
1284                 }
1285
1286                 if (false == ctsvc_record_check_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY) &&
1287                                 contact->emails && contact->emails->records) {
1288                         for (cur = contact->emails->records; cur; cur = cur->next) {
1289                                 ctsvc_email_s *email = cur->data;
1290                                 if (email && email->email_addr) {
1291                                         ctsvc_record_set_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY);
1292                                         free(contact->display_name);
1293                                         contact->display_name = SAFE_STRDUP(email->email_addr);
1294                                         contact->display_source_type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_EMAIL;
1295                                         break;
1296                                 }
1297                         }
1298                 }
1299
1300                 if (ctsvc_record_check_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY)) {
1301                         contact->reverse_display_name = SAFE_STRDUP(contact->display_name);
1302                         contact->sort_name = SAFE_STRDUP(contact->display_name);
1303                         contact->reverse_sort_name = SAFE_STRDUP(contact->display_name);
1304                 } else {
1305                         /* Update as NULL */
1306                         ctsvc_record_set_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY);
1307                 }
1308         }
1309
1310         /* make sortkey */
1311         if (ctsvc_record_check_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY))
1312                 ctsvc_contact_make_sortkey(contact);
1313
1314         return;
1315 }
1316
1317 int ctsvc_get_data_info_name(cts_stmt stmt, contacts_list_h name_list)
1318 {
1319         int ret;
1320         int count;
1321         contacts_record_h record;
1322
1323         ret = contacts_list_get_count(name_list, &count);
1324         RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "contacts_list_get_count Fail(%d)", ret);
1325         RETVM_IF(1 < count, CONTACTS_ERROR_INVALID_PARAMETER, "already had name");
1326
1327         ctsvc_db_name_get_value_from_stmt(stmt, &record, 1);
1328         contacts_list_add(name_list, record);
1329
1330         return CONTACTS_ERROR_NONE;
1331 }
1332
1333 int ctsvc_get_data_info_event(cts_stmt stmt, contacts_list_h list)
1334 {
1335         contacts_record_h record;
1336
1337         ctsvc_db_event_get_value_from_stmt(stmt, &record, 1);
1338         contacts_list_add(list, record);
1339
1340         return CONTACTS_ERROR_NONE;
1341 }
1342
1343 int ctsvc_get_data_info_number(cts_stmt stmt, contacts_list_h number_list)
1344 {
1345         contacts_record_h record;
1346
1347         ctsvc_db_number_get_value_from_stmt(stmt, &record, 1);
1348         contacts_list_add(number_list, record);
1349
1350         return CONTACTS_ERROR_NONE;
1351 }
1352
1353 int ctsvc_get_data_info_email(cts_stmt stmt, contacts_list_h list)
1354 {
1355         contacts_record_h record;
1356
1357         ctsvc_db_email_get_value_from_stmt(stmt, &record, 1);
1358         contacts_list_add(list, record);
1359
1360         return CONTACTS_ERROR_NONE;
1361 }
1362
1363 int ctsvc_get_data_info_address(cts_stmt stmt, contacts_list_h list)
1364 {
1365         contacts_record_h record;
1366
1367         ctsvc_db_address_get_value_from_stmt(stmt, &record, 1);
1368         contacts_list_add(list, record);
1369
1370         return CONTACTS_ERROR_NONE;
1371 }
1372
1373 int ctsvc_get_data_info_messenger(cts_stmt stmt, contacts_list_h list)
1374 {
1375         contacts_record_h record;
1376
1377         ctsvc_db_messenger_get_value_from_stmt(stmt, &record, 1);
1378         contacts_list_add(list, record);
1379
1380         return CONTACTS_ERROR_NONE;
1381 }
1382
1383 int ctsvc_get_data_info_note(cts_stmt stmt, contacts_list_h list)
1384 {
1385         contacts_record_h record;
1386
1387         ctsvc_db_note_get_value_from_stmt(stmt, &record, 1);
1388         contacts_list_add(list, record);
1389
1390         return CONTACTS_ERROR_NONE;
1391 }
1392
1393 int ctsvc_get_data_info_company(cts_stmt stmt, contacts_list_h list)
1394 {
1395         contacts_record_h record;
1396
1397         ctsvc_db_company_get_value_from_stmt(stmt, &record, 1);
1398         contacts_list_add(list, record);
1399
1400         return CONTACTS_ERROR_NONE;
1401 }
1402
1403 int ctsvc_get_data_info_profile(cts_stmt stmt, contacts_list_h list)
1404 {
1405         contacts_record_h record;
1406
1407         ctsvc_db_profile_get_value_from_stmt(stmt, &record, 1);
1408         contacts_list_add(list, record);
1409
1410         return CONTACTS_ERROR_NONE;
1411 }
1412
1413 int ctsvc_get_data_info_relationship(cts_stmt stmt, contacts_list_h list)
1414 {
1415         contacts_record_h record;
1416
1417         ctsvc_db_relationship_get_value_from_stmt(stmt, &record, 1);
1418         contacts_list_add(list, record);
1419
1420         return CONTACTS_ERROR_NONE;
1421 }
1422
1423 int ctsvc_get_data_info_image(cts_stmt stmt, contacts_list_h list)
1424 {
1425         contacts_record_h record;
1426
1427         ctsvc_db_image_get_value_from_stmt(stmt, &record, 1);
1428         contacts_list_add(list, record);
1429
1430         return CONTACTS_ERROR_NONE;
1431 }
1432
1433 int ctsvc_get_data_info_url(cts_stmt stmt, contacts_list_h list)
1434 {
1435         contacts_record_h record;
1436
1437         ctsvc_db_url_get_value_from_stmt(stmt, &record, 1);
1438         contacts_list_add(list, record);
1439
1440         return CONTACTS_ERROR_NONE;
1441 }
1442
1443 int ctsvc_get_data_info_nickname(cts_stmt stmt, contacts_list_h list)
1444 {
1445         contacts_record_h record;
1446
1447         ctsvc_db_nickname_get_value_from_stmt(stmt, &record, 1);
1448         contacts_list_add(list, record);
1449
1450         return CONTACTS_ERROR_NONE;
1451 }
1452
1453 int ctsvc_get_data_info_extension(cts_stmt stmt, contacts_list_h list)
1454 {
1455         contacts_record_h record;
1456
1457         ctsvc_db_extension_get_value_from_stmt(stmt, &record, 1);
1458         contacts_list_add(list, record);
1459
1460         return CONTACTS_ERROR_NONE;
1461 }
1462
1463 int ctsvc_get_data_info_sip(cts_stmt stmt, contacts_list_h list)
1464 {
1465         contacts_record_h record;
1466
1467         ctsvc_db_sip_get_value_from_stmt(stmt, &record, 1);
1468         contacts_list_add(list, record);
1469
1470         return CONTACTS_ERROR_NONE;
1471 }
1472
1473 bool ctsvc_contact_check_default_number(contacts_list_h number_list)
1474 {
1475         bool has_default = false;
1476         ctsvc_number_s *number;
1477         int count;
1478         int ret;
1479
1480         RETV_IF(NULL == number_list, false);
1481
1482         ret = contacts_list_get_count(number_list, &count);
1483         if (CONTACTS_ERROR_NONE != ret || 0 == count)
1484                 return false;
1485
1486         contacts_list_first(number_list);
1487         do {
1488                 contacts_list_get_current_record_p(number_list, (contacts_record_h*)&number);
1489                 if (number && number->number && *number->number) {
1490                         if (number->is_default && false == has_default)
1491                                 has_default = true;
1492                         else if (has_default)
1493                                 number->is_default = false;
1494                 }
1495         } while (CONTACTS_ERROR_NONE == contacts_list_next(number_list));
1496
1497         if (false == has_default) {
1498                 contacts_list_first(number_list);
1499                 do {
1500                         contacts_list_get_current_record_p(number_list, (contacts_record_h*)&number);
1501                         if (number && number->number && *number->number) {
1502                                 number->is_default = true;
1503                                 ctsvc_record_set_property_flag((ctsvc_record_s*)number, _contacts_number.is_default, CTSVC_PROPERTY_FLAG_DIRTY);
1504                                 has_default = true;
1505                                 break;
1506                         }
1507                 } while (CONTACTS_ERROR_NONE == contacts_list_next(number_list));
1508         }
1509         return has_default;
1510 }
1511
1512 bool ctsvc_contact_check_default_email(contacts_list_h email_list)
1513 {
1514         bool has_default = false;
1515         ctsvc_email_s *email;
1516         int count;
1517         int ret;
1518
1519         RETV_IF(NULL == email_list, false);
1520
1521         ret = contacts_list_get_count(email_list, &count);
1522         if (CONTACTS_ERROR_NONE != ret || 0 == count)
1523                 return false;
1524
1525         contacts_list_first(email_list);
1526         do {
1527                 contacts_list_get_current_record_p(email_list, (contacts_record_h*)&email);
1528                 if (email && email->email_addr && *email->email_addr) {
1529                         if (email->is_default && false == has_default)
1530                                 has_default = true;
1531                         else if (has_default)
1532                                 email->is_default = false;
1533                 }
1534         } while (CONTACTS_ERROR_NONE == contacts_list_next(email_list));
1535
1536         if (false == has_default) {
1537                 contacts_list_first(email_list);
1538                 do {
1539                         contacts_list_get_current_record_p(email_list, (contacts_record_h*)&email);
1540                         if (email && email->email_addr && *email->email_addr) {
1541                                 email->is_default = true;
1542                                 ctsvc_record_set_property_flag((ctsvc_record_s*)email, _contacts_email.is_default, CTSVC_PROPERTY_FLAG_DIRTY);
1543                                 has_default = true;
1544                                 break;
1545                         }
1546                 } while (CONTACTS_ERROR_NONE == contacts_list_next(email_list));
1547         }
1548         return has_default;
1549 }
1550
1551 bool ctsvc_contact_check_default_image(contacts_list_h image_list)
1552 {
1553         bool has_default = false;
1554         ctsvc_image_s *image;
1555         int count;
1556         int ret;
1557
1558         RETV_IF(NULL == image_list, false);
1559
1560         ret = contacts_list_get_count(image_list, &count);
1561         if (CONTACTS_ERROR_NONE != ret || 0 == count) {
1562                 DBG("list get count Fail(%d)", count);
1563                 return false;
1564         }
1565
1566         contacts_list_first(image_list);
1567         do {
1568                 contacts_list_get_current_record_p(image_list, (contacts_record_h*)&image);
1569                 if (image && image->path && *image->path) {
1570                         if (image->is_default && false == has_default)
1571                                 has_default = true;
1572                         else if (has_default)
1573                                 image->is_default = false;
1574                 }
1575         } while (CONTACTS_ERROR_NONE == contacts_list_next(image_list));
1576
1577         if (false == has_default) {
1578                 contacts_list_first(image_list);
1579                 do {
1580                         contacts_list_get_current_record_p(image_list, (contacts_record_h*)&image);
1581                         if (image && image->path && *image->path) {
1582                                 image->is_default = true;
1583                                 ctsvc_record_set_property_flag((ctsvc_record_s*)image, _contacts_image.is_default, CTSVC_PROPERTY_FLAG_DIRTY);
1584                                 has_default = true;
1585                                 break;
1586                         }
1587                 } while (CONTACTS_ERROR_NONE == contacts_list_next(image_list));
1588         }
1589         return CONTACTS_ERROR_NONE;
1590 }
1591
1592 bool ctsvc_contact_check_default_address(contacts_list_h address_list)
1593 {
1594         bool has_default = false;
1595         ctsvc_address_s *address;
1596         int count;
1597         int ret;
1598
1599         RETV_IF(NULL == address_list, false);
1600
1601         ret = contacts_list_get_count(address_list, &count);
1602         if (CONTACTS_ERROR_NONE != ret || 0 == count) {
1603                 DBG("list get count Fail(%d)", count);
1604                 return false;
1605         }
1606
1607         contacts_list_first(address_list);
1608         do {
1609                 contacts_list_get_current_record_p(address_list, (contacts_record_h*)&address);
1610                 if (address &&
1611                                 (address->pobox || address->postalcode || address->region || address->locality
1612                                  || address->street || address->extended || address->country)) {
1613                         if (address->is_default && false == has_default)
1614                                 has_default = true;
1615                         else if (has_default)
1616                                 address->is_default = false;
1617                 }
1618         } while (CONTACTS_ERROR_NONE == contacts_list_next(address_list));
1619
1620         if (false == has_default) {
1621                 contacts_list_first(address_list);
1622                 do {
1623                         contacts_list_get_current_record_p(address_list, (contacts_record_h*)&address);
1624                         if (address &&
1625                                         (address->pobox || address->postalcode || address->region || address->locality
1626                                          || address->street || address->extended || address->country)) {
1627                                 address->is_default = true;
1628                                 ctsvc_record_set_property_flag((ctsvc_record_s*)address, _contacts_address.is_default, CTSVC_PROPERTY_FLAG_DIRTY);
1629                                 has_default = true;
1630                                 break;
1631                         }
1632                 } while (CONTACTS_ERROR_NONE == contacts_list_next(address_list));
1633         }
1634         return CONTACTS_ERROR_NONE;
1635 }
1636
1637 int ctsvc_contact_update_data_name(contacts_list_h name_list, int contact_id, bool is_my_profile)
1638 {
1639         CTS_FN_CALL;
1640         int ret = CONTACTS_ERROR_NONE;
1641         contacts_record_h record;
1642         ctsvc_name_s *name;
1643         ctsvc_list_s *list = (ctsvc_list_s*)name_list;
1644         GList *cursor;
1645         RETV_IF(NULL == name_list, CONTACTS_ERROR_INVALID_PARAMETER);
1646
1647         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1648                 name = cursor->data;
1649                 ctsvc_db_name_delete(name->id, is_my_profile);
1650         }
1651
1652         contacts_list_first(name_list);
1653         contacts_list_get_current_record_p(name_list, &record);
1654         if (record) {
1655                 name = (ctsvc_name_s*)record;
1656                 if (0 < name->id) {
1657                         if (name->first || name->last || name->addition || name->prefix || name->suffix
1658                                         || name->phonetic_first || name->phonetic_middle || name->phonetic_last) {
1659                                 ret = ctsvc_db_name_update(record, is_my_profile);
1660                         } else {
1661                                 ret = ctsvc_db_name_delete(name->id, is_my_profile);
1662                         }
1663                 } else {
1664                         ret = ctsvc_db_name_insert(record, contact_id, is_my_profile, NULL);
1665                 }
1666                 if (CONTACTS_ERROR_DB == ret)
1667                         ERR("return(%d)", ret);
1668         }
1669
1670         return ret;
1671 }
1672
1673 int ctsvc_contact_update_data_company(contacts_list_h company_list, int contact_id, bool is_my_profile)
1674 {
1675         CTS_FN_CALL;
1676         int ret = CONTACTS_ERROR_NONE;
1677         contacts_record_h record = NULL;
1678         int count = 0;
1679         ctsvc_list_s *list = (ctsvc_list_s*)company_list;
1680         ctsvc_company_s *company;
1681         GList *cursor;
1682
1683         RETV_IF(NULL == company_list, CONTACTS_ERROR_INVALID_PARAMETER);
1684
1685         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1686                 company = cursor->data;
1687                 ctsvc_db_company_delete(company->id, is_my_profile);
1688         }
1689
1690         ret = contacts_list_get_count(company_list, &count);
1691         if (0 == count)
1692                 return CONTACTS_ERROR_NONE;
1693
1694         contacts_list_first(company_list);
1695         do {
1696                 contacts_list_get_current_record_p(company_list, &record);
1697                 company = (ctsvc_company_s*)record;
1698                 if (0 < company->id) {
1699                         if (company->name || company->department || company->job_title || company->role
1700                                         || company->assistant_name || company->logo || company->location || company->description
1701                                         || company->phonetic_name) {
1702                                 ret = ctsvc_db_company_update(record, contact_id, is_my_profile);
1703                         } else {
1704                                 ret = ctsvc_db_company_delete(company->id, is_my_profile);
1705                         }
1706                 } else {
1707                         ret = ctsvc_db_company_insert(record, contact_id, is_my_profile, NULL);
1708                 }
1709                 if (CONTACTS_ERROR_DB == ret) {
1710                         ERR("return (%d)", ret);
1711                         break;
1712                 }
1713         } while (CONTACTS_ERROR_NONE == contacts_list_next(company_list));
1714
1715         return ret;
1716 }
1717
1718 int ctsvc_contact_update_data_note(contacts_list_h note_list, int contact_id, bool is_my_profile)
1719 {
1720         CTS_FN_CALL;
1721         int ret = CONTACTS_ERROR_NONE;
1722         contacts_record_h record = NULL;
1723         int count = 0;
1724         ctsvc_list_s *list = (ctsvc_list_s*)note_list;
1725         ctsvc_note_s *note;
1726         GList *cursor;
1727
1728         RETV_IF(NULL == note_list, CONTACTS_ERROR_INVALID_PARAMETER);
1729
1730         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1731                 note = cursor->data;
1732                 ctsvc_db_note_delete(note->id, is_my_profile);
1733         }
1734
1735         ret = contacts_list_get_count(note_list, &count);
1736         if (0 == count)
1737                 return CONTACTS_ERROR_NONE;
1738
1739         contacts_list_first(note_list);
1740         do {
1741                 contacts_list_get_current_record_p(note_list, &record);
1742                 note = (ctsvc_note_s*)record;
1743                 if (0 < note->id) {
1744                         if (note->note)
1745                                 ret = ctsvc_db_note_update(record, is_my_profile);
1746                         else
1747                                 ret = ctsvc_db_note_delete(note->id, is_my_profile);
1748                 } else {
1749                         ret = ctsvc_db_note_insert(record, contact_id, is_my_profile, NULL);
1750                 }
1751                 if (CONTACTS_ERROR_DB == ret) {
1752                         ERR("return (%d)", ret);
1753                         break;
1754                 }
1755         } while (CONTACTS_ERROR_NONE == contacts_list_next(note_list));
1756
1757         return ret;
1758 }
1759
1760 int ctsvc_contact_update_data_event(contacts_list_h event_list, int contact_id, bool is_my_profile)
1761 {
1762         CTS_FN_CALL;
1763         int ret = CONTACTS_ERROR_NONE;
1764         contacts_record_h record = NULL;
1765         int count = 0;
1766         ctsvc_list_s *list = (ctsvc_list_s*)event_list;
1767         ctsvc_event_s *event;
1768         GList *cursor;
1769
1770         RETV_IF(NULL == event_list, CONTACTS_ERROR_INVALID_PARAMETER);
1771
1772         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1773                 event = cursor->data;
1774                 ctsvc_db_event_delete(event->id, is_my_profile);
1775         }
1776
1777         ret = contacts_list_get_count(event_list, &count);
1778         if (0 == count)
1779                 return CONTACTS_ERROR_NONE;
1780
1781         contacts_list_first(event_list);
1782         do {
1783                 contacts_list_get_current_record_p(event_list, &record);
1784                 event = (ctsvc_event_s*)record;
1785                 if (0 < event->id) {
1786                         if (0 < event->date)
1787                                 ret = ctsvc_db_event_update(record, is_my_profile);
1788                         else
1789                                 ret = ctsvc_db_event_delete(event->id, is_my_profile);
1790                 } else {
1791                         ret = ctsvc_db_event_insert(record, contact_id, is_my_profile, NULL);
1792                 }
1793                 if (CONTACTS_ERROR_DB == ret) {
1794                         ERR("return (%d)", ret);
1795                         break;
1796                 }
1797         } while (CONTACTS_ERROR_NONE == contacts_list_next(event_list));
1798
1799         return ret;
1800 }
1801
1802 int ctsvc_contact_update_data_messenger(contacts_list_h messenger_list, int contact_id, bool is_my_profile)
1803 {
1804         CTS_FN_CALL;
1805         int ret = CONTACTS_ERROR_NONE;
1806         contacts_record_h record = NULL;
1807         int count = 0;
1808         ctsvc_list_s *list = (ctsvc_list_s*)messenger_list;
1809         ctsvc_messenger_s *messenger;
1810         GList *cursor;
1811
1812         RETV_IF(NULL == messenger_list, CONTACTS_ERROR_INVALID_PARAMETER);
1813
1814         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1815                 messenger = cursor->data;
1816                 ctsvc_db_messenger_delete(messenger->id, is_my_profile);
1817         }
1818
1819         ret = contacts_list_get_count(messenger_list, &count);
1820         if (0 == count)
1821                 return CONTACTS_ERROR_NONE;
1822
1823         contacts_list_first(messenger_list);
1824         do {
1825                 contacts_list_get_current_record_p(messenger_list, &record);
1826                 messenger = (ctsvc_messenger_s*)record;
1827                 if (0 < messenger->id) {
1828                         if (messenger->im_id)
1829                                 ret = ctsvc_db_messenger_update(record, is_my_profile);
1830                         else
1831                                 ret = ctsvc_db_messenger_delete(messenger->id, is_my_profile);
1832                 } else {
1833                         ret = ctsvc_db_messenger_insert(record, contact_id, is_my_profile, NULL);
1834                 }
1835                 if (CONTACTS_ERROR_DB == ret) {
1836                         ERR("return (%d)", ret);
1837                         break;
1838                 }
1839         } while (CONTACTS_ERROR_NONE == contacts_list_next(messenger_list));
1840
1841         return ret;
1842 }
1843
1844 int ctsvc_contact_update_data_address(contacts_list_h address_list, int contact_id, bool is_my_profile)
1845 {
1846         CTS_FN_CALL;
1847         int ret = CONTACTS_ERROR_NONE;
1848         contacts_record_h record = NULL;
1849         int count = 0;
1850         ctsvc_list_s *list = (ctsvc_list_s*)address_list;
1851         ctsvc_address_s *address;
1852         GList *cursor;
1853
1854         RETV_IF(NULL == address_list, CONTACTS_ERROR_INVALID_PARAMETER);
1855
1856         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1857                 address = cursor->data;
1858                 ctsvc_db_address_delete(address->id, is_my_profile);
1859         }
1860
1861         ret = contacts_list_get_count(address_list, &count);
1862         if (0 == count)
1863                 return CONTACTS_ERROR_NONE;
1864
1865         contacts_list_first(address_list);
1866         do {
1867                 contacts_list_get_current_record_p(address_list, &record);
1868                 address = (ctsvc_address_s*)record;
1869                 if (0 < address->id) {
1870                         if (address->pobox || address->postalcode || address->region || address->locality
1871                                         || address->street || address->extended || address->country) {
1872                                 ret = ctsvc_db_address_update(record, is_my_profile);
1873                         } else {
1874                                 ret = ctsvc_db_address_delete(address->id, is_my_profile);
1875                         }
1876                 } else {
1877                         ret = ctsvc_db_address_insert(record, contact_id, is_my_profile, NULL);
1878                 }
1879                 if (CONTACTS_ERROR_DB == ret) {
1880                         ERR("return (%d)", ret);
1881                         break;
1882                 }
1883         } while (CONTACTS_ERROR_NONE == contacts_list_next(address_list));
1884
1885         return ret;
1886 }
1887
1888 int ctsvc_contact_update_data_url(contacts_list_h url_list, int contact_id, bool is_my_profile)
1889 {
1890         CTS_FN_CALL;
1891         int ret = CONTACTS_ERROR_NONE;
1892         contacts_record_h record = NULL;
1893         int count = 0;
1894         ctsvc_list_s *list = (ctsvc_list_s*)url_list;
1895         ctsvc_url_s *url;
1896         GList *cursor;
1897
1898         RETV_IF(NULL == url_list, CONTACTS_ERROR_INVALID_PARAMETER);
1899
1900         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1901                 url = cursor->data;
1902                 ctsvc_db_url_delete(url->id, is_my_profile);
1903         }
1904
1905         ret = contacts_list_get_count(url_list, &count);
1906         if (0 == count)
1907                 return CONTACTS_ERROR_NONE;
1908
1909         contacts_list_first(url_list);
1910         do {
1911                 contacts_list_get_current_record_p(url_list, &record);
1912                 url = (ctsvc_url_s*)record;
1913                 if (0 < url->id) {
1914                         if (url->url)
1915                                 ret = ctsvc_db_url_update(record, is_my_profile);
1916                         else
1917                                 ret = ctsvc_db_url_delete(url->id, is_my_profile);
1918                 } else {
1919                         ret = ctsvc_db_url_insert(record, contact_id, is_my_profile, NULL);
1920                 }
1921                 if (CONTACTS_ERROR_DB == ret) {
1922                         ERR("return (%d)", ret);
1923                         break;
1924                 }
1925         } while (CONTACTS_ERROR_NONE == contacts_list_next(url_list));
1926
1927         return ret;
1928 }
1929
1930 int ctsvc_contact_update_data_profile(contacts_list_h profile_list, int contact_id, bool is_my_profile)
1931 {
1932         CTS_FN_CALL;
1933         int ret = CONTACTS_ERROR_NONE;
1934         contacts_record_h record = NULL;
1935         int count = 0;
1936         ctsvc_list_s *list = (ctsvc_list_s*)profile_list;
1937         ctsvc_profile_s *profile;
1938         GList *cursor;
1939
1940         RETV_IF(NULL == profile_list, CONTACTS_ERROR_INVALID_PARAMETER);
1941
1942         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1943                 profile = cursor->data;
1944                 ctsvc_db_profile_delete(profile->id, is_my_profile);
1945         }
1946         ret = contacts_list_get_count(profile_list, &count);
1947         if (0 == count)
1948                 return CONTACTS_ERROR_NONE;
1949
1950         contacts_list_first(profile_list);
1951         do {
1952                 contacts_list_get_current_record_p(profile_list, &record);
1953                 profile = (ctsvc_profile_s*)record;
1954                 if (0 < profile->id) {
1955                         if (profile->text)
1956                                 ret = ctsvc_db_profile_update(record, is_my_profile);
1957                         else
1958                                 ret = ctsvc_db_profile_delete(profile->id, is_my_profile);
1959                 } else {
1960                         ret = ctsvc_db_profile_insert(record, contact_id, is_my_profile, NULL);
1961                 }
1962                 if (CONTACTS_ERROR_DB == ret) {
1963                         ERR("return (%d)", ret);
1964                         break;
1965                 }
1966         } while (CONTACTS_ERROR_NONE == contacts_list_next(profile_list));
1967
1968         return ret;
1969 }
1970
1971 int ctsvc_contact_update_data_relationship(contacts_list_h relationship_list, int contact_id, bool is_my_profile)
1972 {
1973         CTS_FN_CALL;
1974         int ret = CONTACTS_ERROR_NONE;
1975         contacts_record_h record = NULL;
1976         int count = 0;
1977         ctsvc_list_s *list = (ctsvc_list_s*)relationship_list;
1978         ctsvc_relationship_s *relationship;
1979         GList *cursor;
1980
1981         RETV_IF(NULL == relationship_list, CONTACTS_ERROR_INVALID_PARAMETER);
1982
1983         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1984                 relationship = cursor->data;
1985                 ctsvc_db_relationship_delete(relationship->id, is_my_profile);
1986         }
1987
1988         ret = contacts_list_get_count(relationship_list, &count);
1989         if (0 == count)
1990                 return CONTACTS_ERROR_NONE;
1991
1992         contacts_list_first(relationship_list);
1993         do {
1994                 contacts_list_get_current_record_p(relationship_list, &record);
1995                 relationship = (ctsvc_relationship_s*)record;
1996                 if (0 < relationship->id) {
1997                         if (relationship->name)
1998                                 ret = ctsvc_db_relationship_update(record, is_my_profile);
1999                         else
2000                                 ret = ctsvc_db_relationship_delete(relationship->id, is_my_profile);
2001                 } else {
2002                         ret = ctsvc_db_relationship_insert(record, contact_id, is_my_profile, NULL);
2003                 }
2004                 if (CONTACTS_ERROR_DB == ret) {
2005                         ERR("return (%d)", ret);
2006                         break;
2007                 }
2008         } while (CONTACTS_ERROR_NONE == contacts_list_next(relationship_list));
2009
2010         return ret;
2011 }
2012
2013 int ctsvc_contact_update_data_image(contacts_list_h image_list, int contact_id, bool is_my_profile)
2014 {
2015         CTS_FN_CALL;
2016         int ret = CONTACTS_ERROR_NONE;
2017         contacts_record_h record = NULL;
2018         int count = 0;
2019         ctsvc_list_s *list = (ctsvc_list_s*)image_list;
2020         ctsvc_image_s *image;
2021         GList *cursor;
2022
2023         RETV_IF(NULL == image_list, CONTACTS_ERROR_INVALID_PARAMETER);
2024
2025         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
2026                 image = cursor->data;
2027                 ctsvc_db_image_delete(image->id, is_my_profile);
2028         }
2029
2030         ret = contacts_list_get_count(image_list, &count);
2031         if (0 == count)
2032                 return CONTACTS_ERROR_NONE;
2033
2034         contacts_list_first(image_list);
2035         do {
2036                 contacts_list_get_current_record_p(image_list, &record);
2037                 image = (ctsvc_image_s*)record;
2038                 if (CTSVC_PROPERTY_FLAG_DIRTY & image->base.property_flag) {
2039                         if (0 < image->id) {
2040                                 if (image->path)
2041                                         ret = ctsvc_db_image_update(record, contact_id, is_my_profile);
2042                                 else
2043                                         ret = ctsvc_db_image_delete(image->id, is_my_profile);
2044                         } else {
2045                                 ret = ctsvc_db_image_insert(record, contact_id, is_my_profile, NULL);
2046                         }
2047                 }
2048                 if (CONTACTS_ERROR_DB == ret) {
2049                         ERR("return (%d)", ret);
2050                         break;
2051                 }
2052         } while (CONTACTS_ERROR_NONE == contacts_list_next(image_list));
2053
2054         return ret;
2055 }
2056
2057 int ctsvc_contact_update_data_nickname(contacts_list_h nickname_list, int contact_id, bool is_my_profile)
2058 {
2059         CTS_FN_CALL;
2060         int ret = CONTACTS_ERROR_NONE;
2061         contacts_record_h record = NULL;
2062         int count = 0;
2063         ctsvc_list_s *list = (ctsvc_list_s*)nickname_list;
2064         ctsvc_nickname_s *nickname;
2065         GList *cursor;
2066
2067         RETV_IF(NULL == nickname_list, CONTACTS_ERROR_INVALID_PARAMETER);
2068
2069         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
2070                 nickname = cursor->data;
2071                 ctsvc_db_nickname_delete(nickname->id, is_my_profile);
2072         }
2073
2074         ret = contacts_list_get_count(nickname_list, &count);
2075         if (0 == count)
2076                 return CONTACTS_ERROR_NONE;
2077
2078         contacts_list_first(nickname_list);
2079         do {
2080                 contacts_list_get_current_record_p(nickname_list, &record);
2081                 nickname = (ctsvc_nickname_s*)record;
2082                 if (0 < nickname->id) {
2083                         if (nickname->nickname)
2084                                 ret = ctsvc_db_nickname_update(record, is_my_profile);
2085                         else
2086                                 ret = ctsvc_db_nickname_delete(nickname->id, is_my_profile);
2087                 } else {
2088                         ret = ctsvc_db_nickname_insert(record, contact_id, is_my_profile, NULL);
2089                 }
2090                 if (CONTACTS_ERROR_DB == ret) {
2091                         ERR("return (%d)", ret);
2092                         break;
2093                 }
2094         } while (CONTACTS_ERROR_NONE == contacts_list_next(nickname_list));
2095
2096         return ret;
2097 }
2098
2099 int ctsvc_contact_update_data_extension(contacts_list_h extension_list, int contact_id, bool is_my_profile)
2100 {
2101         CTS_FN_CALL;
2102         int ret = CONTACTS_ERROR_NONE;
2103         contacts_record_h record = NULL;
2104         int count = 0;
2105         ctsvc_list_s *list = (ctsvc_list_s*)extension_list;
2106         ctsvc_extension_s *extension;
2107         GList *cursor;
2108
2109         RETV_IF(NULL == extension_list, CONTACTS_ERROR_INVALID_PARAMETER);
2110
2111         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
2112                 extension = cursor->data;
2113                 ctsvc_db_extension_delete(extension->id, is_my_profile);
2114         }
2115
2116         ret = contacts_list_get_count(extension_list, &count);
2117         if (0 == count)
2118                 return CONTACTS_ERROR_NONE;
2119
2120         contacts_list_first(extension_list);
2121         do {
2122                 contacts_list_get_current_record_p(extension_list, &record);
2123                 extension = (ctsvc_extension_s*)record;
2124                 if (0 < extension->id) {
2125                         if (extension->data2 || extension->data3 || extension->data4 || extension->data5
2126                                         || extension->data6 || extension->data7 || extension->data8 || extension->data9
2127                                         || extension->data10 || extension->data11 || extension->data12) {
2128                                 ret = ctsvc_db_extension_update(record);
2129                         } else {
2130                                 ret = ctsvc_db_extension_delete(extension->id, is_my_profile);
2131                         }
2132                 } else {
2133                         ret = ctsvc_db_extension_insert(record, contact_id, is_my_profile, NULL);
2134                 }
2135                 if (CONTACTS_ERROR_DB == ret) {
2136                         ERR("return (%d)", ret);
2137                         break;
2138                 }
2139         } while (CONTACTS_ERROR_NONE == contacts_list_next(extension_list));
2140
2141         return ret;
2142 }
2143
2144 int ctsvc_contact_update_data_sip(contacts_list_h sip_list, int contact_id, bool is_my_profile)
2145 {
2146         CTS_FN_CALL;
2147         int ret = CONTACTS_ERROR_NONE;
2148         contacts_record_h record = NULL;
2149         int count = 0;
2150         ctsvc_list_s *list = (ctsvc_list_s*)sip_list;
2151         ctsvc_sip_s *sip;
2152         GList *cursor;
2153
2154         RETV_IF(NULL == sip_list, CONTACTS_ERROR_INVALID_PARAMETER);
2155
2156         for (cursor = list->deleted_records;cursor;cursor=cursor->next) {
2157                 sip = (ctsvc_sip_s *)cursor->data;
2158                 ctsvc_db_sip_delete(sip->id, is_my_profile);
2159         }
2160
2161         ret = contacts_list_get_count(sip_list, &count);
2162         if (0 == count)
2163                 return CONTACTS_ERROR_NONE;
2164
2165         contacts_list_first(sip_list);
2166         do {
2167                 contacts_list_get_current_record_p(sip_list, &record);
2168                 sip = (ctsvc_sip_s*)record;
2169                 if (0 < sip->id) {
2170                         if (sip->address)
2171                                 ret = ctsvc_db_sip_update(record, is_my_profile);
2172                         else
2173                                 ret = ctsvc_db_sip_delete(sip->id, is_my_profile);
2174                 }
2175                 else
2176                         ret = ctsvc_db_sip_insert(record, contact_id, is_my_profile, NULL);
2177                 if (CONTACTS_ERROR_DB == ret) {
2178                         ERR("DB error : return (%d)", ret);
2179                         break;
2180                 }
2181         } while (CONTACTS_ERROR_NONE == contacts_list_next(sip_list));
2182
2183         return ret;
2184 }
2185
2186 int ctsvc_contact_update_data_number(contacts_list_h number_list,
2187                 int contact_id, bool is_my_profile, bool *had_phonenumber)
2188 {
2189         CTS_FN_CALL;
2190         int ret = CONTACTS_ERROR_NONE;
2191         contacts_record_h record = NULL;
2192         int count = 0;
2193         ctsvc_list_s *list = (ctsvc_list_s*)number_list;
2194         ctsvc_number_s *number;
2195         GList *cursor;
2196         bool had = false;
2197         *had_phonenumber = false;
2198
2199         RETV_IF(NULL == number_list, CONTACTS_ERROR_INVALID_PARAMETER);
2200
2201         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
2202                 number = cursor->data;
2203                 ctsvc_db_number_delete(number->id, is_my_profile);
2204         }
2205
2206         ret = contacts_list_get_count(number_list, &count);
2207         if (0 == count)
2208                 return CONTACTS_ERROR_NONE;
2209
2210         contacts_list_first(number_list);
2211         do {
2212                 contacts_list_get_current_record_p(number_list, &record);
2213                 number = (ctsvc_number_s*)record;
2214                 if (0 < number->id) {
2215                         if (number->number) {
2216                                 ret = ctsvc_db_number_update(record, is_my_profile);
2217                                 had = true;
2218                         } else {
2219                                 ret = ctsvc_db_number_delete(number->id, is_my_profile);
2220                         }
2221                 } else if (number->number) {
2222                         ret = ctsvc_db_number_insert(record, contact_id, is_my_profile, NULL);
2223                         had = true;
2224                 }
2225                 if (CONTACTS_ERROR_DB == ret) {
2226                         ERR("return (%d)", ret);
2227                         break;
2228                 }
2229         } while (CONTACTS_ERROR_NONE == contacts_list_next(number_list));
2230
2231         *had_phonenumber = had;
2232         return ret;
2233 }
2234
2235 int ctsvc_contact_update_data_email(contacts_list_h email_list,
2236                 int contact_id, bool is_my_profile, bool *had_email)
2237 {
2238         CTS_FN_CALL;
2239         int ret = CONTACTS_ERROR_NONE;
2240         contacts_record_h record = NULL;
2241         int count = 0;
2242         ctsvc_list_s *list = (ctsvc_list_s*)email_list;
2243         ctsvc_email_s *email;
2244         GList *cursor;
2245         bool had = false;
2246         *had_email = false;
2247
2248         RETV_IF(NULL == email_list, CONTACTS_ERROR_INVALID_PARAMETER);
2249
2250         for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
2251                 email = cursor->data;
2252                 ctsvc_db_email_delete(email->id, is_my_profile);
2253         }
2254
2255         ret = contacts_list_get_count(email_list, &count);
2256         if (0 == count)
2257                 return CONTACTS_ERROR_NONE;
2258
2259         contacts_list_first(email_list);
2260         do {
2261                 contacts_list_get_current_record_p(email_list, &record);
2262                 email = (ctsvc_email_s*)record;
2263
2264                 if (0 < email->id) {
2265                         if (email->email_addr) {
2266                                 ret = ctsvc_db_email_update(record, is_my_profile);
2267                                 had = true;
2268                         } else {
2269                                 ret = ctsvc_db_email_delete(email->id, is_my_profile);
2270                         }
2271                 } else if (email->email_addr) {
2272                         ret = ctsvc_db_email_insert(record, contact_id, is_my_profile, NULL);
2273                         had = true;
2274                 }
2275                 if (CONTACTS_ERROR_DB == ret) {
2276                         ERR("return (%d)", ret);
2277                         break;
2278                 }
2279         } while (CONTACTS_ERROR_NONE == contacts_list_next(email_list));
2280
2281         *had_email = had;
2282         return ret;
2283 }
2284
2285 int ctsvc_contact_insert_data_name(contacts_list_h name_list, int contact_id, bool is_my_profile)
2286 {
2287         CTS_FN_CALL;
2288         int ret = CONTACTS_ERROR_NONE;
2289         contacts_record_h record;
2290         RETV_IF(NULL == name_list, CONTACTS_ERROR_INVALID_PARAMETER);
2291
2292         contacts_list_first(name_list);
2293         contacts_list_get_current_record_p(name_list, &record);
2294         if (record) {
2295                 ret = ctsvc_db_name_insert(record, contact_id, is_my_profile, NULL);
2296                 if (CONTACTS_ERROR_DB == ret)
2297                         ERR("ctsvc_db_name_insert() Fail");
2298         }
2299         return ret;
2300 }
2301
2302 int ctsvc_contact_insert_data_number(contacts_list_h number_list, int contact_id, bool is_my_profile)
2303 {
2304         CTS_FN_CALL;
2305         int ret = CONTACTS_ERROR_NONE;
2306         contacts_record_h record;
2307         int count = 0;
2308
2309         RETV_IF(NULL == number_list, CONTACTS_ERROR_INVALID_PARAMETER);
2310         ret = contacts_list_get_count(number_list, &count);
2311         if (0 == count)
2312                 return CONTACTS_ERROR_NONE;
2313
2314         contacts_list_first(number_list);
2315         do {
2316                 contacts_list_get_current_record_p(number_list, &record);
2317                 ret = ctsvc_db_number_insert(record, contact_id, is_my_profile, NULL);
2318                 if (CONTACTS_ERROR_DB == ret) {
2319                         ERR("ctsvc_db_number_insert");
2320                         break;
2321                 }
2322         } while (CONTACTS_ERROR_NONE == contacts_list_next(number_list));
2323
2324         return ret;
2325 }
2326
2327 int ctsvc_contact_insert_data_email(contacts_list_h email_list, int contact_id, bool is_my_profile)
2328 {
2329         CTS_FN_CALL;
2330         int ret = CONTACTS_ERROR_NONE;
2331         contacts_record_h record;
2332         int count = 0;
2333
2334         RETV_IF(NULL == email_list, CONTACTS_ERROR_INVALID_PARAMETER);
2335         ret = contacts_list_get_count(email_list, &count);
2336         if (0 == count)
2337                 return CONTACTS_ERROR_NONE;
2338
2339         contacts_list_first(email_list);
2340         do {
2341                 contacts_list_get_current_record_p(email_list, &record);
2342                 ret = ctsvc_db_email_insert(record, contact_id, is_my_profile, NULL);
2343                 if (CONTACTS_ERROR_DB == ret) {
2344                         ERR("ctsvc_db_email_insert");
2345                         break;
2346                 }
2347         } while (CONTACTS_ERROR_NONE == contacts_list_next(email_list));
2348
2349         return ret;
2350 }
2351
2352 int ctsvc_contact_insert_data_profile(contacts_list_h profile_list, int contact_id, bool is_my_profile)
2353 {
2354         CTS_FN_CALL;
2355         int ret = CONTACTS_ERROR_NONE;
2356         contacts_record_h record;
2357         int count = 0;
2358
2359         RETV_IF(NULL == profile_list, CONTACTS_ERROR_INVALID_PARAMETER);
2360         ret = contacts_list_get_count(profile_list, &count);
2361         if (0 == count)
2362                 return CONTACTS_ERROR_NONE;
2363
2364         contacts_list_first(profile_list);
2365         do {
2366                 contacts_list_get_current_record_p(profile_list, &record);
2367                 ret = ctsvc_db_profile_insert(record, contact_id, is_my_profile, NULL);
2368                 if (CONTACTS_ERROR_DB == ret) {
2369                         ERR("ctsvc_db_profile_insert");
2370                         break;
2371                 }
2372         } while (CONTACTS_ERROR_NONE == contacts_list_next(profile_list));
2373
2374         return ret;
2375 }
2376
2377 int ctsvc_contact_insert_data_company(contacts_list_h company_list, int contact_id, bool is_my_profile)
2378 {
2379         CTS_FN_CALL;
2380         int ret = CONTACTS_ERROR_NONE;
2381         contacts_record_h record = NULL;
2382         int count = 0;
2383
2384         RETV_IF(NULL == company_list, CONTACTS_ERROR_INVALID_PARAMETER);
2385         ret = contacts_list_get_count(company_list, &count);
2386         if (0 == count)
2387                 return CONTACTS_ERROR_NONE;
2388
2389         contacts_list_first(company_list);
2390         do {
2391                 contacts_list_get_current_record_p(company_list, &record);
2392                 ret = ctsvc_db_company_insert(record, contact_id, is_my_profile, NULL);
2393                 if (CONTACTS_ERROR_DB == ret) {
2394                         ERR("ctsvc_db_company_insert");
2395                         break;
2396                 }
2397         } while (CONTACTS_ERROR_NONE == contacts_list_next(company_list));
2398
2399         return ret;
2400 }
2401
2402 int ctsvc_contact_insert_data_note(contacts_list_h note_list, int contact_id, bool is_my_profile)
2403 {
2404         CTS_FN_CALL;
2405         int ret = CONTACTS_ERROR_NONE;
2406         contacts_record_h record = NULL;
2407         int count = 0;
2408
2409         RETV_IF(NULL == note_list, CONTACTS_ERROR_INVALID_PARAMETER);
2410         ret = contacts_list_get_count(note_list, &count);
2411         if (0 == count)
2412                 return CONTACTS_ERROR_NONE;
2413
2414         contacts_list_first(note_list);
2415         do {
2416                 contacts_list_get_current_record_p(note_list, &record);
2417                 if (record) {
2418                         ret = ctsvc_db_note_insert(record, contact_id, is_my_profile, NULL);
2419                         if (CONTACTS_ERROR_DB == ret) {
2420                                 ERR("ctsvc_db_note_insert");
2421                                 break;
2422                         }
2423                 }
2424         } while (CONTACTS_ERROR_NONE == contacts_list_next(note_list));
2425         return ret;
2426 }
2427
2428 int ctsvc_contact_insert_data_event(contacts_list_h event_list, int contact_id, bool is_my_profile)
2429 {
2430         CTS_FN_CALL;
2431         int ret = CONTACTS_ERROR_NONE;
2432         contacts_record_h record;
2433         int count = 0;
2434
2435         RETV_IF(NULL == event_list, CONTACTS_ERROR_INVALID_PARAMETER);
2436         ret = contacts_list_get_count(event_list, &count);
2437         if (0 == count)
2438                 return CONTACTS_ERROR_NONE;
2439
2440         contacts_list_first(event_list);
2441         do {
2442                 contacts_list_get_current_record_p(event_list, &record);
2443                 ret = ctsvc_db_event_insert(record, contact_id, is_my_profile, NULL);
2444                 if (CONTACTS_ERROR_DB == ret) {
2445                         ERR("ctsvc_db_event_insert");
2446                         break;
2447                 }
2448         } while (CONTACTS_ERROR_NONE == contacts_list_next(event_list));
2449
2450         return ret;
2451 }
2452
2453 int ctsvc_contact_insert_data_messenger(contacts_list_h messenger_list, int contact_id, bool is_my_profile)
2454 {
2455         CTS_FN_CALL;
2456         int ret = CONTACTS_ERROR_NONE;
2457         contacts_record_h record;
2458         int count = 0;
2459
2460         RETV_IF(NULL == messenger_list, CONTACTS_ERROR_INVALID_PARAMETER);
2461         ret = contacts_list_get_count(messenger_list, &count);
2462         if (0 == count)
2463                 return CONTACTS_ERROR_NONE;
2464
2465         contacts_list_first(messenger_list);
2466         do {
2467                 contacts_list_get_current_record_p(messenger_list, &record);
2468                 ret = ctsvc_db_messenger_insert(record, contact_id, is_my_profile, NULL);
2469                 if (CONTACTS_ERROR_DB == ret) {
2470                         ERR("ctsvc_db_messenger_insert");
2471                         break;
2472                 }
2473         } while (CONTACTS_ERROR_NONE == contacts_list_next(messenger_list));
2474
2475         return ret;
2476 }
2477
2478 int ctsvc_contact_insert_data_address(contacts_list_h address_list, int contact_id, bool is_my_profile)
2479 {
2480         CTS_FN_CALL;
2481         int ret = CONTACTS_ERROR_NONE;
2482         contacts_record_h record;
2483         int count = 0;
2484
2485         RETV_IF(NULL == address_list, CONTACTS_ERROR_INVALID_PARAMETER);
2486         ret = contacts_list_get_count(address_list, &count);
2487         if (0 == count)
2488                 return CONTACTS_ERROR_NONE;
2489
2490         contacts_list_first(address_list);
2491         do {
2492                 contacts_list_get_current_record_p(address_list, &record);
2493                 ret = ctsvc_db_address_insert(record, contact_id, is_my_profile, NULL);
2494                 if (CONTACTS_ERROR_DB == ret) {
2495                         ERR("ctsvc_db_address_insert");
2496                         break;
2497                 }
2498         } while (CONTACTS_ERROR_NONE == contacts_list_next(address_list));
2499
2500         return ret;
2501 }
2502
2503 int ctsvc_contact_insert_data_url(contacts_list_h url_list, int contact_id, bool is_my_profile)
2504 {
2505         CTS_FN_CALL;
2506         int ret = CONTACTS_ERROR_NONE;
2507         contacts_record_h record;
2508         int count = 0;
2509
2510         RETV_IF(NULL == url_list, CONTACTS_ERROR_INVALID_PARAMETER);
2511         ret = contacts_list_get_count(url_list, &count);
2512         if (0 == count)
2513                 return CONTACTS_ERROR_NONE;
2514
2515         contacts_list_first(url_list);
2516         do {
2517                 contacts_list_get_current_record_p(url_list, &record);
2518                 ret = ctsvc_db_url_insert(record, contact_id, is_my_profile, NULL);
2519                 if (CONTACTS_ERROR_DB == ret) {
2520                         ERR("ctsvc_db_url_insert");
2521                         break;
2522                 }
2523         } while (CONTACTS_ERROR_NONE == contacts_list_next(url_list));
2524
2525         return ret;
2526 }
2527
2528 int ctsvc_contact_insert_data_nickname(contacts_list_h nickname_list, int contact_id, bool is_my_profile)
2529 {
2530         CTS_FN_CALL;
2531         int ret = CONTACTS_ERROR_NONE;
2532         contacts_record_h record;
2533         int count = 0;
2534
2535         RETV_IF(NULL == nickname_list, CONTACTS_ERROR_INVALID_PARAMETER);
2536         ret = contacts_list_get_count(nickname_list, &count);
2537         if (0 == count)
2538                 return CONTACTS_ERROR_NONE;
2539
2540         contacts_list_first(nickname_list);
2541         do {
2542                 contacts_list_get_current_record_p(nickname_list, &record);
2543                 ret = ctsvc_db_nickname_insert(record, contact_id, is_my_profile, NULL);
2544                 if (CONTACTS_ERROR_DB == ret) {
2545                         ERR("ctsvc_db_nickname_insert");
2546                         break;
2547                 }
2548         } while (CONTACTS_ERROR_NONE == contacts_list_next(nickname_list));
2549
2550         return ret;
2551 }
2552
2553 int ctsvc_contact_insert_data_relationship(contacts_list_h relationship_list, int contact_id, bool is_my_profile)
2554 {
2555         CTS_FN_CALL;
2556         int ret = CONTACTS_ERROR_NONE;
2557         contacts_record_h record;
2558         int count = 0;
2559
2560         RETV_IF(NULL == relationship_list, CONTACTS_ERROR_INVALID_PARAMETER);
2561         ret = contacts_list_get_count(relationship_list, &count);
2562         if (0 == count)
2563                 return CONTACTS_ERROR_NONE;
2564
2565         contacts_list_first(relationship_list);
2566         do {
2567                 contacts_list_get_current_record_p(relationship_list, &record);
2568                 ret = ctsvc_db_relationship_insert(record, contact_id, is_my_profile, NULL);
2569                 if (CONTACTS_ERROR_DB == ret) {
2570                         ERR("ctsvc_db_relationship_insert");
2571                         break;
2572                 }
2573         } while (CONTACTS_ERROR_NONE == contacts_list_next(relationship_list));
2574
2575         return ret;
2576 }
2577
2578 int ctsvc_contact_insert_data_image(contacts_list_h image_list, int contact_id, bool is_my_profile)
2579 {
2580         CTS_FN_CALL;
2581         int ret = CONTACTS_ERROR_NONE;
2582         contacts_record_h record;
2583         int count = 0;
2584
2585         RETV_IF(NULL == image_list, CONTACTS_ERROR_INVALID_PARAMETER);
2586         ret = contacts_list_get_count(image_list, &count);
2587         if (0 == count)
2588                 return CONTACTS_ERROR_NONE;
2589
2590         contacts_list_first(image_list);
2591         do {
2592                 contacts_list_get_current_record_p(image_list, &record);
2593                 ret = ctsvc_db_image_insert(record, contact_id, is_my_profile, NULL);
2594                 if (CONTACTS_ERROR_DB == ret) {
2595                         ERR("ctsvc_db_image_insert");
2596                         break;
2597                 }
2598         } while (CONTACTS_ERROR_NONE == contacts_list_next(image_list));
2599
2600         return ret;
2601 }
2602
2603 int ctsvc_contact_insert_data_extension(contacts_list_h extension_list, int contact_id, bool is_my_profile)
2604 {
2605         CTS_FN_CALL;
2606         int ret = CONTACTS_ERROR_NONE;
2607         contacts_record_h record;
2608         int count = 0;
2609
2610         RETV_IF(NULL == extension_list, CONTACTS_ERROR_INVALID_PARAMETER);
2611         ret = contacts_list_get_count(extension_list, &count);
2612         if (0 == count)
2613                 return CONTACTS_ERROR_NONE;
2614
2615         contacts_list_first(extension_list);
2616         do {
2617                 contacts_list_get_current_record_p(extension_list, &record);
2618                 ret = ctsvc_db_extension_insert(record, contact_id, is_my_profile, NULL);
2619                 if (CONTACTS_ERROR_DB == ret) {
2620                         ERR("ctsvc_db_extension_insert");
2621                         break;
2622                 }
2623         } while (CONTACTS_ERROR_NONE == contacts_list_next(extension_list));
2624
2625         return ret;
2626 }
2627
2628 int ctsvc_contact_insert_data_sip(contacts_list_h sip_list, int contact_id, bool is_my_profile)
2629 {
2630         CTS_FN_CALL;
2631         int ret = CONTACTS_ERROR_NONE;
2632         contacts_record_h record;
2633         int count = 0;
2634
2635         RETV_IF(NULL == sip_list, CONTACTS_ERROR_INVALID_PARAMETER);
2636         ret = contacts_list_get_count(sip_list, &count);
2637         if (0 == count)
2638                 return CONTACTS_ERROR_NONE;
2639
2640         contacts_list_first(sip_list);
2641         do {
2642                 contacts_list_get_current_record_p(sip_list, &record);
2643                 ret = ctsvc_db_sip_insert(record, contact_id, is_my_profile, NULL);
2644                 if (CONTACTS_ERROR_DB == ret) {
2645                         ERR("DB error : ctsvc_db_sip_insert");
2646                         break;
2647                 }
2648         } while (CONTACTS_ERROR_NONE == contacts_list_next(sip_list));
2649
2650         return ret;
2651 }
2652
2653 int ctsvc_contact_update_display_name(int contact_id, contacts_display_name_source_type_e changed_record_type)
2654 {
2655         int ret = CONTACTS_ERROR_NONE;
2656         int display_name_type;
2657         contacts_record_h record;
2658         ret = ctsvc_db_contact_get(contact_id, (contacts_record_h*)&record);
2659         RETVM_IF(ret != CONTACTS_ERROR_NONE, ret, "ctsvc_db_contact_get Fail(%d)", ret);
2660         contacts_record_get_int(record, _contacts_contact.display_source_type, &display_name_type);
2661
2662         if (display_name_type <= changed_record_type) {
2663
2664                 cts_stmt stmt = NULL;
2665                 char query[CTS_SQL_MAX_LEN] = {0};
2666                 ctsvc_contact_s *contact = (ctsvc_contact_s*)record;
2667                 ctsvc_contact_make_display_name(contact);
2668
2669                 snprintf(query, sizeof(query), "UPDATE "CTS_TABLE_CONTACTS" SET "
2670                                 "display_name=?, reverse_display_name=?, display_name_source=%d, "
2671                                 "display_name_language=%d, reverse_display_name_language=%d, "
2672                                 "sort_name=?, reverse_sort_name=?, sortkey=?, reverse_sortkey=?, "
2673                                 "changed_ver=%d, changed_time=%d  WHERE contact_id=%d",
2674                                 contact->display_source_type,
2675                                 contact->display_name_language, contact->reverse_display_name_language,
2676                                 ctsvc_get_next_ver(), (int)time(NULL), contact_id);
2677
2678                 ret = ctsvc_query_prepare(query, &stmt);
2679                 if (NULL == stmt) {
2680                         ERR("ctsvc_query_prepare() Fail(%d)", ret);
2681                         contacts_record_destroy(record, true);
2682                         return ret;
2683                 }
2684
2685                 if (contact->display_name)
2686                         ctsvc_stmt_bind_text(stmt, 1, contact->display_name);
2687                 if (contact->reverse_display_name)
2688                         ctsvc_stmt_bind_text(stmt, 2, contact->reverse_display_name);
2689                 if (contact->sort_name)
2690                         ctsvc_stmt_bind_text(stmt, 3, contact->sort_name);
2691                 if (contact->reverse_sort_name)
2692                         ctsvc_stmt_bind_text(stmt, 4, contact->reverse_sort_name);
2693                 if (contact->sortkey)
2694                         ctsvc_stmt_bind_text(stmt, 5, contact->sortkey);
2695                 if (contact->reverse_sortkey)
2696                         ctsvc_stmt_bind_text(stmt, 6, contact->reverse_sortkey);
2697
2698                 ret = ctsvc_stmt_step(stmt);
2699                 WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_stmt_step() Fail(%d)", ret);
2700
2701                 ctsvc_stmt_finalize(stmt);
2702         }
2703
2704         contacts_record_destroy(record, true);
2705         return ret;
2706 }
2707
2708 extern ctsvc_db_plugin_info_s ctsvc_db_plugin_contact;
2709 int ctsvc_db_contact_get(int id, contacts_record_h *out_record)
2710 {
2711         return ctsvc_db_plugin_contact.get_record(id, out_record);
2712 }
2713