4 * Copyright (c) 2010 - 2015 Samsung Electronics Co., Ltd. All rights reserved.
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
10 * http://www.apache.org/licenses/LICENSE-2.0
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.
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"
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"
56 #include "ctsvc_server_person.h"
57 #include "ctsvc_server_group.h"
59 #ifdef ENABLE_LOG_FEATURE
60 #include "ctsvc_server_phonelog.h"
61 #endif /* ENABLE_LOG_FEATURE */
63 #define CTSVC_CONTACT_INITIAL_DATA_MAX_LEN 128
65 int ctsvc_contact_add_image_file(int parent_id, int img_id,
66 char *src_img, char *dest, int dest_size)
74 RETV_IF(NULL == src_img, CONTACTS_ERROR_INVALID_PARAMETER);
76 ext = strrchr(src_img, '.');
77 if (NULL == ext || strchr(ext, '/'))
80 lower_ext = strdup(ext);
84 return CONTACTS_ERROR_OUT_OF_MEMORY;
87 *temp = tolower(*temp);
91 version = ctsvc_get_next_ver();
92 snprintf(dest, dest_size, "%d_%d-%d%s", parent_id, img_id, version, lower_ext);
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);
102 return CONTACTS_ERROR_NONE;
105 static int __ctsvc_contact_get_current_image_file(int image_id, char *dest, int dest_size)
110 char query[CTS_SQL_MIN_LEN] = {0};
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);
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;
126 tmp_path = ctsvc_stmt_get_text(stmt, 0);
128 snprintf(dest, dest_size, "%s/%s", CTSVC_CONTACT_IMG_FULL_LOCATION, tmp_path);
130 ctsvc_stmt_finalize(stmt);
131 return CONTACTS_ERROR_NONE;
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
139 bool ctsvc_contact_check_image_location(const char *path)
144 if (path == NULL || *path == '\0')
147 slash = strrchr(path, '/');
148 if (slash == NULL || slash == path)
151 len = (int)(slash-path);
152 if (len != strlen(CTSVC_CONTACT_IMG_FULL_LOCATION))
155 if (STRING_EQUAL == strncmp(path, CTSVC_CONTACT_IMG_FULL_LOCATION, len))
161 int ctsvc_contact_update_image_file(int parent_id, int img_id,
162 char *src_img, char *dest_name, int dest_size)
165 char dest[CTSVC_IMG_FULL_PATH_SIZE_MAX] = {0};
167 ret = __ctsvc_contact_get_current_image_file(img_id, dest, sizeof(dest));
169 WARN_IF(CONTACTS_ERROR_NONE != ret && CONTACTS_ERROR_NO_DATA != ret,
170 "__ctsvc_contact_get_current_image_file() Fail(%d)", ret);
172 if (src_img && STRING_EQUAL == strcmp(dest, src_img)) {
173 snprintf(dest_name, dest_size, "%s", src_img + strlen(CTSVC_CONTACT_IMG_FULL_LOCATION) + 1);
174 return CONTACTS_ERROR_NONE;
179 WARN("unlink() Fail(%d)", errno);
183 ret = ctsvc_contact_add_image_file(parent_id, img_id, src_img, dest_name, dest_size);
184 RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "ctsvc_contact_add_image_file() Fail(%d)", ret);
190 int ctsvc_db_contact_update_changed_time(int contact_id)
193 char query[CTS_SQL_MIN_LEN] = {0};
195 snprintf(query, sizeof(query),
196 "UPDATE %s SET changed_ver=%d, changed_time=%d WHERE contact_id=%d AND deleted = 0",
197 CTS_TABLE_CONTACTS, ctsvc_get_next_ver(), (int)time(NULL), contact_id);
199 ret = ctsvc_query_exec(query);
200 RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "ctsvc_query_exec() Fail(%d)", ret);
202 ctsvc_set_contact_noti();
204 return CONTACTS_ERROR_NONE;
207 int ctsvc_contact_delete_image_file_with_path(const unsigned char *image_path)
212 char full_path[CTSVC_IMG_FULL_PATH_SIZE_MAX] = {0};
213 snprintf(full_path, sizeof(full_path), "%s/%s", CTSVC_CONTACT_IMG_FULL_LOCATION, image_path);
214 ret = unlink(full_path);
216 WARN("unlink() Fail(%d)", errno);
219 return CONTACTS_ERROR_NONE;
222 int ctsvc_db_contact_delete(int contact_id)
225 int ret, rel_changed;
229 char query[CTS_SQL_MAX_LEN] = {0};
230 cts_stmt stmt = NULL;
233 ret = ctsvc_begin_trans();
234 RETVM_IF(ret, ret, "ctsvc_begin_trans() Fail(%d)", ret);
236 snprintf(query, sizeof(query),
237 "SELECT addressbook_id, person_id "
238 "FROM "CTS_TABLE_CONTACTS" WHERE contact_id = %d AND deleted = 0", contact_id);
240 ret = ctsvc_query_prepare(query, &stmt);
242 ERR("ctsvc_query_prepare() Fail(%d)", ret);
243 ctsvc_end_trans(false);
247 ret = ctsvc_stmt_step(stmt);
249 ERR("ctsvc_stmt_step() Fail(%d)", ret);
250 ctsvc_stmt_finalize(stmt);
251 ctsvc_end_trans(false);
252 if (CONTACTS_ERROR_NONE == ret)
253 return CONTACTS_ERROR_NO_DATA;
258 addressbook_id = ctsvc_stmt_get_int(stmt, 0);
259 person_id = ctsvc_stmt_get_int(stmt, 1);
260 DBG("addressbook_id : %d, person_id : %d", addressbook_id, person_id);
261 ctsvc_stmt_finalize(stmt);
264 if (false == ctsvc_have_ab_write_permission(addressbook_id)) {
265 ERR("Does not have permission to delete this contact");
266 ctsvc_end_trans(false);
267 return CONTACTS_ERROR_PERMISSION_DENIED;
270 version = ctsvc_get_next_ver();
271 snprintf(query, sizeof(query),
272 "UPDATE %s SET member_changed_ver=%d "
273 "WHERE group_id IN (SELECT group_id FROM %s WHERE contact_id = %d AND deleted = 0) ",
274 CTS_TABLE_GROUPS, version, CTS_TABLE_GROUP_RELATIONS, contact_id);
275 ret = ctsvc_query_exec(query);
276 if (CONTACTS_ERROR_NONE != ret) {
277 ERR("ctsvc_query_exec() Fail(%d)", ret);
278 ctsvc_end_trans(false);
281 rel_changed = ctsvc_db_change();
283 snprintf(query, sizeof(query),
284 "UPDATE %s SET deleted = 1, person_id = 0, changed_ver=%d WHERE contact_id = %d",
285 CTS_TABLE_CONTACTS, version, contact_id);
286 ret = ctsvc_query_exec(query);
287 if (CONTACTS_ERROR_NONE != ret) {
288 ERR("ctsvc_query_exec() Fail(%d)", ret);
289 ctsvc_end_trans(false);
293 snprintf(query, sizeof(query), "SELECT link_count FROM "CTS_TABLE_PERSONS" WHERE person_id = %d", person_id);
294 ret = ctsvc_query_get_first_int_result(query, &link_count);
295 WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_query_get_first_int_result() Fail(%d)", ret);
297 * set dirty bit to person by trigger
298 * : person will be aggregated in ctsvc_person_aggregate
301 if (1 < link_count) {
302 ctsvc_person_aggregate(person_id);
304 #ifdef ENABLE_LOG_FEATURE
305 /* update phonelog */
306 ctsvc_db_phone_log_update_person_id(NULL, person_id, -1, false);
307 #endif /* ENABLE_LOG_FEATURE */
309 ctsvc_set_person_noti();
312 ctsvc_set_contact_noti();
314 ctsvc_set_group_rel_noti();
316 ret = ctsvc_end_trans(true);
317 if (ret < CONTACTS_ERROR_NONE) {
318 ERR("ctsvc_end_trans() Fail(%d)", ret);
321 return CONTACTS_ERROR_NONE;
325 static inline void __ctsvc_contact_get_initial(char *src, char *dest, int dest_size, bool pinyin)
329 int len = strlen(src);
330 for (i = 0; i < len && j < (dest_size-1);) {
335 int char_len = ctsvc_check_utf8(src[i]);
337 for (k = 0; k < char_len && j < (dest_size-1); k++)
338 dest[j++] = src[i++];
339 if (false == pinyin && j < (dest_size-1))
348 static inline void __ctsvc_remove_space(char *src, char *dest, int dest_size)
350 int len = strlen(src);
353 for (i = 0; i < len && i < dest_size; i++) {
354 if (src[i] && src[i] != ' ') {
362 /* make search name to insert search_index table name column
363 * korean : display_name, chosung, phonetic
364 * japanese : dislay_name(hiragana), phonetic
365 * if display_name is chinese and sort_name(phonetic) is japanese,
366 * then search_name is normalized_name and sort_name (phonetic)
367 * chinese : display_name, pinyin name, pinyin initial, phonetic
368 * others : display_name, phonetic
370 int ctsvc_contact_make_search_name(ctsvc_contact_s *contact, char **search_name)
373 char *temp_name = NULL;
376 RETV_IF(NULL == contact, CONTACTS_ERROR_NO_DATA);
378 if (contact->display_name) {
379 if (ctsvc_has_chinese(contact->display_name)) {
380 if (CTSVC_LANG_JAPANESE == ctsvc_check_language_type(contact->sort_name)) {
381 char *normalized_display_name = NULL;
383 ctsvc_normalize_str(contact->display_name, &normalized_display_name);
384 if (normalized_display_name) {
385 buf_size = SAFE_STRLEN(normalized_display_name) + strlen(contact->sort_name) + 2;
386 name = calloc(1, buf_size);
388 ERR("calloc() Fail");
389 free(normalized_display_name);
390 return CONTACTS_ERROR_OUT_OF_MEMORY;
392 snprintf(name, buf_size, "%s %s", normalized_display_name, contact->sort_name);
393 free(normalized_display_name);
396 char *langset = ctsvc_get_langset();
397 if (STRING_EQUAL == strncmp(langset, "zh_CN", strlen("zh_CN"))) {
398 pinyin_name_s *pinyinname;
401 ret = ctsvc_convert_chinese_to_pinyin(contact->display_name, &pinyinname, &size);
402 if (CONTACTS_ERROR_NONE == ret) {
403 int name_len = (CHINESE_PINYIN_SPELL_MAX_LEN*strlen(contact->display_name)+1) *sizeof(char);
404 char *name_nospace = calloc(1, name_len);
405 if (NULL == name_nospace) {
406 ERR("calloc() Fail");
407 ctsvc_pinyin_free(pinyinname, size);
408 return CONTACTS_ERROR_OUT_OF_MEMORY;
410 char *temp_name = NULL;
412 ctsvc_normalize_str(contact->display_name, &name);
414 for (i = 0; i < size; i++) {
415 __ctsvc_remove_space(pinyinname[i].pinyin_name, name_nospace, name_len);
417 buf_size = SAFE_STRLEN(name)
418 + SAFE_STRLEN(pinyinname[i].pinyin_name)
419 + SAFE_STRLEN(name_nospace)
420 + SAFE_STRLEN(pinyinname[i].pinyin_initial)
422 temp_name = calloc(1, buf_size);
423 if (NULL == temp_name) {
424 ERR("calloc() Fail");
426 ctsvc_pinyin_free(pinyinname, size);
428 return CONTACTS_ERROR_OUT_OF_MEMORY;
430 snprintf(temp_name, buf_size, "%s %s %s %s",
431 name, pinyinname[i].pinyin_name, name_nospace, pinyinname[i].pinyin_initial);
437 len = ctsvc_check_utf8(contact->display_name[0]);
438 for (i = len; i < strlen(contact->display_name); i += len) {
439 len = ctsvc_check_utf8(contact->display_name[i]);
441 buf_size = SAFE_STRLEN(name) + SAFE_STRLEN(&contact->display_name[i]) + 2;
442 temp_name = calloc(1, buf_size);
443 if (NULL == temp_name) {
444 ERR("calloc() Fail");
446 ctsvc_pinyin_free(pinyinname, size);
448 return CONTACTS_ERROR_OUT_OF_MEMORY;
450 snprintf(temp_name, buf_size, "%s %s", name, &contact->display_name[i]);
457 ctsvc_pinyin_free(pinyinname, size);
459 char initial[CTSVC_CONTACT_INITIAL_DATA_MAX_LEN] = {0,};
460 char *normalized_display_name = NULL;
462 ctsvc_normalize_str(contact->display_name, &normalized_display_name);
463 if (normalized_display_name) {
464 __ctsvc_contact_get_initial(contact->display_name, initial, sizeof(initial), false);
465 buf_size = SAFE_STRLEN(normalized_display_name) + strlen(initial) + 2;
466 name = calloc(1, buf_size);
468 ERR("calloc() Fail");
469 free(normalized_display_name);
470 return CONTACTS_ERROR_OUT_OF_MEMORY;
472 snprintf(name, buf_size, "%s %s", normalized_display_name, initial);
474 free(normalized_display_name);
478 char initial[CTSVC_CONTACT_INITIAL_DATA_MAX_LEN] = {0,};
479 char *normalized_display_name = NULL;
481 ctsvc_normalize_str(contact->display_name, &normalized_display_name);
482 if (normalized_display_name) {
483 __ctsvc_contact_get_initial(contact->display_name, initial, sizeof(initial), false);
484 buf_size = SAFE_STRLEN(normalized_display_name) + strlen(initial) + 2;
485 name = calloc(1, buf_size);
487 ERR("calloc() Fail");
488 free(normalized_display_name);
489 return CONTACTS_ERROR_OUT_OF_MEMORY;
491 snprintf(name, buf_size, "%s %s", normalized_display_name, initial);
493 free(normalized_display_name);
497 } else if (ctsvc_has_korean(contact->display_name)) {
498 /* 'a가' should be searched by 'ㄱ' */
500 int full_len, chosung_len;
501 char *chosung = calloc(1, strlen(contact->display_name) * 5);
502 if (NULL == chosung) {
503 ERR("calloc() Fail");
504 return CONTACTS_ERROR_OUT_OF_MEMORY;
506 int total_len = strlen(contact->display_name);
508 count = ctsvc_get_chosung(contact->display_name, chosung, strlen(contact->display_name) * 5);
510 ctsvc_normalize_str(contact->display_name, &name);
513 for (i = 0, j = 0; i < total_len; i += full_len, j += chosung_len) {
514 full_len = ctsvc_check_utf8(contact->display_name[i]);
515 chosung_len = ctsvc_check_utf8(chosung[j]);
517 buf_size = SAFE_STRLEN(name) + SAFE_STRLEN(&contact->display_name[i]) + SAFE_STRLEN(&chosung[j]) + 3;
518 temp_name = calloc(1, buf_size);
519 if (NULL == temp_name) {
520 ERR("calloc() Fail");
523 return CONTACTS_ERROR_OUT_OF_MEMORY;
526 snprintf(temp_name, buf_size, "%s %s %s", name, &contact->display_name[i], &chosung[j]);
533 } else if (CTSVC_LANG_JAPANESE == ctsvc_check_language_type(contact->display_name)) {
534 ctsvc_convert_japanese_to_hiragana(contact->display_name, &name);
536 /* Insert 'ABO Â' for 'ÂBC' */
537 char initial[CTSVC_CONTACT_INITIAL_DATA_MAX_LEN] = {0};
538 char *normalized_display_name = NULL;
540 ctsvc_normalize_str(contact->display_name, &normalized_display_name);
541 if (normalized_display_name) {
542 __ctsvc_contact_get_initial(contact->display_name, initial, sizeof(initial), false);
543 buf_size = SAFE_STRLEN(normalized_display_name) + strlen(initial) + 2;
544 name = calloc(1, buf_size);
546 ERR("calloc() Fail");
547 free(normalized_display_name);
548 return CONTACTS_ERROR_OUT_OF_MEMORY;
550 snprintf(name, buf_size, "%s %s", normalized_display_name, initial);
552 free(normalized_display_name);
557 /* append phonetic name */
559 contacts_list_h name_list = (contacts_list_h)contact->name;
560 ctsvc_name_s *name_record;
561 contacts_list_first(name_list);
562 char *phonetic = NULL;
565 contacts_list_get_current_record_p(name_list, (contacts_record_h*)&name_record);
567 buf_size = SAFE_STRLEN(name_record->phonetic_first) + SAFE_STRLEN(name_record->phonetic_last) + SAFE_STRLEN(name_record->phonetic_middle);
569 buf_size += 3; /* for space and null string */
570 phonetic = calloc(1, buf_size);
571 if (NULL == phonetic) {
572 ERR("calloc() Fail");
574 return CONTACTS_ERROR_OUT_OF_MEMORY;
577 if (name_record->phonetic_first)
578 temp_len += snprintf(phonetic, buf_size, "%s", name_record->phonetic_first);
579 if (name_record->phonetic_middle) {
581 temp_len += snprintf(phonetic + temp_len, buf_size - temp_len, " ");
582 temp_len += snprintf(phonetic + temp_len, buf_size - temp_len, "%s", name_record->phonetic_middle);
584 if (name_record->phonetic_last) {
586 temp_len += snprintf(phonetic + temp_len, buf_size - temp_len, " ");
587 temp_len += snprintf(phonetic + temp_len, buf_size - temp_len, "%s", name_record->phonetic_last);
591 buf_size = SAFE_STRLEN(name) + SAFE_STRLEN(phonetic) + 2;
592 temp_name = calloc(1, buf_size);
593 if (NULL == temp_name) {
594 ERR("calloc() Fail");
597 return CONTACTS_ERROR_OUT_OF_MEMORY;
599 snprintf(temp_name, buf_size, "%s %s", name, phonetic);
611 return CONTACTS_ERROR_NONE;
614 static int __ctsvc_make_phonetic_name(ctsvc_name_s *name, char **phonetic, contacts_name_display_order_e order)
616 int len = SAFE_STRLEN(name->phonetic_first) + SAFE_STRLEN(name->phonetic_last) + SAFE_STRLEN(name->phonetic_middle);
618 len += 3; /* for space and null string */
619 *phonetic = calloc(1, len);
620 if (NULL == *phonetic) {
621 ERR("calloc() Fail");
622 return CONTACTS_ERROR_OUT_OF_MEMORY;
626 if (order == CONTACTS_NAME_DISPLAY_ORDER_FIRSTLAST) {
627 if (name->phonetic_first)
628 temp_len += snprintf(*phonetic, len, "%s", name->phonetic_first);
629 if (name->phonetic_middle) {
631 temp_len += snprintf(*phonetic + temp_len, len - temp_len, " ");
632 temp_len += snprintf(*phonetic + temp_len, len - temp_len, "%s", name->phonetic_middle);
634 if (name->phonetic_last) {
636 temp_len += snprintf(*phonetic + temp_len, len - temp_len, " ");
637 temp_len += snprintf(*phonetic + temp_len, len - temp_len, "%s", name->phonetic_last);
640 if (name->phonetic_last)
641 temp_len += snprintf(*phonetic, len, "%s", name->phonetic_last);
642 if (name->phonetic_middle) {
644 temp_len += snprintf(*phonetic + temp_len, len - temp_len, " ");
645 temp_len += snprintf(*phonetic + temp_len, len - temp_len, "%s", name->phonetic_middle);
647 if (name->phonetic_first) {
649 temp_len += snprintf(*phonetic + temp_len, len - temp_len, " ");
650 temp_len += snprintf(*phonetic + temp_len, len - temp_len, "%s", name->phonetic_first);
655 return CONTACTS_ERROR_NONE;
658 static inline int __ctsvc_get_sort_name_to_pinyin(const char *display_name, char **sort_name)
662 pinyin_name_s *pinyinname = NULL;
665 if (false == ctsvc_has_chinese(display_name))
666 return CONTACTS_ERROR_INVALID_PARAMETER;
668 ret = ctsvc_convert_chinese_to_pinyin(display_name, &pinyinname, &size);
670 if (ret == CONTACTS_ERROR_NONE) {
671 char temp[strlen(display_name) * 2 + strlen(pinyinname[0].pinyin_name)];
672 int pinyin_index = 0;
680 if (pinyinname[0].pinyin_name[pinyin_index] == '\0') {
681 if (display_name[name_index] != '\0') {
682 temp[temp_index] = ' ';
684 name_len = ctsvc_check_utf8(display_name[name_index]);
686 memcpy(&(temp[temp_index]), &(display_name[name_index]), name_len);
687 temp_index += name_len;
688 name_index += name_len;
693 pinyin_len = ctsvc_check_utf8(pinyinname[0].pinyin_name[pinyin_index]);
696 memcpy(&(temp[temp_index]), &(pinyinname[0].pinyin_name[pinyin_index]), pinyin_len);
697 temp_index += pinyin_len;
699 if (pinyinname[0].pinyin_name[pinyin_index] == ' ') {
700 name_len = ctsvc_check_utf8(display_name[name_index]);
704 if (name_len == 1 && display_name[name_index] == ' ') {
705 temp[temp_index] = ' ';
709 memcpy(&(temp[temp_index]), &(display_name[name_index]), name_len);
710 temp_index += name_len;
711 name_index += name_len;
712 temp[temp_index] = ' ';
716 pinyin_index += pinyin_len;
718 temp[temp_index] = '\0';
719 *sort_name = strdup(temp);
720 ctsvc_pinyin_free(pinyinname, size);
725 void ctsvc_contact_make_sortkey(ctsvc_contact_s *contact)
727 char *sortkey = NULL;
728 char *phonetic = NULL;
731 if (contact->display_source_type == CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NAME) {
732 if (0 < contact->name->count && contact->name->records
733 && contact->name->records->data) {
734 ctsvc_name_s *name = (ctsvc_name_s*)contact->name->records->data;
735 __ctsvc_make_phonetic_name(name, &phonetic, CONTACTS_NAME_DISPLAY_ORDER_FIRSTLAST);
740 sort_type = ctsvc_get_name_sort_type(phonetic);
741 else if (contact->sort_name)
742 sort_type = ctsvc_get_name_sort_type(contact->sort_name);
744 sort_type = CTSVC_SORT_OTHERS;
746 WARN_IF(sort_type < 0, "ctsvc_get_name_sort_type Fail(%d)", sort_type);
747 char *langset = ctsvc_get_langset();
752 if (STRING_EQUAL == strncmp(langset, "zh_CN", strlen("zh_CN"))) {
753 /* chinese to pinyin */
756 __ctsvc_get_sort_name_to_pinyin(phonetic, &pinyin);
758 __ctsvc_get_sort_name_to_pinyin(contact->sort_name, &pinyin);
761 free(contact->sort_name);
762 contact->sort_name = pinyin;
763 sort_type = CTSVC_SORT_WESTERN;
765 } else if (STRING_EQUAL == strncmp(langset, "ko_KR", strlen("ko_KR"))) {
766 sort_type = CTSVC_SORT_KOREAN;
770 case CTSVC_SORT_JAPANESE:
772 char *hiragana = NULL;
773 ctsvc_convert_japanese_to_hiragana(contact->sort_name, &hiragana);
776 free(contact->sort_name);
777 contact->sort_name = hiragana;
784 FREEandSTRDUP(contact->sort_name, phonetic);
792 if (ctsvc_get_primary_sort() == sort_type)
793 contact->display_name_language = CTSVC_SORT_PRIMARY;
794 else if (ctsvc_get_secondary_sort() == sort_type)
795 contact->display_name_language = CTSVC_SORT_SECONDARY;
796 else if (sort_type < 0)
797 contact->display_name_language = CTSVC_SORT_OTHERS;
799 contact->display_name_language = sort_type;
802 * check reverse sort_name, reverser_display_name_language
803 * make reverse phonetic name
805 if (contact->display_source_type == CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NAME) {
806 if (0 < contact->name->count && contact->name->records
807 && contact->name->records->data) {
808 ctsvc_name_s *name = (ctsvc_name_s*)contact->name->records->data;
809 __ctsvc_make_phonetic_name(name, &phonetic, CONTACTS_NAME_DISPLAY_ORDER_LASTFIRST);
814 sort_type = ctsvc_get_name_sort_type(phonetic);
815 else if (contact->reverse_sort_name)
816 sort_type = ctsvc_get_name_sort_type(contact->reverse_sort_name);
818 sort_type = CTSVC_SORT_OTHERS;
820 WARN_IF(sort_type < 0, "ctsvc_get_name_sort_type Fail(%d)", sort_type);
825 if (STRING_EQUAL == strncmp(langset, "zh_CN", strlen("zh_CN"))) {
828 __ctsvc_get_sort_name_to_pinyin(phonetic, &pinyin);
830 __ctsvc_get_sort_name_to_pinyin(contact->reverse_sort_name, &pinyin);
833 free(contact->reverse_sort_name);
834 contact->reverse_sort_name = pinyin;
835 sort_type = CTSVC_SORT_WESTERN;
837 } else if (STRING_EQUAL == strncmp(langset, "ko_KR", strlen("ko_KR"))) {
838 sort_type = CTSVC_SORT_KOREAN;
842 case CTSVC_SORT_JAPANESE:
844 char *hiragana = NULL;
845 ctsvc_convert_japanese_to_hiragana(contact->reverse_sort_name, &hiragana);
848 free(contact->reverse_sort_name);
849 contact->reverse_sort_name = hiragana;
856 FREEandSTRDUP(contact->reverse_sort_name, phonetic);
864 if (ctsvc_get_primary_sort() == sort_type)
865 contact->reverse_display_name_language = CTSVC_SORT_PRIMARY;
866 else if (ctsvc_get_secondary_sort() == sort_type)
867 contact->reverse_display_name_language = CTSVC_SORT_SECONDARY;
868 else if (sort_type < 0)
869 contact->reverse_display_name_language = CTSVC_SORT_OTHERS;
871 contact->reverse_display_name_language = sort_type;
873 if (contact->sort_name) {
874 sort_type = ctsvc_collation_str(contact->sort_name, &sortkey);
875 if (CONTACTS_ERROR_NONE == sort_type)
876 contact->sortkey = sortkey;
883 if (contact->reverse_sort_name) {
884 sort_type = ctsvc_collation_str(contact->reverse_sort_name, &sortkey);
885 if (CONTACTS_ERROR_NONE == sort_type)
886 contact->reverse_sortkey = sortkey;
892 static bool __ctsvc_contact_check_name_has_korean(const ctsvc_name_s *name)
894 if (name->first && ctsvc_has_korean(name->first))
896 else if (name->last && ctsvc_has_korean(name->last))
898 else if (name->addition && ctsvc_has_korean(name->addition))
900 else if (name->prefix && ctsvc_has_korean(name->prefix))
902 else if (name->suffix && ctsvc_has_korean(name->suffix))
908 static bool __ctsvc_contact_check_name_has_japanese(const ctsvc_name_s *name)
910 if (name->first && ctsvc_check_language_type(name->first) == CTSVC_LANG_JAPANESE)
912 else if (name->addition && ctsvc_check_language_type(name->addition) == CTSVC_LANG_JAPANESE)
914 else if (name->last && ctsvc_check_language_type(name->last) == CTSVC_LANG_JAPANESE)
920 static bool __ctsvc_contact_check_name_has_chinese(const ctsvc_name_s *name)
922 if (name->first && ctsvc_check_language_type(name->first) == CTSVC_LANG_CHINESE)
924 else if (name->addition && ctsvc_check_language_type(name->addition) == CTSVC_LANG_CHINESE)
926 else if (name->last && ctsvc_check_language_type(name->last) == CTSVC_LANG_CHINESE)
932 int ctsvc_contact_get_name_language(const ctsvc_name_s *name)
935 if (__ctsvc_contact_check_name_has_korean(name))
936 lang = CTSVC_LANG_KOREAN;
937 else if (__ctsvc_contact_check_name_has_japanese(name))
938 lang = CTSVC_LANG_JAPANESE;
939 else if (__ctsvc_contact_check_name_has_chinese(name))
940 lang = CTSVC_LANG_CHINESE;
943 lang = ctsvc_check_language_type(name->last);
944 else if (name->first)
945 lang = ctsvc_check_language_type(name->first);
946 else if (name->addition)
947 lang = ctsvc_check_language_type(name->addition);
953 char* __ctsvc_remove_first_space(char *src)
955 if (src == NULL || SAFE_STRLEN(src) == 0)
958 int name_len = (SAFE_STRLEN(src)+1)*sizeof(char);
959 char *name_nospace = NULL;
960 name_nospace = calloc(1, name_len);
961 if (NULL == name_nospace) {
962 ERR("calloc() Fail");
966 int len = strlen(src);
969 for (i = 0; i < len && i < name_len; i++) {
970 if (src[i] && src[i] != ' ') {
971 strncpy(name_nospace, src+i, name_len);
978 * Make display_name, sort_name, sortkey of the contact by name record
979 * If the contact record does not have name record,
980 * we use company, nickname, number, email record in order
982 void ctsvc_contact_make_display_name(ctsvc_contact_s *contact)
985 ctsvc_name_s *name = NULL;
987 free(contact->display_name);
988 contact->display_name = NULL;
990 free(contact->reverse_display_name);
991 contact->reverse_display_name = NULL;
993 free(contact->sort_name);
994 contact->sort_name = NULL;
996 free(contact->reverse_sort_name);
997 contact->reverse_sort_name = NULL;
999 free(contact->sortkey);
1000 contact->sortkey = NULL;
1002 free(contact->reverse_sortkey);
1003 contact->reverse_sortkey = NULL;
1005 contact->display_name_language = CTSVC_SORT_OTHERS;
1006 contact->reverse_display_name_language = CTSVC_SORT_OTHERS;
1008 contact->display_source_type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_INVALID;
1010 if (0 < contact->name->count && contact->name->records
1011 && contact->name->records->data) {
1012 name = (ctsvc_name_s*)contact->name->records->data;
1015 if (name && (name->first || name->last || name->prefix || name->addition
1017 int reverse_lang_type = -1;
1019 int temp_display_len;
1020 char *display = NULL;
1021 char *temp_display = NULL;
1024 * Make reverse display name (Last name first)
1025 * Default : Prefix Last, First Middle(addition), Suffix
1026 * Korean, Chinese : Prefix LastMiddleFirstSuffix
1027 * Japanese : Prefix Last Middle First Suffix
1028 * reverse sort name does not include prefix
1029 * But, if there is only prefix, reverse sort_name is prefix
1031 temp_display_len = SAFE_STRLEN(name->first)
1032 + SAFE_STRLEN(name->addition)
1033 + SAFE_STRLEN(name->last)
1034 + SAFE_STRLEN(name->suffix);
1035 if (0 < temp_display_len) {
1036 temp_display_len += 7;
1037 temp_display = calloc(1, temp_display_len);
1038 if (NULL == temp_display) {
1039 ERR("calloc() Fail");
1044 /* get language type */
1045 reverse_lang_type = ctsvc_contact_get_name_language(name);
1047 char *temp = __ctsvc_remove_first_space(name->last);
1048 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1050 if (reverse_lang_type != CTSVC_LANG_KOREAN &&
1051 reverse_lang_type != CTSVC_LANG_CHINESE &&
1052 reverse_lang_type != CTSVC_LANG_JAPANESE) {
1053 if (name->first || name->addition)
1054 len += snprintf(temp_display + len, temp_display_len - len, ",");
1058 if (reverse_lang_type == CTSVC_LANG_JAPANESE) {
1059 /* make temp_display name Prefix - Last - Middle - First - Suffix */
1060 if (name->addition) {
1061 char *temp = __ctsvc_remove_first_space(name->addition);
1063 len += snprintf(temp_display + len, temp_display_len - len, " ");
1064 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1069 char *temp = __ctsvc_remove_first_space(name->first);
1071 len += snprintf(temp_display + len, temp_display_len - len, " ");
1072 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1075 } else if (reverse_lang_type == CTSVC_LANG_CHINESE || reverse_lang_type == CTSVC_LANG_KOREAN) {
1076 if (name->addition) {
1077 char *temp = __ctsvc_remove_first_space(name->addition);
1078 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1083 char *temp = __ctsvc_remove_first_space(name->first);
1084 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1088 /* make temp_display name Prefix - Last - First - Middle - Suffix */
1090 if (*temp_display) {
1091 if (reverse_lang_type < 0)
1092 reverse_lang_type = ctsvc_check_language_type(temp_display);
1094 if (reverse_lang_type != CTSVC_LANG_KOREAN &&
1095 reverse_lang_type != CTSVC_LANG_CHINESE)
1096 len += snprintf(temp_display + len, temp_display_len - len, " ");
1098 char *temp = __ctsvc_remove_first_space(name->first);
1099 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1103 if (name->addition) {
1104 if (*temp_display) {
1105 if (reverse_lang_type < 0)
1106 reverse_lang_type = ctsvc_check_language_type(temp_display);
1108 if (reverse_lang_type != CTSVC_LANG_KOREAN &&
1109 reverse_lang_type != CTSVC_LANG_CHINESE)
1110 len += snprintf(temp_display + len, temp_display_len - len, " ");
1112 char *temp = __ctsvc_remove_first_space(name->addition);
1113 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1119 if (*temp_display) {
1120 if (reverse_lang_type < 0)
1121 reverse_lang_type = ctsvc_check_language_type(temp_display);
1123 if (reverse_lang_type == CTSVC_LANG_JAPANESE)
1124 len += snprintf(temp_display + len, temp_display_len - len, " ");
1125 else if (reverse_lang_type != CTSVC_LANG_KOREAN &&
1126 reverse_lang_type != CTSVC_LANG_CHINESE)
1127 len += snprintf(temp_display + len, temp_display_len - len, ", ");
1129 char *temp = __ctsvc_remove_first_space(name->suffix);
1130 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1135 if (name->prefix && temp_display) {
1136 display_len = SAFE_STRLEN(name->prefix) + temp_display_len + 2;
1137 display = calloc(1, display_len);
1138 if (NULL == display) {
1139 ERR("calloc() Fail");
1143 char *temp = __ctsvc_remove_first_space(name->prefix);
1144 snprintf(display, display_len, "%s %s", temp, temp_display);
1146 contact->reverse_display_name = display;
1147 contact->reverse_sort_name = temp_display;
1148 } else if (temp_display) {
1149 contact->reverse_display_name = temp_display;
1150 contact->reverse_sort_name = strdup(temp_display);
1151 } else if (name->prefix) {
1152 contact->reverse_display_name = strdup(name->prefix);
1153 contact->reverse_sort_name = strdup(name->prefix);
1157 * Make display name (First name first)
1158 * Default : Prefix First Middle Last, Suffix
1159 * Korean, Chinese : Prefix LastFirstMiddleSuffix (Same as reverse display name)
1160 * Japanese : Prefix First Middle Last Suffix
1161 * sort name does not include prefix
1162 * But, if there is only prefix, sort_name is prefix
1164 if (reverse_lang_type == CTSVC_LANG_KOREAN ||
1165 reverse_lang_type == CTSVC_LANG_CHINESE ||
1166 reverse_lang_type == CTSVC_LANG_JAPANESE) {
1167 contact->display_name = strdup(contact->reverse_display_name);
1168 contact->sort_name = SAFE_STRDUP(contact->reverse_sort_name);
1171 temp_display = NULL;
1172 temp_display_len = SAFE_STRLEN(name->first)
1173 + SAFE_STRLEN(name->addition)
1174 + SAFE_STRLEN(name->last)
1175 + SAFE_STRLEN(name->suffix);
1176 if (0 < temp_display_len) {
1177 temp_display_len += 6;
1178 /* make reverse_temp_display_name */
1179 temp_display = calloc(1, temp_display_len);
1180 if (NULL == temp_display) {
1181 ERR("calloc() Fail");
1187 char *temp = __ctsvc_remove_first_space(name->first);
1188 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1192 if (name->addition) {
1193 char *temp = __ctsvc_remove_first_space(name->addition);
1195 len += snprintf(temp_display + len, temp_display_len - len, " ");
1196 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1201 char *temp = __ctsvc_remove_first_space(name->last);
1203 len += snprintf(temp_display + len, temp_display_len - len, " ");
1204 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1209 if (*temp_display) {
1210 lang_type = ctsvc_check_language_type(temp_display);
1211 if (lang_type == CTSVC_LANG_JAPANESE)
1212 len += snprintf(temp_display + len, temp_display_len - len, " ");
1214 len += snprintf(temp_display + len, temp_display_len - len, ", ");
1216 char *temp = __ctsvc_remove_first_space(name->suffix);
1217 len += snprintf(temp_display + len, temp_display_len - len, "%s", temp);
1222 if (name->prefix && temp_display) {
1223 display_len = SAFE_STRLEN(name->prefix) + temp_display_len + 2;
1224 display = calloc(1, display_len);
1225 if (NULL == display) {
1226 ERR("calloc() Fail");
1230 snprintf(display, display_len, "%s %s", name->prefix, temp_display);
1231 contact->display_name = display;
1232 contact->sort_name = temp_display;
1233 } else if (temp_display) {
1234 contact->display_name = temp_display;
1235 contact->sort_name = strdup(temp_display);
1236 } else if (name->prefix) {
1237 contact->display_name = strdup(name->prefix);
1238 contact->sort_name = strdup(name->prefix);
1242 ctsvc_record_set_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY);
1243 contact->display_source_type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NAME;
1246 if (contact->company && contact->company->records) {
1247 for (cur = contact->company->records; cur; cur = cur->next) {
1248 ctsvc_company_s *company = cur->data;
1249 if (company && company->name) {
1250 ctsvc_record_set_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY);
1251 contact->display_name = SAFE_STRDUP(company->name);
1252 contact->display_source_type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_COMPANY;
1258 if (false == ctsvc_record_check_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY) &&
1259 contact->nicknames && contact->nicknames->records) {
1260 for (cur = contact->nicknames->records; cur; cur = cur->next) {
1261 ctsvc_nickname_s *nickname = cur->data;
1262 if (nickname && nickname->nickname) {
1263 ctsvc_record_set_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY);
1264 free(contact->display_name);
1265 contact->display_name = SAFE_STRDUP(nickname->nickname);
1266 contact->display_source_type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NICKNAME;
1272 if (false == ctsvc_record_check_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY) &&
1273 contact->numbers && contact->numbers->records) {
1274 for (cur = contact->numbers->records; cur; cur = cur->next) {
1275 ctsvc_number_s *number = cur->data;
1276 if (number && number->number) {
1277 ctsvc_record_set_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY);
1278 free(contact->display_name);
1279 contact->display_name = SAFE_STRDUP(number->number);
1280 contact->display_source_type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NUMBER;
1286 if (false == ctsvc_record_check_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY) &&
1287 contact->emails && contact->emails->records) {
1288 for (cur = contact->emails->records; cur; cur = cur->next) {
1289 ctsvc_email_s *email = cur->data;
1290 if (email && email->email_addr) {
1291 ctsvc_record_set_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY);
1292 free(contact->display_name);
1293 contact->display_name = SAFE_STRDUP(email->email_addr);
1294 contact->display_source_type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_EMAIL;
1300 if (ctsvc_record_check_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY)) {
1301 contact->reverse_display_name = SAFE_STRDUP(contact->display_name);
1302 contact->sort_name = SAFE_STRDUP(contact->display_name);
1303 contact->reverse_sort_name = SAFE_STRDUP(contact->display_name);
1305 /* Update as NULL */
1306 ctsvc_record_set_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY);
1311 if (ctsvc_record_check_property_flag((ctsvc_record_s*)contact, _contacts_contact.display_name, CTSVC_PROPERTY_FLAG_DIRTY))
1312 ctsvc_contact_make_sortkey(contact);
1317 int ctsvc_get_data_info_name(cts_stmt stmt, contacts_list_h name_list)
1321 contacts_record_h record;
1323 ret = contacts_list_get_count(name_list, &count);
1324 RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "contacts_list_get_count Fail(%d)", ret);
1325 RETVM_IF(1 < count, CONTACTS_ERROR_INVALID_PARAMETER, "already had name");
1327 ctsvc_db_name_get_value_from_stmt(stmt, &record, 1);
1328 contacts_list_add(name_list, record);
1330 return CONTACTS_ERROR_NONE;
1333 int ctsvc_get_data_info_event(cts_stmt stmt, contacts_list_h list)
1335 contacts_record_h record;
1337 ctsvc_db_event_get_value_from_stmt(stmt, &record, 1);
1338 contacts_list_add(list, record);
1340 return CONTACTS_ERROR_NONE;
1343 int ctsvc_get_data_info_number(cts_stmt stmt, contacts_list_h number_list)
1345 contacts_record_h record;
1347 ctsvc_db_number_get_value_from_stmt(stmt, &record, 1);
1348 contacts_list_add(number_list, record);
1350 return CONTACTS_ERROR_NONE;
1353 int ctsvc_get_data_info_email(cts_stmt stmt, contacts_list_h list)
1355 contacts_record_h record;
1357 ctsvc_db_email_get_value_from_stmt(stmt, &record, 1);
1358 contacts_list_add(list, record);
1360 return CONTACTS_ERROR_NONE;
1363 int ctsvc_get_data_info_address(cts_stmt stmt, contacts_list_h list)
1365 contacts_record_h record;
1367 ctsvc_db_address_get_value_from_stmt(stmt, &record, 1);
1368 contacts_list_add(list, record);
1370 return CONTACTS_ERROR_NONE;
1373 int ctsvc_get_data_info_messenger(cts_stmt stmt, contacts_list_h list)
1375 contacts_record_h record;
1377 ctsvc_db_messenger_get_value_from_stmt(stmt, &record, 1);
1378 contacts_list_add(list, record);
1380 return CONTACTS_ERROR_NONE;
1383 int ctsvc_get_data_info_note(cts_stmt stmt, contacts_list_h list)
1385 contacts_record_h record;
1387 ctsvc_db_note_get_value_from_stmt(stmt, &record, 1);
1388 contacts_list_add(list, record);
1390 return CONTACTS_ERROR_NONE;
1393 int ctsvc_get_data_info_company(cts_stmt stmt, contacts_list_h list)
1395 contacts_record_h record;
1397 ctsvc_db_company_get_value_from_stmt(stmt, &record, 1);
1398 contacts_list_add(list, record);
1400 return CONTACTS_ERROR_NONE;
1403 int ctsvc_get_data_info_profile(cts_stmt stmt, contacts_list_h list)
1405 contacts_record_h record;
1407 ctsvc_db_profile_get_value_from_stmt(stmt, &record, 1);
1408 contacts_list_add(list, record);
1410 return CONTACTS_ERROR_NONE;
1413 int ctsvc_get_data_info_relationship(cts_stmt stmt, contacts_list_h list)
1415 contacts_record_h record;
1417 ctsvc_db_relationship_get_value_from_stmt(stmt, &record, 1);
1418 contacts_list_add(list, record);
1420 return CONTACTS_ERROR_NONE;
1423 int ctsvc_get_data_info_image(cts_stmt stmt, contacts_list_h list)
1425 contacts_record_h record;
1427 ctsvc_db_image_get_value_from_stmt(stmt, &record, 1);
1428 contacts_list_add(list, record);
1430 return CONTACTS_ERROR_NONE;
1433 int ctsvc_get_data_info_url(cts_stmt stmt, contacts_list_h list)
1435 contacts_record_h record;
1437 ctsvc_db_url_get_value_from_stmt(stmt, &record, 1);
1438 contacts_list_add(list, record);
1440 return CONTACTS_ERROR_NONE;
1443 int ctsvc_get_data_info_nickname(cts_stmt stmt, contacts_list_h list)
1445 contacts_record_h record;
1447 ctsvc_db_nickname_get_value_from_stmt(stmt, &record, 1);
1448 contacts_list_add(list, record);
1450 return CONTACTS_ERROR_NONE;
1453 int ctsvc_get_data_info_extension(cts_stmt stmt, contacts_list_h list)
1455 contacts_record_h record;
1457 ctsvc_db_extension_get_value_from_stmt(stmt, &record, 1);
1458 contacts_list_add(list, record);
1460 return CONTACTS_ERROR_NONE;
1463 int ctsvc_get_data_info_sip(cts_stmt stmt, contacts_list_h list)
1465 contacts_record_h record;
1467 ctsvc_db_sip_get_value_from_stmt(stmt, &record, 1);
1468 contacts_list_add(list, record);
1470 return CONTACTS_ERROR_NONE;
1473 bool ctsvc_contact_check_default_number(contacts_list_h number_list)
1475 bool has_default = false;
1476 ctsvc_number_s *number;
1480 RETV_IF(NULL == number_list, false);
1482 ret = contacts_list_get_count(number_list, &count);
1483 if (CONTACTS_ERROR_NONE != ret || 0 == count)
1486 contacts_list_first(number_list);
1488 contacts_list_get_current_record_p(number_list, (contacts_record_h*)&number);
1489 if (number && number->number && *number->number) {
1490 if (number->is_default && false == has_default)
1492 else if (has_default)
1493 number->is_default = false;
1495 } while (CONTACTS_ERROR_NONE == contacts_list_next(number_list));
1497 if (false == has_default) {
1498 contacts_list_first(number_list);
1500 contacts_list_get_current_record_p(number_list, (contacts_record_h*)&number);
1501 if (number && number->number && *number->number) {
1502 number->is_default = true;
1503 ctsvc_record_set_property_flag((ctsvc_record_s*)number, _contacts_number.is_default, CTSVC_PROPERTY_FLAG_DIRTY);
1507 } while (CONTACTS_ERROR_NONE == contacts_list_next(number_list));
1512 bool ctsvc_contact_check_default_email(contacts_list_h email_list)
1514 bool has_default = false;
1515 ctsvc_email_s *email;
1519 RETV_IF(NULL == email_list, false);
1521 ret = contacts_list_get_count(email_list, &count);
1522 if (CONTACTS_ERROR_NONE != ret || 0 == count)
1525 contacts_list_first(email_list);
1527 contacts_list_get_current_record_p(email_list, (contacts_record_h*)&email);
1528 if (email && email->email_addr && *email->email_addr) {
1529 if (email->is_default && false == has_default)
1531 else if (has_default)
1532 email->is_default = false;
1534 } while (CONTACTS_ERROR_NONE == contacts_list_next(email_list));
1536 if (false == has_default) {
1537 contacts_list_first(email_list);
1539 contacts_list_get_current_record_p(email_list, (contacts_record_h*)&email);
1540 if (email && email->email_addr && *email->email_addr) {
1541 email->is_default = true;
1542 ctsvc_record_set_property_flag((ctsvc_record_s*)email, _contacts_email.is_default, CTSVC_PROPERTY_FLAG_DIRTY);
1546 } while (CONTACTS_ERROR_NONE == contacts_list_next(email_list));
1551 bool ctsvc_contact_check_default_image(contacts_list_h image_list)
1553 bool has_default = false;
1554 ctsvc_image_s *image;
1558 RETV_IF(NULL == image_list, false);
1560 ret = contacts_list_get_count(image_list, &count);
1561 if (CONTACTS_ERROR_NONE != ret || 0 == count) {
1562 DBG("list get count Fail(%d)", count);
1566 contacts_list_first(image_list);
1568 contacts_list_get_current_record_p(image_list, (contacts_record_h*)&image);
1569 if (image && image->path && *image->path) {
1570 if (image->is_default && false == has_default)
1572 else if (has_default)
1573 image->is_default = false;
1575 } while (CONTACTS_ERROR_NONE == contacts_list_next(image_list));
1577 if (false == has_default) {
1578 contacts_list_first(image_list);
1580 contacts_list_get_current_record_p(image_list, (contacts_record_h*)&image);
1581 if (image && image->path && *image->path) {
1582 image->is_default = true;
1583 ctsvc_record_set_property_flag((ctsvc_record_s*)image, _contacts_image.is_default, CTSVC_PROPERTY_FLAG_DIRTY);
1587 } while (CONTACTS_ERROR_NONE == contacts_list_next(image_list));
1589 return CONTACTS_ERROR_NONE;
1592 bool ctsvc_contact_check_default_address(contacts_list_h address_list)
1594 bool has_default = false;
1595 ctsvc_address_s *address;
1599 RETV_IF(NULL == address_list, false);
1601 ret = contacts_list_get_count(address_list, &count);
1602 if (CONTACTS_ERROR_NONE != ret || 0 == count) {
1603 DBG("list get count Fail(%d)", count);
1607 contacts_list_first(address_list);
1609 contacts_list_get_current_record_p(address_list, (contacts_record_h*)&address);
1611 (address->pobox || address->postalcode || address->region || address->locality
1612 || address->street || address->extended || address->country)) {
1613 if (address->is_default && false == has_default)
1615 else if (has_default)
1616 address->is_default = false;
1618 } while (CONTACTS_ERROR_NONE == contacts_list_next(address_list));
1620 if (false == has_default) {
1621 contacts_list_first(address_list);
1623 contacts_list_get_current_record_p(address_list, (contacts_record_h*)&address);
1625 (address->pobox || address->postalcode || address->region || address->locality
1626 || address->street || address->extended || address->country)) {
1627 address->is_default = true;
1628 ctsvc_record_set_property_flag((ctsvc_record_s*)address, _contacts_address.is_default, CTSVC_PROPERTY_FLAG_DIRTY);
1632 } while (CONTACTS_ERROR_NONE == contacts_list_next(address_list));
1634 return CONTACTS_ERROR_NONE;
1637 int ctsvc_contact_update_data_name(contacts_list_h name_list, int contact_id, bool is_my_profile)
1640 int ret = CONTACTS_ERROR_NONE;
1641 contacts_record_h record;
1643 ctsvc_list_s *list = (ctsvc_list_s*)name_list;
1645 RETV_IF(NULL == name_list, CONTACTS_ERROR_INVALID_PARAMETER);
1647 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1648 name = cursor->data;
1649 ctsvc_db_name_delete(name->id, is_my_profile);
1652 contacts_list_first(name_list);
1653 contacts_list_get_current_record_p(name_list, &record);
1655 name = (ctsvc_name_s*)record;
1657 if (name->first || name->last || name->addition || name->prefix || name->suffix
1658 || name->phonetic_first || name->phonetic_middle || name->phonetic_last) {
1659 ret = ctsvc_db_name_update(record, is_my_profile);
1661 ret = ctsvc_db_name_delete(name->id, is_my_profile);
1664 ret = ctsvc_db_name_insert(record, contact_id, is_my_profile, NULL);
1666 if (CONTACTS_ERROR_DB == ret)
1667 ERR("return(%d)", ret);
1673 int ctsvc_contact_update_data_company(contacts_list_h company_list, int contact_id, bool is_my_profile)
1676 int ret = CONTACTS_ERROR_NONE;
1677 contacts_record_h record = NULL;
1679 ctsvc_list_s *list = (ctsvc_list_s*)company_list;
1680 ctsvc_company_s *company;
1683 RETV_IF(NULL == company_list, CONTACTS_ERROR_INVALID_PARAMETER);
1685 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1686 company = cursor->data;
1687 ctsvc_db_company_delete(company->id, is_my_profile);
1690 ret = contacts_list_get_count(company_list, &count);
1692 return CONTACTS_ERROR_NONE;
1694 contacts_list_first(company_list);
1696 contacts_list_get_current_record_p(company_list, &record);
1697 company = (ctsvc_company_s*)record;
1698 if (0 < company->id) {
1699 if (company->name || company->department || company->job_title || company->role
1700 || company->assistant_name || company->logo || company->location || company->description
1701 || company->phonetic_name) {
1702 ret = ctsvc_db_company_update(record, contact_id, is_my_profile);
1704 ret = ctsvc_db_company_delete(company->id, is_my_profile);
1707 ret = ctsvc_db_company_insert(record, contact_id, is_my_profile, NULL);
1709 if (CONTACTS_ERROR_DB == ret) {
1710 ERR("return (%d)", ret);
1713 } while (CONTACTS_ERROR_NONE == contacts_list_next(company_list));
1718 int ctsvc_contact_update_data_note(contacts_list_h note_list, int contact_id, bool is_my_profile)
1721 int ret = CONTACTS_ERROR_NONE;
1722 contacts_record_h record = NULL;
1724 ctsvc_list_s *list = (ctsvc_list_s*)note_list;
1728 RETV_IF(NULL == note_list, CONTACTS_ERROR_INVALID_PARAMETER);
1730 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1731 note = cursor->data;
1732 ctsvc_db_note_delete(note->id, is_my_profile);
1735 ret = contacts_list_get_count(note_list, &count);
1737 return CONTACTS_ERROR_NONE;
1739 contacts_list_first(note_list);
1741 contacts_list_get_current_record_p(note_list, &record);
1742 note = (ctsvc_note_s*)record;
1745 ret = ctsvc_db_note_update(record, is_my_profile);
1747 ret = ctsvc_db_note_delete(note->id, is_my_profile);
1749 ret = ctsvc_db_note_insert(record, contact_id, is_my_profile, NULL);
1751 if (CONTACTS_ERROR_DB == ret) {
1752 ERR("return (%d)", ret);
1755 } while (CONTACTS_ERROR_NONE == contacts_list_next(note_list));
1760 int ctsvc_contact_update_data_event(contacts_list_h event_list, int contact_id, bool is_my_profile)
1763 int ret = CONTACTS_ERROR_NONE;
1764 contacts_record_h record = NULL;
1766 ctsvc_list_s *list = (ctsvc_list_s*)event_list;
1767 ctsvc_event_s *event;
1770 RETV_IF(NULL == event_list, CONTACTS_ERROR_INVALID_PARAMETER);
1772 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1773 event = cursor->data;
1774 ctsvc_db_event_delete(event->id, is_my_profile);
1777 ret = contacts_list_get_count(event_list, &count);
1779 return CONTACTS_ERROR_NONE;
1781 contacts_list_first(event_list);
1783 contacts_list_get_current_record_p(event_list, &record);
1784 event = (ctsvc_event_s*)record;
1785 if (0 < event->id) {
1786 if (0 < event->date)
1787 ret = ctsvc_db_event_update(record, is_my_profile);
1789 ret = ctsvc_db_event_delete(event->id, is_my_profile);
1791 ret = ctsvc_db_event_insert(record, contact_id, is_my_profile, NULL);
1793 if (CONTACTS_ERROR_DB == ret) {
1794 ERR("return (%d)", ret);
1797 } while (CONTACTS_ERROR_NONE == contacts_list_next(event_list));
1802 int ctsvc_contact_update_data_messenger(contacts_list_h messenger_list, int contact_id, bool is_my_profile)
1805 int ret = CONTACTS_ERROR_NONE;
1806 contacts_record_h record = NULL;
1808 ctsvc_list_s *list = (ctsvc_list_s*)messenger_list;
1809 ctsvc_messenger_s *messenger;
1812 RETV_IF(NULL == messenger_list, CONTACTS_ERROR_INVALID_PARAMETER);
1814 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1815 messenger = cursor->data;
1816 ctsvc_db_messenger_delete(messenger->id, is_my_profile);
1819 ret = contacts_list_get_count(messenger_list, &count);
1821 return CONTACTS_ERROR_NONE;
1823 contacts_list_first(messenger_list);
1825 contacts_list_get_current_record_p(messenger_list, &record);
1826 messenger = (ctsvc_messenger_s*)record;
1827 if (0 < messenger->id) {
1828 if (messenger->im_id)
1829 ret = ctsvc_db_messenger_update(record, is_my_profile);
1831 ret = ctsvc_db_messenger_delete(messenger->id, is_my_profile);
1833 ret = ctsvc_db_messenger_insert(record, contact_id, is_my_profile, NULL);
1835 if (CONTACTS_ERROR_DB == ret) {
1836 ERR("return (%d)", ret);
1839 } while (CONTACTS_ERROR_NONE == contacts_list_next(messenger_list));
1844 int ctsvc_contact_update_data_address(contacts_list_h address_list, int contact_id, bool is_my_profile)
1847 int ret = CONTACTS_ERROR_NONE;
1848 contacts_record_h record = NULL;
1850 ctsvc_list_s *list = (ctsvc_list_s*)address_list;
1851 ctsvc_address_s *address;
1854 RETV_IF(NULL == address_list, CONTACTS_ERROR_INVALID_PARAMETER);
1856 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1857 address = cursor->data;
1858 ctsvc_db_address_delete(address->id, is_my_profile);
1861 ret = contacts_list_get_count(address_list, &count);
1863 return CONTACTS_ERROR_NONE;
1865 contacts_list_first(address_list);
1867 contacts_list_get_current_record_p(address_list, &record);
1868 address = (ctsvc_address_s*)record;
1869 if (0 < address->id) {
1870 if (address->pobox || address->postalcode || address->region || address->locality
1871 || address->street || address->extended || address->country) {
1872 ret = ctsvc_db_address_update(record, is_my_profile);
1874 ret = ctsvc_db_address_delete(address->id, is_my_profile);
1877 ret = ctsvc_db_address_insert(record, contact_id, is_my_profile, NULL);
1879 if (CONTACTS_ERROR_DB == ret) {
1880 ERR("return (%d)", ret);
1883 } while (CONTACTS_ERROR_NONE == contacts_list_next(address_list));
1888 int ctsvc_contact_update_data_url(contacts_list_h url_list, int contact_id, bool is_my_profile)
1891 int ret = CONTACTS_ERROR_NONE;
1892 contacts_record_h record = NULL;
1894 ctsvc_list_s *list = (ctsvc_list_s*)url_list;
1898 RETV_IF(NULL == url_list, CONTACTS_ERROR_INVALID_PARAMETER);
1900 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1902 ctsvc_db_url_delete(url->id, is_my_profile);
1905 ret = contacts_list_get_count(url_list, &count);
1907 return CONTACTS_ERROR_NONE;
1909 contacts_list_first(url_list);
1911 contacts_list_get_current_record_p(url_list, &record);
1912 url = (ctsvc_url_s*)record;
1915 ret = ctsvc_db_url_update(record, is_my_profile);
1917 ret = ctsvc_db_url_delete(url->id, is_my_profile);
1919 ret = ctsvc_db_url_insert(record, contact_id, is_my_profile, NULL);
1921 if (CONTACTS_ERROR_DB == ret) {
1922 ERR("return (%d)", ret);
1925 } while (CONTACTS_ERROR_NONE == contacts_list_next(url_list));
1930 int ctsvc_contact_update_data_profile(contacts_list_h profile_list, int contact_id, bool is_my_profile)
1933 int ret = CONTACTS_ERROR_NONE;
1934 contacts_record_h record = NULL;
1936 ctsvc_list_s *list = (ctsvc_list_s*)profile_list;
1937 ctsvc_profile_s *profile;
1940 RETV_IF(NULL == profile_list, CONTACTS_ERROR_INVALID_PARAMETER);
1942 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1943 profile = cursor->data;
1944 ctsvc_db_profile_delete(profile->id, is_my_profile);
1946 ret = contacts_list_get_count(profile_list, &count);
1948 return CONTACTS_ERROR_NONE;
1950 contacts_list_first(profile_list);
1952 contacts_list_get_current_record_p(profile_list, &record);
1953 profile = (ctsvc_profile_s*)record;
1954 if (0 < profile->id) {
1956 ret = ctsvc_db_profile_update(record, is_my_profile);
1958 ret = ctsvc_db_profile_delete(profile->id, is_my_profile);
1960 ret = ctsvc_db_profile_insert(record, contact_id, is_my_profile, NULL);
1962 if (CONTACTS_ERROR_DB == ret) {
1963 ERR("return (%d)", ret);
1966 } while (CONTACTS_ERROR_NONE == contacts_list_next(profile_list));
1971 int ctsvc_contact_update_data_relationship(contacts_list_h relationship_list, int contact_id, bool is_my_profile)
1974 int ret = CONTACTS_ERROR_NONE;
1975 contacts_record_h record = NULL;
1977 ctsvc_list_s *list = (ctsvc_list_s*)relationship_list;
1978 ctsvc_relationship_s *relationship;
1981 RETV_IF(NULL == relationship_list, CONTACTS_ERROR_INVALID_PARAMETER);
1983 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
1984 relationship = cursor->data;
1985 ctsvc_db_relationship_delete(relationship->id, is_my_profile);
1988 ret = contacts_list_get_count(relationship_list, &count);
1990 return CONTACTS_ERROR_NONE;
1992 contacts_list_first(relationship_list);
1994 contacts_list_get_current_record_p(relationship_list, &record);
1995 relationship = (ctsvc_relationship_s*)record;
1996 if (0 < relationship->id) {
1997 if (relationship->name)
1998 ret = ctsvc_db_relationship_update(record, is_my_profile);
2000 ret = ctsvc_db_relationship_delete(relationship->id, is_my_profile);
2002 ret = ctsvc_db_relationship_insert(record, contact_id, is_my_profile, NULL);
2004 if (CONTACTS_ERROR_DB == ret) {
2005 ERR("return (%d)", ret);
2008 } while (CONTACTS_ERROR_NONE == contacts_list_next(relationship_list));
2013 int ctsvc_contact_update_data_image(contacts_list_h image_list, int contact_id, bool is_my_profile)
2016 int ret = CONTACTS_ERROR_NONE;
2017 contacts_record_h record = NULL;
2019 ctsvc_list_s *list = (ctsvc_list_s*)image_list;
2020 ctsvc_image_s *image;
2023 RETV_IF(NULL == image_list, CONTACTS_ERROR_INVALID_PARAMETER);
2025 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
2026 image = cursor->data;
2027 ctsvc_db_image_delete(image->id, is_my_profile);
2030 ret = contacts_list_get_count(image_list, &count);
2032 return CONTACTS_ERROR_NONE;
2034 contacts_list_first(image_list);
2036 contacts_list_get_current_record_p(image_list, &record);
2037 image = (ctsvc_image_s*)record;
2038 if (CTSVC_PROPERTY_FLAG_DIRTY & image->base.property_flag) {
2039 if (0 < image->id) {
2041 ret = ctsvc_db_image_update(record, contact_id, is_my_profile);
2043 ret = ctsvc_db_image_delete(image->id, is_my_profile);
2045 ret = ctsvc_db_image_insert(record, contact_id, is_my_profile, NULL);
2048 if (CONTACTS_ERROR_DB == ret) {
2049 ERR("return (%d)", ret);
2052 } while (CONTACTS_ERROR_NONE == contacts_list_next(image_list));
2057 int ctsvc_contact_update_data_nickname(contacts_list_h nickname_list, int contact_id, bool is_my_profile)
2060 int ret = CONTACTS_ERROR_NONE;
2061 contacts_record_h record = NULL;
2063 ctsvc_list_s *list = (ctsvc_list_s*)nickname_list;
2064 ctsvc_nickname_s *nickname;
2067 RETV_IF(NULL == nickname_list, CONTACTS_ERROR_INVALID_PARAMETER);
2069 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
2070 nickname = cursor->data;
2071 ctsvc_db_nickname_delete(nickname->id, is_my_profile);
2074 ret = contacts_list_get_count(nickname_list, &count);
2076 return CONTACTS_ERROR_NONE;
2078 contacts_list_first(nickname_list);
2080 contacts_list_get_current_record_p(nickname_list, &record);
2081 nickname = (ctsvc_nickname_s*)record;
2082 if (0 < nickname->id) {
2083 if (nickname->nickname)
2084 ret = ctsvc_db_nickname_update(record, is_my_profile);
2086 ret = ctsvc_db_nickname_delete(nickname->id, is_my_profile);
2088 ret = ctsvc_db_nickname_insert(record, contact_id, is_my_profile, NULL);
2090 if (CONTACTS_ERROR_DB == ret) {
2091 ERR("return (%d)", ret);
2094 } while (CONTACTS_ERROR_NONE == contacts_list_next(nickname_list));
2099 int ctsvc_contact_update_data_extension(contacts_list_h extension_list, int contact_id, bool is_my_profile)
2102 int ret = CONTACTS_ERROR_NONE;
2103 contacts_record_h record = NULL;
2105 ctsvc_list_s *list = (ctsvc_list_s*)extension_list;
2106 ctsvc_extension_s *extension;
2109 RETV_IF(NULL == extension_list, CONTACTS_ERROR_INVALID_PARAMETER);
2111 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
2112 extension = cursor->data;
2113 ctsvc_db_extension_delete(extension->id, is_my_profile);
2116 ret = contacts_list_get_count(extension_list, &count);
2118 return CONTACTS_ERROR_NONE;
2120 contacts_list_first(extension_list);
2122 contacts_list_get_current_record_p(extension_list, &record);
2123 extension = (ctsvc_extension_s*)record;
2124 if (0 < extension->id) {
2125 if (extension->data2 || extension->data3 || extension->data4 || extension->data5
2126 || extension->data6 || extension->data7 || extension->data8 || extension->data9
2127 || extension->data10 || extension->data11 || extension->data12) {
2128 ret = ctsvc_db_extension_update(record);
2130 ret = ctsvc_db_extension_delete(extension->id, is_my_profile);
2133 ret = ctsvc_db_extension_insert(record, contact_id, is_my_profile, NULL);
2135 if (CONTACTS_ERROR_DB == ret) {
2136 ERR("return (%d)", ret);
2139 } while (CONTACTS_ERROR_NONE == contacts_list_next(extension_list));
2144 int ctsvc_contact_update_data_sip(contacts_list_h sip_list, int contact_id, bool is_my_profile)
2147 int ret = CONTACTS_ERROR_NONE;
2148 contacts_record_h record = NULL;
2150 ctsvc_list_s *list = (ctsvc_list_s*)sip_list;
2154 RETV_IF(NULL == sip_list, CONTACTS_ERROR_INVALID_PARAMETER);
2156 for (cursor = list->deleted_records;cursor;cursor=cursor->next) {
2157 sip = (ctsvc_sip_s *)cursor->data;
2158 ctsvc_db_sip_delete(sip->id, is_my_profile);
2161 ret = contacts_list_get_count(sip_list, &count);
2163 return CONTACTS_ERROR_NONE;
2165 contacts_list_first(sip_list);
2167 contacts_list_get_current_record_p(sip_list, &record);
2168 sip = (ctsvc_sip_s*)record;
2171 ret = ctsvc_db_sip_update(record, is_my_profile);
2173 ret = ctsvc_db_sip_delete(sip->id, is_my_profile);
2176 ret = ctsvc_db_sip_insert(record, contact_id, is_my_profile, NULL);
2177 if (CONTACTS_ERROR_DB == ret) {
2178 ERR("DB error : return (%d)", ret);
2181 } while (CONTACTS_ERROR_NONE == contacts_list_next(sip_list));
2186 int ctsvc_contact_update_data_number(contacts_list_h number_list,
2187 int contact_id, bool is_my_profile, bool *had_phonenumber)
2190 int ret = CONTACTS_ERROR_NONE;
2191 contacts_record_h record = NULL;
2193 ctsvc_list_s *list = (ctsvc_list_s*)number_list;
2194 ctsvc_number_s *number;
2197 *had_phonenumber = false;
2199 RETV_IF(NULL == number_list, CONTACTS_ERROR_INVALID_PARAMETER);
2201 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
2202 number = cursor->data;
2203 ctsvc_db_number_delete(number->id, is_my_profile);
2206 ret = contacts_list_get_count(number_list, &count);
2208 return CONTACTS_ERROR_NONE;
2210 contacts_list_first(number_list);
2212 contacts_list_get_current_record_p(number_list, &record);
2213 number = (ctsvc_number_s*)record;
2214 if (0 < number->id) {
2215 if (number->number) {
2216 ret = ctsvc_db_number_update(record, is_my_profile);
2219 ret = ctsvc_db_number_delete(number->id, is_my_profile);
2221 } else if (number->number) {
2222 ret = ctsvc_db_number_insert(record, contact_id, is_my_profile, NULL);
2225 if (CONTACTS_ERROR_DB == ret) {
2226 ERR("return (%d)", ret);
2229 } while (CONTACTS_ERROR_NONE == contacts_list_next(number_list));
2231 *had_phonenumber = had;
2235 int ctsvc_contact_update_data_email(contacts_list_h email_list,
2236 int contact_id, bool is_my_profile, bool *had_email)
2239 int ret = CONTACTS_ERROR_NONE;
2240 contacts_record_h record = NULL;
2242 ctsvc_list_s *list = (ctsvc_list_s*)email_list;
2243 ctsvc_email_s *email;
2248 RETV_IF(NULL == email_list, CONTACTS_ERROR_INVALID_PARAMETER);
2250 for (cursor = list->deleted_records; cursor; cursor = cursor->next) {
2251 email = cursor->data;
2252 ctsvc_db_email_delete(email->id, is_my_profile);
2255 ret = contacts_list_get_count(email_list, &count);
2257 return CONTACTS_ERROR_NONE;
2259 contacts_list_first(email_list);
2261 contacts_list_get_current_record_p(email_list, &record);
2262 email = (ctsvc_email_s*)record;
2264 if (0 < email->id) {
2265 if (email->email_addr) {
2266 ret = ctsvc_db_email_update(record, is_my_profile);
2269 ret = ctsvc_db_email_delete(email->id, is_my_profile);
2271 } else if (email->email_addr) {
2272 ret = ctsvc_db_email_insert(record, contact_id, is_my_profile, NULL);
2275 if (CONTACTS_ERROR_DB == ret) {
2276 ERR("return (%d)", ret);
2279 } while (CONTACTS_ERROR_NONE == contacts_list_next(email_list));
2285 int ctsvc_contact_insert_data_name(contacts_list_h name_list, int contact_id, bool is_my_profile)
2288 int ret = CONTACTS_ERROR_NONE;
2289 contacts_record_h record;
2290 RETV_IF(NULL == name_list, CONTACTS_ERROR_INVALID_PARAMETER);
2292 contacts_list_first(name_list);
2293 contacts_list_get_current_record_p(name_list, &record);
2295 ret = ctsvc_db_name_insert(record, contact_id, is_my_profile, NULL);
2296 if (CONTACTS_ERROR_DB == ret)
2297 ERR("ctsvc_db_name_insert() Fail");
2302 int ctsvc_contact_insert_data_number(contacts_list_h number_list, int contact_id, bool is_my_profile)
2305 int ret = CONTACTS_ERROR_NONE;
2306 contacts_record_h record;
2309 RETV_IF(NULL == number_list, CONTACTS_ERROR_INVALID_PARAMETER);
2310 ret = contacts_list_get_count(number_list, &count);
2312 return CONTACTS_ERROR_NONE;
2314 contacts_list_first(number_list);
2316 contacts_list_get_current_record_p(number_list, &record);
2317 ret = ctsvc_db_number_insert(record, contact_id, is_my_profile, NULL);
2318 if (CONTACTS_ERROR_DB == ret) {
2319 ERR("ctsvc_db_number_insert");
2322 } while (CONTACTS_ERROR_NONE == contacts_list_next(number_list));
2327 int ctsvc_contact_insert_data_email(contacts_list_h email_list, int contact_id, bool is_my_profile)
2330 int ret = CONTACTS_ERROR_NONE;
2331 contacts_record_h record;
2334 RETV_IF(NULL == email_list, CONTACTS_ERROR_INVALID_PARAMETER);
2335 ret = contacts_list_get_count(email_list, &count);
2337 return CONTACTS_ERROR_NONE;
2339 contacts_list_first(email_list);
2341 contacts_list_get_current_record_p(email_list, &record);
2342 ret = ctsvc_db_email_insert(record, contact_id, is_my_profile, NULL);
2343 if (CONTACTS_ERROR_DB == ret) {
2344 ERR("ctsvc_db_email_insert");
2347 } while (CONTACTS_ERROR_NONE == contacts_list_next(email_list));
2352 int ctsvc_contact_insert_data_profile(contacts_list_h profile_list, int contact_id, bool is_my_profile)
2355 int ret = CONTACTS_ERROR_NONE;
2356 contacts_record_h record;
2359 RETV_IF(NULL == profile_list, CONTACTS_ERROR_INVALID_PARAMETER);
2360 ret = contacts_list_get_count(profile_list, &count);
2362 return CONTACTS_ERROR_NONE;
2364 contacts_list_first(profile_list);
2366 contacts_list_get_current_record_p(profile_list, &record);
2367 ret = ctsvc_db_profile_insert(record, contact_id, is_my_profile, NULL);
2368 if (CONTACTS_ERROR_DB == ret) {
2369 ERR("ctsvc_db_profile_insert");
2372 } while (CONTACTS_ERROR_NONE == contacts_list_next(profile_list));
2377 int ctsvc_contact_insert_data_company(contacts_list_h company_list, int contact_id, bool is_my_profile)
2380 int ret = CONTACTS_ERROR_NONE;
2381 contacts_record_h record = NULL;
2384 RETV_IF(NULL == company_list, CONTACTS_ERROR_INVALID_PARAMETER);
2385 ret = contacts_list_get_count(company_list, &count);
2387 return CONTACTS_ERROR_NONE;
2389 contacts_list_first(company_list);
2391 contacts_list_get_current_record_p(company_list, &record);
2392 ret = ctsvc_db_company_insert(record, contact_id, is_my_profile, NULL);
2393 if (CONTACTS_ERROR_DB == ret) {
2394 ERR("ctsvc_db_company_insert");
2397 } while (CONTACTS_ERROR_NONE == contacts_list_next(company_list));
2402 int ctsvc_contact_insert_data_note(contacts_list_h note_list, int contact_id, bool is_my_profile)
2405 int ret = CONTACTS_ERROR_NONE;
2406 contacts_record_h record = NULL;
2409 RETV_IF(NULL == note_list, CONTACTS_ERROR_INVALID_PARAMETER);
2410 ret = contacts_list_get_count(note_list, &count);
2412 return CONTACTS_ERROR_NONE;
2414 contacts_list_first(note_list);
2416 contacts_list_get_current_record_p(note_list, &record);
2418 ret = ctsvc_db_note_insert(record, contact_id, is_my_profile, NULL);
2419 if (CONTACTS_ERROR_DB == ret) {
2420 ERR("ctsvc_db_note_insert");
2424 } while (CONTACTS_ERROR_NONE == contacts_list_next(note_list));
2428 int ctsvc_contact_insert_data_event(contacts_list_h event_list, int contact_id, bool is_my_profile)
2431 int ret = CONTACTS_ERROR_NONE;
2432 contacts_record_h record;
2435 RETV_IF(NULL == event_list, CONTACTS_ERROR_INVALID_PARAMETER);
2436 ret = contacts_list_get_count(event_list, &count);
2438 return CONTACTS_ERROR_NONE;
2440 contacts_list_first(event_list);
2442 contacts_list_get_current_record_p(event_list, &record);
2443 ret = ctsvc_db_event_insert(record, contact_id, is_my_profile, NULL);
2444 if (CONTACTS_ERROR_DB == ret) {
2445 ERR("ctsvc_db_event_insert");
2448 } while (CONTACTS_ERROR_NONE == contacts_list_next(event_list));
2453 int ctsvc_contact_insert_data_messenger(contacts_list_h messenger_list, int contact_id, bool is_my_profile)
2456 int ret = CONTACTS_ERROR_NONE;
2457 contacts_record_h record;
2460 RETV_IF(NULL == messenger_list, CONTACTS_ERROR_INVALID_PARAMETER);
2461 ret = contacts_list_get_count(messenger_list, &count);
2463 return CONTACTS_ERROR_NONE;
2465 contacts_list_first(messenger_list);
2467 contacts_list_get_current_record_p(messenger_list, &record);
2468 ret = ctsvc_db_messenger_insert(record, contact_id, is_my_profile, NULL);
2469 if (CONTACTS_ERROR_DB == ret) {
2470 ERR("ctsvc_db_messenger_insert");
2473 } while (CONTACTS_ERROR_NONE == contacts_list_next(messenger_list));
2478 int ctsvc_contact_insert_data_address(contacts_list_h address_list, int contact_id, bool is_my_profile)
2481 int ret = CONTACTS_ERROR_NONE;
2482 contacts_record_h record;
2485 RETV_IF(NULL == address_list, CONTACTS_ERROR_INVALID_PARAMETER);
2486 ret = contacts_list_get_count(address_list, &count);
2488 return CONTACTS_ERROR_NONE;
2490 contacts_list_first(address_list);
2492 contacts_list_get_current_record_p(address_list, &record);
2493 ret = ctsvc_db_address_insert(record, contact_id, is_my_profile, NULL);
2494 if (CONTACTS_ERROR_DB == ret) {
2495 ERR("ctsvc_db_address_insert");
2498 } while (CONTACTS_ERROR_NONE == contacts_list_next(address_list));
2503 int ctsvc_contact_insert_data_url(contacts_list_h url_list, int contact_id, bool is_my_profile)
2506 int ret = CONTACTS_ERROR_NONE;
2507 contacts_record_h record;
2510 RETV_IF(NULL == url_list, CONTACTS_ERROR_INVALID_PARAMETER);
2511 ret = contacts_list_get_count(url_list, &count);
2513 return CONTACTS_ERROR_NONE;
2515 contacts_list_first(url_list);
2517 contacts_list_get_current_record_p(url_list, &record);
2518 ret = ctsvc_db_url_insert(record, contact_id, is_my_profile, NULL);
2519 if (CONTACTS_ERROR_DB == ret) {
2520 ERR("ctsvc_db_url_insert");
2523 } while (CONTACTS_ERROR_NONE == contacts_list_next(url_list));
2528 int ctsvc_contact_insert_data_nickname(contacts_list_h nickname_list, int contact_id, bool is_my_profile)
2531 int ret = CONTACTS_ERROR_NONE;
2532 contacts_record_h record;
2535 RETV_IF(NULL == nickname_list, CONTACTS_ERROR_INVALID_PARAMETER);
2536 ret = contacts_list_get_count(nickname_list, &count);
2538 return CONTACTS_ERROR_NONE;
2540 contacts_list_first(nickname_list);
2542 contacts_list_get_current_record_p(nickname_list, &record);
2543 ret = ctsvc_db_nickname_insert(record, contact_id, is_my_profile, NULL);
2544 if (CONTACTS_ERROR_DB == ret) {
2545 ERR("ctsvc_db_nickname_insert");
2548 } while (CONTACTS_ERROR_NONE == contacts_list_next(nickname_list));
2553 int ctsvc_contact_insert_data_relationship(contacts_list_h relationship_list, int contact_id, bool is_my_profile)
2556 int ret = CONTACTS_ERROR_NONE;
2557 contacts_record_h record;
2560 RETV_IF(NULL == relationship_list, CONTACTS_ERROR_INVALID_PARAMETER);
2561 ret = contacts_list_get_count(relationship_list, &count);
2563 return CONTACTS_ERROR_NONE;
2565 contacts_list_first(relationship_list);
2567 contacts_list_get_current_record_p(relationship_list, &record);
2568 ret = ctsvc_db_relationship_insert(record, contact_id, is_my_profile, NULL);
2569 if (CONTACTS_ERROR_DB == ret) {
2570 ERR("ctsvc_db_relationship_insert");
2573 } while (CONTACTS_ERROR_NONE == contacts_list_next(relationship_list));
2578 int ctsvc_contact_insert_data_image(contacts_list_h image_list, int contact_id, bool is_my_profile)
2581 int ret = CONTACTS_ERROR_NONE;
2582 contacts_record_h record;
2585 RETV_IF(NULL == image_list, CONTACTS_ERROR_INVALID_PARAMETER);
2586 ret = contacts_list_get_count(image_list, &count);
2588 return CONTACTS_ERROR_NONE;
2590 contacts_list_first(image_list);
2592 contacts_list_get_current_record_p(image_list, &record);
2593 ret = ctsvc_db_image_insert(record, contact_id, is_my_profile, NULL);
2594 if (CONTACTS_ERROR_DB == ret) {
2595 ERR("ctsvc_db_image_insert");
2598 } while (CONTACTS_ERROR_NONE == contacts_list_next(image_list));
2603 int ctsvc_contact_insert_data_extension(contacts_list_h extension_list, int contact_id, bool is_my_profile)
2606 int ret = CONTACTS_ERROR_NONE;
2607 contacts_record_h record;
2610 RETV_IF(NULL == extension_list, CONTACTS_ERROR_INVALID_PARAMETER);
2611 ret = contacts_list_get_count(extension_list, &count);
2613 return CONTACTS_ERROR_NONE;
2615 contacts_list_first(extension_list);
2617 contacts_list_get_current_record_p(extension_list, &record);
2618 ret = ctsvc_db_extension_insert(record, contact_id, is_my_profile, NULL);
2619 if (CONTACTS_ERROR_DB == ret) {
2620 ERR("ctsvc_db_extension_insert");
2623 } while (CONTACTS_ERROR_NONE == contacts_list_next(extension_list));
2628 int ctsvc_contact_insert_data_sip(contacts_list_h sip_list, int contact_id, bool is_my_profile)
2631 int ret = CONTACTS_ERROR_NONE;
2632 contacts_record_h record;
2635 RETV_IF(NULL == sip_list, CONTACTS_ERROR_INVALID_PARAMETER);
2636 ret = contacts_list_get_count(sip_list, &count);
2638 return CONTACTS_ERROR_NONE;
2640 contacts_list_first(sip_list);
2642 contacts_list_get_current_record_p(sip_list, &record);
2643 ret = ctsvc_db_sip_insert(record, contact_id, is_my_profile, NULL);
2644 if (CONTACTS_ERROR_DB == ret) {
2645 ERR("DB error : ctsvc_db_sip_insert");
2648 } while (CONTACTS_ERROR_NONE == contacts_list_next(sip_list));
2653 int ctsvc_contact_update_display_name(int contact_id, contacts_display_name_source_type_e changed_record_type)
2655 int ret = CONTACTS_ERROR_NONE;
2656 int display_name_type;
2657 contacts_record_h record;
2658 ret = ctsvc_db_contact_get(contact_id, (contacts_record_h*)&record);
2659 RETVM_IF(ret != CONTACTS_ERROR_NONE, ret, "ctsvc_db_contact_get Fail(%d)", ret);
2660 contacts_record_get_int(record, _contacts_contact.display_source_type, &display_name_type);
2662 if (display_name_type <= changed_record_type) {
2664 cts_stmt stmt = NULL;
2665 char query[CTS_SQL_MAX_LEN] = {0};
2666 ctsvc_contact_s *contact = (ctsvc_contact_s*)record;
2667 ctsvc_contact_make_display_name(contact);
2669 snprintf(query, sizeof(query), "UPDATE "CTS_TABLE_CONTACTS" SET "
2670 "display_name=?, reverse_display_name=?, display_name_source=%d, "
2671 "display_name_language=%d, reverse_display_name_language=%d, "
2672 "sort_name=?, reverse_sort_name=?, sortkey=?, reverse_sortkey=?, "
2673 "changed_ver=%d, changed_time=%d WHERE contact_id=%d",
2674 contact->display_source_type,
2675 contact->display_name_language, contact->reverse_display_name_language,
2676 ctsvc_get_next_ver(), (int)time(NULL), contact_id);
2678 ret = ctsvc_query_prepare(query, &stmt);
2680 ERR("ctsvc_query_prepare() Fail(%d)", ret);
2681 contacts_record_destroy(record, true);
2685 if (contact->display_name)
2686 ctsvc_stmt_bind_text(stmt, 1, contact->display_name);
2687 if (contact->reverse_display_name)
2688 ctsvc_stmt_bind_text(stmt, 2, contact->reverse_display_name);
2689 if (contact->sort_name)
2690 ctsvc_stmt_bind_text(stmt, 3, contact->sort_name);
2691 if (contact->reverse_sort_name)
2692 ctsvc_stmt_bind_text(stmt, 4, contact->reverse_sort_name);
2693 if (contact->sortkey)
2694 ctsvc_stmt_bind_text(stmt, 5, contact->sortkey);
2695 if (contact->reverse_sortkey)
2696 ctsvc_stmt_bind_text(stmt, 6, contact->reverse_sortkey);
2698 ret = ctsvc_stmt_step(stmt);
2699 WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_stmt_step() Fail(%d)", ret);
2701 ctsvc_stmt_finalize(stmt);
2704 contacts_record_destroy(record, true);
2708 extern ctsvc_db_plugin_info_s ctsvc_db_plugin_contact;
2709 int ctsvc_db_contact_get(int id, contacts_record_h *out_record)
2711 return ctsvc_db_plugin_contact.get_record(id, out_record);