server/db/ctsvc_db_plugin_contact_helper.c

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