server/db/ctsvc_db_plugin_name_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 "contacts.h"
  20 #include "ctsvc_internal.h"
  21 #include "ctsvc_db_schema.h"
  22 #include "ctsvc_db_sqlite.h"
  23 #include "ctsvc_normalize.h"
  24 #include "ctsvc_localize_utils.h"
  25 #include "ctsvc_db_init.h"
  26 #include "ctsvc_db_query.h"
  27 #include "ctsvc_db_plugin_name_helper.h"
  28 #include "ctsvc_record.h"
  29 #include "ctsvc_server_setting.h"
  30 #include "ctsvc_notification.h"
  31
  32 enum {
  33         CTSVC_NN_FIRST,
  34         CTSVC_NN_LAST,
  35         CTSVC_NN_MAX,
  36 };
  37
  38 static inline void __ctsvc_make_name_lookup(int op_code, const char *name_first,
  39                 const char *name_last, char **name_lookup)
  40 {
  41         if (name_first && NULL == name_last) {
  42                 *name_lookup = SAFE_STRDUP(name_first);
  43         } else if (NULL == name_first && name_last) {
  44                 *name_lookup = SAFE_STRDUP(name_last);
  45         } else {
  46                 if (CONTACTS_NAME_DISPLAY_ORDER_FIRSTLAST == op_code) {
  47                         *name_lookup = calloc(1, SAFE_STRLEN(name_first) + SAFE_STRLEN(name_last) + 3);
  48                         if (NULL == *name_lookup) {
  49                                 /* LCOV_EXCL_START */
  50                                 ERR("calloc() Fail");
  51                                 return;
  52                                 /* LCOV_EXCL_STOP */
  53                         }
  54                         snprintf(*name_lookup, SAFE_STRLEN(name_first) + SAFE_STRLEN(name_last) + 3, "%s %c%s",
  55                                         SAFE_STR(name_first), 0x7E, SAFE_STR(name_last));
  56                 } else {
  57                         *name_lookup = calloc(1, SAFE_STRLEN(name_first) + SAFE_STRLEN(name_last) + 5);
  58                         if (NULL == *name_lookup) {
  59                                 /* LCOV_EXCL_START */
  60                                 ERR("calloc() Fail");
  61                                 return;
  62                                 /* LCOV_EXCL_STOP */
  63                         }
  64                         snprintf(*name_lookup, SAFE_STRLEN(name_first) + SAFE_STRLEN(name_last) + 5, "%s,%c %c%s",
  65                                         SAFE_STR(name_last), 0x7E, 0x7E, SAFE_STR(name_first));
  66                 }
  67         }
  68 }
  69
  70 static inline int __ctsvc_name_bind_stmt(cts_stmt stmt, ctsvc_name_s *name, int start_cnt)
  71 {
  72         ctsvc_stmt_bind_int(stmt, start_cnt, name->is_default);
  73         ctsvc_stmt_bind_int(stmt, start_cnt+1, name->language_type);
  74         if (name->first)
  75                 sqlite3_bind_text(stmt, start_cnt+2, name->first,
  76                                 strlen(name->first), SQLITE_STATIC);
  77         if (name->last)
  78                 sqlite3_bind_text(stmt, start_cnt+3, name->last,
  79                                 strlen(name->last), SQLITE_STATIC);
  80         if (name->addition)
  81                 sqlite3_bind_text(stmt, start_cnt+4, name->addition,
  82                                 strlen(name->addition), SQLITE_STATIC);
  83         if (name->prefix)
  84                 sqlite3_bind_text(stmt, start_cnt+5, name->prefix,
  85                                 strlen(name->prefix), SQLITE_STATIC);
  86         if (name->suffix)
  87                 sqlite3_bind_text(stmt, start_cnt+6, name->suffix,
  88                                 strlen(name->suffix), SQLITE_STATIC);
  89         if (name->phonetic_first)
  90                 sqlite3_bind_text(stmt, start_cnt+7, name->phonetic_first,
  91                                 strlen(name->phonetic_first), SQLITE_STATIC);
  92         if (name->phonetic_middle)
  93                 sqlite3_bind_text(stmt, start_cnt+8, name->phonetic_middle,
  94                                 strlen(name->phonetic_middle), SQLITE_STATIC);
  95         if (name->phonetic_last)
  96                 sqlite3_bind_text(stmt, start_cnt+9, name->phonetic_last,
  97                                 strlen(name->phonetic_last), SQLITE_STATIC);
  98         if (name->lookup)
  99                 sqlite3_bind_text(stmt, start_cnt+10, name->lookup,
 100                                 strlen(name->lookup), SQLITE_STATIC);
 101         if (name->reverse_lookup)
 102                 sqlite3_bind_text(stmt, start_cnt+11, name->reverse_lookup,
 103                                 strlen(name->reverse_lookup), SQLITE_STATIC);
 104         return CONTACTS_ERROR_NONE;
 105 }
 106
 107 static int __ctsvc_normalize_name(ctsvc_name_s *src, char *dest[])
 108 {
 109         int ret = CONTACTS_ERROR_NO_DATA;
 110         int language_type = 0;
 111
 112         if (src->first) {
 113                 ret = ctsvc_normalize_str(src->first, &dest[CTSVC_NN_FIRST]);
 114                 RETVM_IF(ret < CONTACTS_ERROR_NONE, ret, "ctsvc_normalize_str() Fail(%d)", ret);
 115                 language_type = ret;
 116         }
 117
 118         if (src->last) {
 119                 ret = ctsvc_normalize_str(src->last, &dest[CTSVC_NN_LAST]);
 120                 RETVM_IF(ret < CONTACTS_ERROR_NONE, ret, "ctsvc_normalize_str() Fail(%d)", ret);
 121                 if (language_type < ret)
 122                         language_type = ret;
 123         }
 124         return language_type;
 125 }
 126
 127 int ctsvc_db_name_insert(contacts_record_h record, int contact_id, bool is_my_profile, int *id)
 128 {
 129         int ret, len = 0;
 130         cts_stmt stmt = NULL;
 131         ctsvc_name_s *name = (ctsvc_name_s*)record;
 132         char query[CTS_SQL_MAX_LEN] = {0};
 133         char *normal_name[CTSVC_NN_MAX] = {NULL}; /* insert name search info */
 134         char *temp_normal_first = NULL;
 135         char *temp_normal_last = NULL;
 136         int len_normal_first = 0;
 137         int len_normal_last = 0;
 138
 139         RETV_IF(NULL == name, CONTACTS_ERROR_INVALID_PARAMETER);
 140
 141         RETVM_IF(contact_id <= 0, CONTACTS_ERROR_INVALID_PARAMETER,
 142                         "contact_id(%d) is mandatory field to insert name record ", name->contact_id);
 143         RETVM_IF(0 < name->id, CONTACTS_ERROR_INVALID_PARAMETER,
 144                         "id(%d), This record is already inserted", name->id);
 145
 146         if (name->first || name->last || name->addition || name->prefix || name->suffix
 147                         || name->phonetic_first || name->phonetic_middle || name->phonetic_last) {
 148                 /*
 149                  * If name record already exists, delete current name record
 150                  * If user update record with out-of-date record, name record can be two
 151                  */
 152                 snprintf(query, sizeof(query),
 153                                 "DELETE FROM "CTS_TABLE_DATA" "
 154                                 "WHERE contact_id = %d AND datatype=%d "
 155                                 "AND is_my_profile = %d",
 156                                 contact_id, CONTACTS_DATA_TYPE_NAME, is_my_profile);
 157                 ret = ctsvc_query_exec(query);
 158                 if (CONTACTS_ERROR_NONE != ret) {
 159                         /* LCOV_EXCL_START */
 160                         ERR("ctsvc_query_exec() Faild(%d)", ret);
 161                         return ret;
 162                         /* LCOV_EXCL_STOP */
 163                 }
 164
 165                 snprintf(query, sizeof(query),
 166                                 "INSERT INTO "CTS_TABLE_DATA"(contact_id, is_my_profile, datatype, is_default, data1, data2, data3, "
 167                                 "data4, data5, data6, data7, data8, data9, data10, data11, data12) "
 168                                 "VALUES(%d, %d, %d, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
 169                                 contact_id, is_my_profile, CONTACTS_DATA_TYPE_NAME);
 170
 171                 ret = ctsvc_query_prepare(query, &stmt);
 172                 RETVM_IF(NULL == stmt, ret, "ctsvc_query_prepare() Fail(%d)", ret);
 173
 174                 ret = __ctsvc_normalize_name(name, normal_name);
 175                 WARN_IF(ret < CONTACTS_ERROR_NONE, "__ctsvc_normalize_name() Fail(%d)", ret);
 176
 177                 switch (ret) {
 178                 case CTSVC_LANG_KOREAN:
 179                         len_normal_first = SAFE_STRLEN(normal_name[CTSVC_NN_FIRST]);
 180                         len_normal_last = SAFE_STRLEN(normal_name[CTSVC_NN_LAST]);
 181                         temp_normal_first = calloc(1, len_normal_first + len_normal_last + 1);
 182                         if (temp_normal_first == NULL) {
 183                                 ERR("calloc() Fail");
 184                                 return CONTACTS_ERROR_OUT_OF_MEMORY;
 185                         }
 186                         if (normal_name[CTSVC_NN_LAST]) {
 187                                 len = snprintf(temp_normal_first, len_normal_first + len_normal_last + 1,
 188                                                 "%s", normal_name[CTSVC_NN_LAST]);
 189                         }
 190                         if (normal_name[CTSVC_NN_FIRST]) {
 191                                 snprintf(temp_normal_first+len, len_normal_first + len_normal_last + 1 - len,
 192                                                 "%s", normal_name[CTSVC_NN_FIRST]);
 193                         }
 194                         temp_normal_last = NULL;
 195                         break;
 196                 case CTSVC_LANG_ENGLISH:
 197                 default:
 198                         if (normal_name[CTSVC_NN_FIRST] && normal_name[CTSVC_NN_FIRST][0])
 199                                 temp_normal_first = SAFE_STRDUP(normal_name[CTSVC_NN_FIRST]);
 200
 201                         if (normal_name[CTSVC_NN_LAST] && normal_name[CTSVC_NN_LAST][0])
 202                                 temp_normal_last = SAFE_STRDUP(normal_name[CTSVC_NN_LAST]);
 203
 204                         break;
 205                 }
 206
 207
 208                 if (ctsvc_get_primary_sort() == ret)
 209                         name->language_type = CTSVC_LANG_DEFAULT;
 210                 else if (ctsvc_get_secondary_sort() == ret)
 211                         name->language_type = CTSVC_LANG_SECONDARY;
 212                 else
 213                         name->language_type = ret;
 214
 215
 216                 __ctsvc_make_name_lookup(CONTACTS_NAME_DISPLAY_ORDER_FIRSTLAST,
 217                                 temp_normal_first, temp_normal_last, &name->lookup);
 218
 219                 __ctsvc_make_name_lookup(CONTACTS_NAME_DISPLAY_ORDER_LASTFIRST,
 220                                 temp_normal_first, temp_normal_last, &name->reverse_lookup);
 221
 222                 free(temp_normal_first);
 223                 free(temp_normal_last);
 224                 free(normal_name[CTSVC_NN_FIRST]);
 225                 free(normal_name[CTSVC_NN_LAST]);
 226
 227                 __ctsvc_name_bind_stmt(stmt, name, 1);
 228
 229                 ret = ctsvc_stmt_step(stmt);
 230                 if (CONTACTS_ERROR_NONE != ret) {
 231                         /* LCOV_EXCL_START */
 232                         ERR("ctsvc_stmt_step() Fail(%d)", ret);
 233                         ctsvc_stmt_finalize(stmt);
 234                         return ret;
 235                         /* LCOV_EXCL_STOP */
 236                 }
 237
 238                 /* name->id = ctsvc_db_get_last_insert_id(); */
 239                 if (id)
 240                         *id = ctsvc_db_get_last_insert_id();
 241                 name->contact_id = contact_id;
 242                 ctsvc_stmt_finalize(stmt);
 243
 244                 if (false == is_my_profile)
 245                         ctsvc_set_name_noti();
 246         }
 247
 248         /* update search index table */
 249         return CONTACTS_ERROR_NONE;
 250 }
 251
 252
 253 int ctsvc_db_name_get_value_from_stmt(cts_stmt stmt, contacts_record_h *record, int start_count)
 254 {
 255         int ret;
 256         char *temp;
 257         ctsvc_name_s *name;
 258
 259         ret = contacts_record_create(_contacts_name._uri, (contacts_record_h*)&name);
 260         RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "contacts_record_create Fail(%d)", ret);
 261
 262         name->id = ctsvc_stmt_get_int(stmt, start_count++);
 263         name->contact_id = ctsvc_stmt_get_int(stmt, start_count++);
 264         name->is_default = ctsvc_stmt_get_int(stmt, start_count++);
 265         name->language_type = ctsvc_stmt_get_int(stmt, start_count++);
 266         temp = ctsvc_stmt_get_text(stmt, start_count++);
 267         name->first = SAFE_STRDUP(temp);
 268         temp = ctsvc_stmt_get_text(stmt, start_count++);
 269         name->last = SAFE_STRDUP(temp);
 270         temp = ctsvc_stmt_get_text(stmt, start_count++);
 271         name->addition = SAFE_STRDUP(temp);
 272         temp = ctsvc_stmt_get_text(stmt, start_count++);
 273         name->prefix = SAFE_STRDUP(temp);
 274         temp = ctsvc_stmt_get_text(stmt, start_count++);
 275         name->suffix = SAFE_STRDUP(temp);
 276         temp = ctsvc_stmt_get_text(stmt, start_count++);
 277         name->phonetic_first = SAFE_STRDUP(temp);
 278         temp = ctsvc_stmt_get_text(stmt, start_count++);
 279         name->phonetic_middle = SAFE_STRDUP(temp);
 280         temp = ctsvc_stmt_get_text(stmt, start_count++);
 281         name->phonetic_last = SAFE_STRDUP(temp);
 282         temp = ctsvc_stmt_get_text(stmt, start_count++);
 283         name->lookup = SAFE_STRDUP(temp);
 284         temp = ctsvc_stmt_get_text(stmt, start_count++);
 285         name->reverse_lookup = SAFE_STRDUP(temp);
 286
 287         *record = (contacts_record_h)name;
 288
 289         return CONTACTS_ERROR_NONE;
 290 }
 291
 292 int ctsvc_db_name_update(contacts_record_h record, bool is_my_profile)
 293 {
 294         int ret, len = 0;
 295         int id;
 296         char *set = NULL;
 297         GSList *cursor = NULL;
 298         GSList *bind_text = NULL;
 299         ctsvc_name_s *name = (ctsvc_name_s*)record;
 300         char *tmp_first, *tmp_last;
 301         char *normal_name[CTSVC_NN_MAX] = {NULL};
 302         char *temp_normal_first = NULL;
 303         char *temp_normal_last = NULL;
 304         char query[CTS_SQL_MIN_LEN] = {0};
 305
 306         RETVM_IF(0 == name->id, CONTACTS_ERROR_INVALID_PARAMETER, "name of contact has no ID.");
 307         RETVM_IF(CTSVC_PROPERTY_FLAG_DIRTY != (name->base.property_flag & CTSVC_PROPERTY_FLAG_DIRTY), CONTACTS_ERROR_NONE, "No update");
 308
 309         snprintf(query, sizeof(query),
 310                         "SELECT id FROM "CTS_TABLE_DATA" WHERE id = %d", name->id);
 311         ret = ctsvc_query_get_first_int_result(query, &id);
 312         RETV_IF(ret != CONTACTS_ERROR_NONE, ret);
 313
 314         tmp_first = name->first;
 315         tmp_last = name->last;
 316
 317         ret = __ctsvc_normalize_name(name, normal_name);
 318         if (ret < CONTACTS_ERROR_NONE) {
 319                 /* LCOV_EXCL_START */
 320                 ERR("cts_normalize_name() Fail(%d)", ret);
 321                 return ret;
 322                 /* LCOV_EXCL_STOP */
 323         }
 324
 325         switch (ret) {
 326         case CTSVC_LANG_KOREAN:
 327                 temp_normal_first = calloc(1, SAFE_STRLEN(normal_name[CTSVC_NN_LAST]) +  SAFE_STRLEN(normal_name[CTSVC_NN_LAST]) + 1);
 328                 if (temp_normal_first == NULL) {
 329                         ERR("calloc() Fail");
 330                         return CONTACTS_ERROR_OUT_OF_MEMORY;
 331                 }
 332                 if (normal_name[CTSVC_NN_LAST]) {
 333                         len = snprintf(temp_normal_first, SAFE_STRLEN(normal_name[CTSVC_NN_LAST]) +  SAFE_STRLEN(normal_name[CTSVC_NN_LAST]) + 1,
 334                                         "%s", normal_name[CTSVC_NN_LAST]);
 335                 }
 336                 if (normal_name[CTSVC_NN_FIRST]) {
 337                         snprintf(temp_normal_first+len, SAFE_STRLEN(normal_name[CTSVC_NN_LAST]) +  SAFE_STRLEN(normal_name[CTSVC_NN_LAST]) + 1 - len,
 338                                         "%s", normal_name[CTSVC_NN_FIRST]);
 339                 }
 340                 temp_normal_last = NULL;
 341                 break;
 342         case CTSVC_LANG_ENGLISH:
 343         default:
 344                 if (normal_name[CTSVC_NN_FIRST] && normal_name[CTSVC_NN_FIRST][0])
 345                         temp_normal_first = SAFE_STRDUP(normal_name[CTSVC_NN_FIRST]);
 346                 else
 347                         name->first = NULL;
 348
 349                 if (normal_name[CTSVC_NN_LAST] && normal_name[CTSVC_NN_LAST][0])
 350                         temp_normal_last = SAFE_STRDUP(normal_name[CTSVC_NN_LAST]);
 351                 else
 352                         name->last = NULL;
 353                 break;
 354         }
 355
 356         if (ctsvc_get_primary_sort() == ret)
 357                 name->language_type = CTSVC_LANG_DEFAULT;
 358         else if (ctsvc_get_secondary_sort() == ret)
 359                 name->language_type = CTSVC_LANG_SECONDARY;
 360         else
 361                 name->language_type = ret;
 362
 363         name->first = tmp_first;
 364         name->last = tmp_last;
 365
 366         __ctsvc_make_name_lookup(CONTACTS_NAME_DISPLAY_ORDER_FIRSTLAST,
 367                         temp_normal_first, temp_normal_last, &name->lookup);
 368
 369         __ctsvc_make_name_lookup(CONTACTS_NAME_DISPLAY_ORDER_LASTFIRST,
 370                         temp_normal_first, temp_normal_last, &name->reverse_lookup);
 371
 372         free(temp_normal_first);
 373         free(temp_normal_last);
 374         free(normal_name[CTSVC_NN_FIRST]);
 375         free(normal_name[CTSVC_NN_LAST]);
 376
 377         do {
 378                 char query_set[CTS_SQL_MAX_LEN] = {0};
 379                 if (CONTACTS_ERROR_NONE != (ret = ctsvc_db_create_set_query(record, &set, &bind_text))) break;
 380                 snprintf(query_set, sizeof(query_set), "%s, is_default=%d, data1=%d, data11=?, data12=?",
 381                                 set, name->is_default, name->language_type);
 382                 bind_text = g_slist_append(bind_text, strdup(SAFE_STR(name->lookup)));
 383                 bind_text = g_slist_append(bind_text, strdup(SAFE_STR(name->reverse_lookup)));
 384                 if (CONTACTS_ERROR_NONE != (ret = ctsvc_db_update_record_with_set_query(query_set, bind_text, CTS_TABLE_DATA, name->id))) break;
 385
 386                 if (false == is_my_profile)
 387                         ctsvc_set_name_noti();
 388         } while (0);
 389
 390         CTSVC_RECORD_RESET_PROPERTY_FLAGS((ctsvc_record_s*)record);
 391         free(set);
 392
 393         if (bind_text) {
 394                 for (cursor = bind_text; cursor; cursor = cursor->next) {
 395                         free(cursor->data);
 396                         cursor->data = NULL;
 397                 }
 398                 g_slist_free(bind_text);
 399         }
 400
 401         return CONTACTS_ERROR_NONE;
 402 }
 403
 404 int ctsvc_db_name_delete(int id, bool is_my_profile)
 405 {
 406         int ret;
 407         char query[CTS_SQL_MIN_LEN] = {0};
 408
 409         snprintf(query, sizeof(query), "DELETE FROM "CTS_TABLE_DATA" WHERE id = %d", id);
 410
 411         ret = ctsvc_query_exec(query);
 412         RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "ctsvc_query_exec() Fail(%d)", ret);
 413
 414         if (false == is_my_profile)
 415                 ctsvc_set_name_noti();
 416
 417         return CONTACTS_ERROR_NONE;
 418 }
 419