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