server/db/ctsvc_db_plugin_contact_helper.c

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