server/db/ctsvc_db_plugin_email.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_db_utils.h"
  24 #include "ctsvc_db_init.h"
  25 #include "ctsvc_db_access_control.h"
  26 #include "ctsvc_db_plugin_contact_helper.h"
  27 #include "ctsvc_db_plugin_email_helper.h"
  28 #include "ctsvc_record.h"
  29 #include "ctsvc_notification.h"
  30 #include "ctsvc_db_query.h"
  31 #include "ctsvc_list.h"
  32
  33
  34 static int __ctsvc_db_email_get_person_default_email(int person_id)
  35 {
  36         int ret;
  37         int default_email_id;
  38         char query[CTS_SQL_MAX_LEN] = {0};
  39
  40         snprintf(query, sizeof(query),
  41                         "SELECT id FROM "CTSVC_DB_VIEW_CONTACT" c, "CTS_TABLE_DATA" d "
  42                         "WHERE c.person_id = %d AND d.datatype = %d AND c.contact_id = d.contact_id AND d.is_default = 1",
  43                         person_id, CONTACTS_DATA_TYPE_EMAIL);
  44         ret = ctsvc_query_get_first_int_result(query, &default_email_id);
  45         if (CONTACTS_ERROR_NONE != ret)
  46                 return 0;
  47         return default_email_id;
  48 }
  49
  50 static int __ctsvc_db_email_update_person_has_email(int person_id, bool has_email)
  51 {
  52         int ret;
  53         char query[CTS_SQL_MAX_LEN] = {0};
  54
  55         snprintf(query, sizeof(query),
  56                         "UPDATE "CTS_TABLE_PERSONS" SET has_email = %d WHERE person_id = %d",
  57                         has_email, person_id);
  58
  59         ret = ctsvc_query_exec(query);
  60         WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_query_exec() Fail(%d)", ret);
  61         return ret;
  62 }
  63
  64 static int __ctsvc_db_email_update_default(int email_id, int contact_id, bool is_default, bool is_primary_default)
  65 {
  66         int ret;
  67         char query[CTS_SQL_MAX_LEN] = {0};
  68
  69         snprintf(query, sizeof(query),
  70                         "UPDATE "CTS_TABLE_DATA" SET is_default = %d, is_primary_default = %d WHERE id = %d",
  71                         is_default, is_primary_default, email_id);
  72         ret = ctsvc_query_exec(query);
  73
  74         WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_query_exec() Fail(%d)", ret);
  75         return ret;
  76 }
  77
  78 static int __ctsvc_db_email_get_default_email_id(int contact_id)
  79 {
  80         int ret;
  81         int email_id = 0;
  82         char query[CTS_SQL_MAX_LEN] = {0};
  83         snprintf(query, sizeof(query),
  84                         "SELECT id FROM "CTS_TABLE_DATA" WHERE datatype=%d AND contact_id=%d AND is_default=1",
  85                         CONTACTS_DATA_TYPE_EMAIL, contact_id);
  86         ret = ctsvc_query_get_first_int_result(query, &email_id);
  87         if (CONTACTS_ERROR_NONE != ret)
  88                 return 0;
  89         return email_id;
  90 }
  91
  92 static int __ctsvc_db_email_get_primary_default_email_id(int contact_id)
  93 {
  94         int ret;
  95         int email_id = 0;
  96         char query[CTS_SQL_MAX_LEN] = {0};
  97         snprintf(query, sizeof(query),
  98                         "SELECT id FROM "CTS_TABLE_DATA" WHERE datatype=%d AND contact_id=%d AND is_primary_default=1",
  99                         CONTACTS_DATA_TYPE_EMAIL, contact_id);
 100         ret = ctsvc_query_get_first_int_result(query, &email_id);
 101         if (CONTACTS_ERROR_NONE != ret)
 102                 return 0;
 103         return email_id;
 104 }
 105
 106 static int __ctsvc_db_email_get_primary_default_contact_id(int person_id)
 107 {
 108         int ret;
 109         int default_contact_id;
 110         char query[CTS_SQL_MAX_LEN] = {0};
 111
 112         snprintf(query, sizeof(query),
 113                         "SELECT c.contact_id FROM "CTS_TABLE_CONTACTS" c, "CTS_TABLE_DATA" d "
 114                         "WHERE c.person_id = %d AND d.datatype = %d AND c.contact_id = d.contact_id AND d.is_primary_default = 1",
 115                         person_id, CONTACTS_DATA_TYPE_EMAIL);
 116         ret = ctsvc_query_get_first_int_result(query, &default_contact_id);
 117         if (CONTACTS_ERROR_NONE != ret)
 118                 return 0;
 119         return default_contact_id;
 120 }
 121
 122 static int __ctsvc_db_email_set_primary_default(int email_id, bool is_primary_default)
 123 {
 124         int ret;
 125         char query[CTS_SQL_MAX_LEN] = {0};
 126
 127         snprintf(query, sizeof(query),
 128                         "UPDATE "CTS_TABLE_DATA" SET is_primary_default = %d WHERE id = %d",
 129                         is_primary_default, email_id);
 130         ret = ctsvc_query_exec(query);
 131         WARN_IF(CONTACTS_ERROR_NONE != ret, "ctsvc_query_exec() Fail(%d)", ret);
 132         return ret;
 133 }
 134
 135 static int __ctsvc_db_email_insert_record(contacts_record_h record, int *id)
 136 {
 137         int ret;
 138         int addressbook_id = 0;
 139         int person_id = 0;
 140         int old_default_email_id = 0;
 141         char query[CTS_SQL_MAX_LEN] = {0};
 142         cts_stmt stmt = NULL;
 143         ctsvc_email_s *email = (ctsvc_email_s*)record;
 144         RETV_IF(NULL == email->email_addr, CONTACTS_ERROR_INVALID_PARAMETER);
 145
 146         ret = ctsvc_begin_trans();
 147         if (CONTACTS_ERROR_NONE != ret) {
 148                 ERR("ctsvc_begin_trans() Fail(%d)", ret);
 149                 return ret;
 150         }
 151
 152         snprintf(query, sizeof(query),
 153                         "SELECT addressbook_id, person_id FROM "CTSVC_DB_VIEW_CONTACT" WHERE contact_id = %d", email->contact_id);
 154         ret = ctsvc_query_prepare(query, &stmt);
 155         if (NULL == stmt) {
 156                 ERR("ctsvc_query_prepare() Fail(%d)", ret);
 157                 ctsvc_end_trans(false);
 158                 return ret;
 159         }
 160
 161         ret = ctsvc_stmt_step(stmt);
 162         if (1 != ret) {
 163                 ERR("ctsvc_stmt_step() Fail(%d)", ret);
 164                 ctsvc_stmt_finalize(stmt);
 165                 ctsvc_end_trans(false);
 166                 if (CONTACTS_ERROR_NONE == ret)
 167                         return CONTACTS_ERROR_INVALID_PARAMETER;
 168                 else
 169                         return ret;
 170         }
 171         addressbook_id = ctsvc_stmt_get_int(stmt, 0);
 172         person_id = ctsvc_stmt_get_int(stmt, 1);
 173         ctsvc_stmt_finalize(stmt);
 174
 175         if (false == ctsvc_have_ab_write_permission(addressbook_id, false)) {
 176                 ERR("No permission in this addresbook_id(%d)", addressbook_id);
 177                 ctsvc_end_trans(false);
 178                 return CONTACTS_ERROR_PERMISSION_DENIED;
 179         }
 180
 181         old_default_email_id = __ctsvc_db_email_get_default_email_id(email->contact_id);
 182         if (0 == old_default_email_id)
 183                 email->is_default = true;
 184
 185         ret = ctsvc_db_email_insert(record, email->contact_id, false, id);
 186         if (CONTACTS_ERROR_NONE != ret) {
 187                 ERR("ctsvc_begin_trans() Fail(%d)", ret);
 188                 ctsvc_end_trans(false);
 189                 return ret;
 190         }
 191
 192         snprintf(query, sizeof(query),
 193                         "UPDATE "CTS_TABLE_CONTACTS" SET has_email = %d, changed_ver = %d, changed_time = %d "
 194                         "WHERE contact_id = %d",
 195                         1, ctsvc_get_next_ver(), (int)time(NULL), email->contact_id);
 196
 197         ret = ctsvc_query_exec(query);
 198         if (CONTACTS_ERROR_NONE != ret) {
 199                 ERR("ctsvc_query_exec() Fail(%d)", ret);
 200                 ctsvc_end_trans(false);
 201                 return ret;
 202         }
 203
 204         if (email->is_default) {
 205                 int primary_default_contact_id = 0;
 206
 207                 __ctsvc_db_email_update_person_has_email(person_id, true);
 208
 209                 primary_default_contact_id = __ctsvc_db_email_get_primary_default_contact_id(person_id);
 210                 if (0 == primary_default_contact_id || email->contact_id == primary_default_contact_id)
 211                         __ctsvc_db_email_set_primary_default(*id, true);
 212
 213                 ctsvc_contact_update_display_name(email->contact_id, CONTACTS_DISPLAY_NAME_SOURCE_TYPE_EMAIL);
 214         }
 215
 216         ctsvc_set_contact_noti();
 217         ctsvc_set_person_noti();
 218
 219         ret = ctsvc_end_trans(true);
 220         if (ret < CONTACTS_ERROR_NONE) {
 221                 ERR("ctsvc_end_trans() Fail(%d)", ret);
 222                 return ret;
 223         } else {
 224                 return CONTACTS_ERROR_NONE;
 225         }
 226 }
 227
 228 static int __ctsvc_db_email_get_record(int id, contacts_record_h *out_record)
 229 {
 230         int ret;
 231         cts_stmt stmt = NULL;
 232         char query[CTS_SQL_MAX_LEN] = {0};
 233
 234         RETV_IF(NULL == out_record, CONTACTS_ERROR_INVALID_PARAMETER);
 235         *out_record = NULL;
 236
 237         snprintf(query, sizeof(query),
 238                         "SELECT id, data.contact_id, is_default, data1, data2, data3 "
 239                         "FROM "CTS_TABLE_DATA", "CTSVC_DB_VIEW_CONTACT" "
 240                         "ON "CTS_TABLE_DATA".contact_id = "CTSVC_DB_VIEW_CONTACT".contact_id "
 241                         "WHERE id = %d AND datatype = %d ",
 242                         id, CONTACTS_DATA_TYPE_EMAIL);
 243
 244         ret = ctsvc_query_prepare(query, &stmt);
 245         RETVM_IF(NULL == stmt, ret, "ctsvc_query_prepare() Fail(%d)", ret);
 246
 247         ret = ctsvc_stmt_step(stmt);
 248         if (1 /*CTS_TRUE*/ != ret) {
 249                 ERR("ctsvc_stmt_step() Fail(%d)", ret);
 250                 ctsvc_stmt_finalize(stmt);
 251                 if (CONTACTS_ERROR_NONE == ret)
 252                         return CONTACTS_ERROR_NO_DATA;
 253                 else
 254                         return ret;
 255         }
 256
 257         ctsvc_db_email_get_value_from_stmt(stmt, out_record, 0);
 258
 259         ctsvc_stmt_finalize(stmt);
 260
 261         return CONTACTS_ERROR_NONE;
 262 }
 263
 264 static int __ctsvc_db_email_update_record(contacts_record_h record)
 265 {
 266         int ret;
 267         int addressbook_id;
 268         char query[CTS_SQL_MAX_LEN] = {0};
 269         ctsvc_email_s *email = (ctsvc_email_s*)record;
 270         RETVM_IF(NULL == email->email_addr, CONTACTS_ERROR_INVALID_PARAMETER, "email is empty");
 271
 272         ret = ctsvc_begin_trans();
 273         if (CONTACTS_ERROR_NONE != ret) {
 274                 ERR("ctsvc_begin_trans() Fail(%d)", ret);
 275                 return ret;
 276         }
 277
 278         snprintf(query, sizeof(query),
 279                         "SELECT addressbook_id FROM "CTSVC_DB_VIEW_CONTACT" WHERE contact_id = %d", email->contact_id);
 280         ret = ctsvc_query_get_first_int_result(query, &addressbook_id);
 281         if (CONTACTS_ERROR_NONE != ret) {
 282                 ERR("No data : contact_id (%d) is not exist", email->contact_id);
 283                 ctsvc_end_trans(false);
 284                 return ret;
 285         }
 286
 287         if (false == ctsvc_have_ab_write_permission(addressbook_id, false)) {
 288                 ERR("No permission in this addresbook_id(%d)", addressbook_id);
 289                 ctsvc_end_trans(false);
 290                 return CONTACTS_ERROR_PERMISSION_DENIED;
 291         }
 292
 293         ret = ctsvc_db_email_update(record, false);
 294         if (CONTACTS_ERROR_NONE != ret) {
 295                 ERR("update record Fail(%d)", ret);
 296                 ctsvc_end_trans(false);
 297                 return ret;
 298         }
 299
 300         if (email->is_default) {
 301                 int old_primary_default_email_id = 0;
 302                 old_primary_default_email_id = __ctsvc_db_email_get_primary_default_email_id(email->contact_id);
 303                 if (old_primary_default_email_id)
 304                         __ctsvc_db_email_set_primary_default(email->id, true);
 305         }
 306         ctsvc_contact_update_display_name(email->contact_id, CONTACTS_DISPLAY_NAME_SOURCE_TYPE_EMAIL);
 307
 308         ret = ctsvc_db_contact_update_changed_time(email->contact_id);
 309         if (CONTACTS_ERROR_NONE != ret) {
 310                 ERR("ctsvc_db_contact_update_changed_time() Fail(%d)", ret);
 311                 ctsvc_end_trans(false);
 312                 return ret;
 313         }
 314         ctsvc_set_person_noti();
 315
 316         ret = ctsvc_end_trans(true);
 317         if (ret < CONTACTS_ERROR_NONE) {
 318                 ERR("ctsvc_end_trans() Fail(%d)", ret);
 319                 return ret;
 320         } else {
 321                 return CONTACTS_ERROR_NONE;
 322         }
 323 }
 324
 325 static int __ctsvc_db_email_delete_record(int id)
 326 {
 327         int ret;
 328         int email_id;
 329         int contact_id;
 330         int person_id;
 331         int is_default;
 332         int is_primary_default;
 333         char query[CTS_SQL_MAX_LEN] = {0};
 334         bool has_email = false;
 335         cts_stmt stmt = NULL;
 336         int addressbook_id;
 337
 338         ret = ctsvc_begin_trans();
 339         if (CONTACTS_ERROR_NONE != ret) {
 340                 ERR("ctsvc_begin_trans() Fail(%d)", ret);
 341                 return ret;
 342         }
 343
 344         snprintf(query, sizeof(query),
 345                         "SELECT contact_id, person_id, addressbook_id FROM "CTSVC_DB_VIEW_CONTACT " "
 346                         "WHERE contact_id = (SELECT contact_id FROM "CTS_TABLE_DATA" WHERE id = %d)", id);
 347
 348         ret = ctsvc_query_prepare(query, &stmt);
 349         if (NULL == stmt) {
 350                 ERR("ctsvc_query_prepare() Fail(%d)", ret);
 351                 ctsvc_end_trans(false);
 352                 return ret;
 353         }
 354
 355         ret = ctsvc_stmt_step(stmt);
 356         if (1 != ret) {
 357                 ERR("ctsvc_stmt_step() Fail(%d)", ret);
 358                 ctsvc_stmt_finalize(stmt);
 359                 ctsvc_end_trans(false);
 360                 if (CONTACTS_ERROR_NONE == ret)
 361                         return CONTACTS_ERROR_NO_DATA;
 362                 else
 363                         return ret;
 364         }
 365         contact_id = ctsvc_stmt_get_int(stmt, 0);
 366         person_id = ctsvc_stmt_get_int(stmt, 1);
 367         addressbook_id = ctsvc_stmt_get_int(stmt, 2);
 368         ctsvc_stmt_finalize(stmt);
 369
 370         if (false == ctsvc_have_ab_write_permission(addressbook_id, false)) {
 371                 ERR("No permission in this addresbook_id(%d)", addressbook_id);
 372                 ctsvc_end_trans(false);
 373                 return CONTACTS_ERROR_PERMISSION_DENIED;
 374         }
 375
 376         snprintf(query, sizeof(query),
 377                         "SELECT is_default, is_primary_default FROM "CTS_TABLE_DATA" WHERE id = %d", id);
 378
 379         ret = ctsvc_query_prepare(query, &stmt);
 380         RETVM_IF(NULL == stmt, ret, "ctsvc_query_prepare() Fail(%d)", ret);
 381
 382         ret = ctsvc_stmt_step(stmt);
 383         if (1 != ret) {
 384                 ERR("ctsvc_stmt_step() Fail(%d)", ret);
 385                 ctsvc_stmt_finalize(stmt);
 386                 ctsvc_end_trans(false);
 387                 if (CONTACTS_ERROR_NONE == ret)
 388                         return CONTACTS_ERROR_NO_DATA;
 389                 else
 390                         return ret;
 391         }
 392         is_default = ctsvc_stmt_get_int(stmt, 0);
 393         is_primary_default = ctsvc_stmt_get_int(stmt, 1);
 394         ctsvc_stmt_finalize(stmt);
 395
 396         ret = ctsvc_db_email_delete(id, false);
 397         if (CONTACTS_ERROR_NONE != ret) {
 398                 ERR("ctsvc_begin_trans() Fail(%d)", ret);
 399                 ctsvc_end_trans(false);
 400                 return ret;
 401         }
 402
 403         snprintf(query, sizeof(query),
 404                         "SELECT id FROM "CTS_TABLE_DATA" WHERE datatype = %d AND contact_id = %d AND is_my_profile = 0 limit 1",
 405                         CONTACTS_DATA_TYPE_EMAIL, contact_id);
 406         ret = ctsvc_query_get_first_int_result(query, &email_id);
 407         if (0 < ret)
 408                 has_email = true;
 409
 410         snprintf(query, sizeof(query),
 411                         "UPDATE "CTS_TABLE_CONTACTS" SET has_email = %d, changed_ver = %d, changed_time = %d "
 412                         "WHERE contact_id = %d",
 413                         has_email, ctsvc_get_next_ver(), (int)time(NULL), contact_id);
 414
 415         ret = ctsvc_query_exec(query);
 416         if (CONTACTS_ERROR_NONE != ret) {
 417                 ERR("ctsvc_query_exec() Fail(%d)", ret);
 418                 ctsvc_end_trans(false);
 419                 return ret;
 420         }
 421
 422         if (is_default) {
 423
 424                 if (email_id) {
 425                         __ctsvc_db_email_update_default(email_id, contact_id, is_default, is_primary_default);
 426                 } else if (is_primary_default) {
 427                         int default_email_id = 0;
 428                         default_email_id = __ctsvc_db_email_get_person_default_email(person_id);
 429                         if (default_email_id)
 430                                 __ctsvc_db_email_set_primary_default(default_email_id, true);
 431                         else
 432                                 __ctsvc_db_email_update_person_has_email(person_id, false);
 433                 }
 434                 ctsvc_contact_update_display_name(contact_id, CONTACTS_DISPLAY_NAME_SOURCE_TYPE_EMAIL);
 435         }
 436
 437         ctsvc_set_contact_noti();
 438         ctsvc_set_person_noti();
 439
 440         ret = ctsvc_end_trans(true);
 441         RETVM_IF(ret < CONTACTS_ERROR_NONE, ret, "ctsvc_end_trans() Fail(%d)", ret);
 442         return CONTACTS_ERROR_NONE;
 443 }
 444
 445 static int __ctsvc_db_email_get_all_records(int offset, int limit, contacts_list_h *out_list)
 446 {
 447         int len;
 448         int ret;
 449         contacts_list_h list;
 450         ctsvc_email_s *email;
 451         cts_stmt stmt = NULL;
 452         char query[CTS_SQL_MAX_LEN] = {0};
 453
 454         len = snprintf(query, sizeof(query),
 455                         "SELECT id, data.contact_id, is_default, data1, data2, data3 "
 456                         "FROM "CTS_TABLE_DATA", "CTSVC_DB_VIEW_CONTACT" "
 457                         "ON "CTS_TABLE_DATA".contact_id = "CTSVC_DB_VIEW_CONTACT".contact_id "
 458                         "WHERE datatype = %d AND is_my_profile=0 ",
 459                         CONTACTS_DATA_TYPE_EMAIL);
 460
 461         if (0 != limit) {
 462                 len += snprintf(query+len, sizeof(query)-len, " LIMIT %d", limit);
 463                 if (0 < offset)
 464                         len += snprintf(query+len, sizeof(query)-len, " OFFSET %d", offset);
 465         }
 466
 467         ret = ctsvc_query_prepare(query, &stmt);
 468         RETVM_IF(NULL == stmt, ret, "ctsvc_query_prepare() Fail(%d)", ret);
 469
 470         contacts_list_create(&list);
 471         while ((ret = ctsvc_stmt_step(stmt))) {
 472                 if (1 /*CTS_TRUE */ != ret) {
 473                         ERR("DB : ctsvc_stmt_step() Fail(%d)", ret);
 474                         ctsvc_stmt_finalize(stmt);
 475                         contacts_list_destroy(list, true);
 476                         return ret;
 477                 }
 478                 ctsvc_db_email_get_value_from_stmt(stmt, (contacts_record_h*)&email, 0);
 479                 ctsvc_list_prepend(list, (contacts_record_h)email);
 480         }
 481         ctsvc_stmt_finalize(stmt);
 482         ctsvc_list_reverse(list);
 483
 484         *out_list = list;
 485         return CONTACTS_ERROR_NONE;
 486 }
 487
 488 static int __ctsvc_db_email_get_records_with_query(contacts_query_h query, int offset,
 489                 int limit, contacts_list_h *out_list)
 490 {
 491         int ret;
 492         int i;
 493         int field_count;
 494         ctsvc_query_s *s_query;
 495         cts_stmt stmt;
 496         contacts_list_h list;
 497         ctsvc_email_s *email;
 498
 499         RETV_IF(NULL == query, CONTACTS_ERROR_INVALID_PARAMETER);
 500         s_query = (ctsvc_query_s*)query;
 501
 502         ret = ctsvc_db_make_get_records_query_stmt(s_query, offset, limit, &stmt);
 503         RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "ctsvc_db_make_get_records_query_stmt fail(%d)", ret);
 504
 505         contacts_list_create(&list);
 506         while ((ret = ctsvc_stmt_step(stmt))) {
 507                 contacts_record_h record;
 508                 if (1 /*CTS_TRUE */ != ret) {
 509                         ERR("ctsvc_stmt_step() Fail(%d)", ret);
 510                         ctsvc_stmt_finalize(stmt);
 511                         contacts_list_destroy(list, true);
 512                         return ret;
 513                 }
 514
 515                 contacts_record_create(_contacts_email._uri, &record);
 516                 email = (ctsvc_email_s*)record;
 517                 if (0 == s_query->projection_count) {
 518                         field_count = s_query->property_count;
 519                 } else {
 520                         field_count = s_query->projection_count;
 521                         ret = ctsvc_record_set_projection_flags(record, s_query->projection,
 522                                         s_query->projection_count, s_query->property_count);
 523
 524                         if (CONTACTS_ERROR_NONE != ret)
 525                                 ASSERT_NOT_REACHED("To set projection is Fail.\n");
 526                 }
 527
 528                 for (i = 0; i < field_count; i++) {
 529                         char *temp;
 530                         int property_id;
 531                         if (0 == s_query->projection_count)
 532                                 property_id = s_query->properties[i].property_id;
 533                         else
 534                                 property_id = s_query->projection[i];
 535
 536                         switch (property_id) {
 537                         case CTSVC_PROPERTY_EMAIL_ID:
 538                                 email->id = ctsvc_stmt_get_int(stmt, i);
 539                                 break;
 540                         case CTSVC_PROPERTY_EMAIL_CONTACT_ID:
 541                                 email->contact_id = ctsvc_stmt_get_int(stmt, i);
 542                                 break;
 543                         case CTSVC_PROPERTY_EMAIL_TYPE:
 544                                 email->type = ctsvc_stmt_get_int(stmt, i);
 545                                 break;
 546                         case CTSVC_PROPERTY_EMAIL_LABEL:
 547                                 temp = ctsvc_stmt_get_text(stmt, i);
 548                                 free(email->label);
 549                                 email->label = SAFE_STRDUP(temp);
 550                                 break;
 551                         case CTSVC_PROPERTY_EMAIL_EMAIL:
 552                                 temp = ctsvc_stmt_get_text(stmt, i);
 553                                 free(email->email_addr);
 554                                 email->email_addr = SAFE_STRDUP(temp);
 555                                 break;
 556                         case CTSVC_PROPERTY_EMAIL_IS_DEFAULT:
 557                                 email->is_default = ctsvc_stmt_get_int(stmt, i);
 558                                 break;
 559                         default:
 560                                 break;
 561                         }
 562                 }
 563                 ctsvc_list_prepend(list, record);
 564         }
 565         ctsvc_stmt_finalize(stmt);
 566         ctsvc_list_reverse(list);
 567
 568         *out_list = list;
 569         return CONTACTS_ERROR_NONE;
 570 }
 571
 572 ctsvc_db_plugin_info_s ctsvc_db_plugin_email = {
 573         .is_query_only = false,
 574         .insert_record = __ctsvc_db_email_insert_record,
 575         .get_record = __ctsvc_db_email_get_record,
 576         .update_record = __ctsvc_db_email_update_record,
 577         .delete_record = __ctsvc_db_email_delete_record,
 578         .get_all_records = __ctsvc_db_email_get_all_records,
 579         .get_records_with_query = __ctsvc_db_email_get_records_with_query,
 580         .insert_records = NULL,
 581         .update_records = NULL,
 582         .delete_records = NULL,
 583         .get_count = NULL,
 584         .get_count_with_query = NULL,
 585         .replace_record = NULL,
 586         .replace_records = NULL,
 587 };
 588