server/db/ctsvc_db_plugin_group.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 <unistd.h>
  20
  21 #include "contacts.h"
  22 #include "ctsvc_internal.h"
  23 #include "ctsvc_db_schema.h"
  24 #include "ctsvc_db_sqlite.h"
  25 #include "ctsvc_db_utils.h"
  26 #include "ctsvc_list.h"
  27 #include "ctsvc_db_query.h"
  28 #include "ctsvc_db_init.h"
  29 #include "ctsvc_record.h"
  30 #include "ctsvc_notification.h"
  31 #include "ctsvc_db_access_control.h"
  32 #include "ctsvc_db_plugin_group_helper.h"
  33 #include "ctsvc_notify.h"
  34
  35
  36 static double __ctsvc_db_group_get_next_group_prio(void)
  37 {
  38         int ret;
  39         double prio = 0.0;
  40         cts_stmt stmt;
  41         char query[CTS_SQL_MAX_LEN] = {0};
  42
  43         snprintf(query, sizeof(query), "SELECT MAX(group_prio) FROM "CTS_TABLE_GROUPS" ");
  44
  45         ret = ctsvc_query_prepare(query, &stmt);
  46         RETVM_IF(NULL == stmt, ret, "ctsvc_query_prepare() Fail(%d)", ret);
  47
  48         ret = ctsvc_stmt_step(stmt);
  49         if (1 /*CTS_TRUE*/  == ret)
  50                 prio = ctsvc_stmt_get_dbl(stmt, 0);
  51         ctsvc_stmt_finalize(stmt);
  52
  53         return prio + 1.0;
  54 }
  55
  56 static int __ctsvc_db_group_insert_record(contacts_record_h record, int *id)
  57 {
  58         int ret;
  59         int ver;
  60         cts_stmt stmt;
  61         double group_prio = 0.0;
  62         ctsvc_group_s *group = (ctsvc_group_s*)record;
  63         char query[CTS_SQL_MAX_LEN] = {0};
  64
  65         RETV_IF(NULL == record, CONTACTS_ERROR_INVALID_PARAMETER);
  66         RETVM_IF(CTSVC_RECORD_GROUP != group->base.r_type, CONTACTS_ERROR_INVALID_PARAMETER,
  67                         "record is invalid type(%d)", group->base.r_type);
  68         RETVM_IF(NULL == group->name, CONTACTS_ERROR_INVALID_PARAMETER,
  69                         "The name of record is empty.");
  70
  71         ret = ctsvc_begin_trans();
  72         RETVM_IF(ret < CONTACTS_ERROR_NONE, ret,  "ctsvc_begin_trans() Fail(%d)", ret);
  73
  74         if (false == ctsvc_have_ab_write_permission(group->addressbook_id, true)) {
  75                 /* LCOV_EXCL_START */
  76                 ERR("No permission in this addresbook_id(%d)", group->addressbook_id);
  77                 ctsvc_end_trans(false);
  78                 return CONTACTS_ERROR_PERMISSION_DENIED;
  79                 /* LCOV_EXCL_STOP */
  80         }
  81
  82         group_prio = __ctsvc_db_group_get_next_group_prio();
  83         group->id = ctsvc_db_get_next_id(CTS_TABLE_GROUPS);
  84         if (id)
  85                 *id = group->id;
  86
  87         snprintf(query, sizeof(query),
  88                         "INSERT INTO "CTS_TABLE_GROUPS"(group_id, addressbook_id, group_name, created_ver, changed_ver, ringtone_path, "
  89                         "vibration, message_alert, image_thumbnail_path, extra_data, is_read_only, group_prio) "
  90                         "VALUES(%d, %d, ?, ?, ?, ?, ?, ?, ?, ?, %d, %lf)",
  91                         group->id, group->addressbook_id, group->is_read_only, group_prio);
  92
  93         ret = ctsvc_query_prepare(query, &stmt);
  94         if (NULL == stmt) {
  95                 /* LCOV_EXCL_START */
  96                 ERR("ctsvc_query_prepare() Fail(%d)", ret);
  97                 ctsvc_end_trans(false);
  98                 return ret;
  99                 /* LCOV_EXCL_STOP */
 100         }
 101
 102         ctsvc_stmt_bind_text(stmt, 1, group->name);
 103
 104         ver = ctsvc_get_next_ver();
 105
 106         ctsvc_stmt_bind_int(stmt, 2, ver);
 107         ctsvc_stmt_bind_int(stmt, 3, ver);
 108
 109         if (group->ringtone_path)
 110                 ctsvc_stmt_bind_text(stmt, 4, group->ringtone_path);
 111         if (group->vibration)
 112                 ctsvc_stmt_bind_text(stmt, 5, group->vibration);
 113         if (group->message_alert)
 114                 ctsvc_stmt_bind_text(stmt, 6, group->message_alert);
 115
 116         if (group->image_thumbnail_path) {
 117                 char image[CTSVC_IMG_FULL_PATH_SIZE_MAX] = {0};
 118                 ret = ctsvc_have_file_read_permission(group->image_thumbnail_path);
 119                 if (ret != CONTACTS_ERROR_NONE) {
 120                         /* LCOV_EXCL_START */
 121                         ERR("ctsvc_have_file_read_permission Fail(%d)", ret);
 122                         ctsvc_stmt_finalize(stmt);
 123                         ctsvc_end_trans(false);
 124                         return ret;
 125                         /* LCOV_EXCL_STOP */
 126                 }
 127
 128                 ctsvc_utils_make_image_file_name(0, group->id, group->image_thumbnail_path, image, sizeof(image));
 129                 ret = ctsvc_utils_copy_image(CTS_GROUP_IMAGE_LOCATION, group->image_thumbnail_path, image);
 130                 if (CONTACTS_ERROR_NONE != ret) {
 131                         /* LCOV_EXCL_START */
 132                         ERR("ctsvc_utils_copy_image() Fail(%d)", ret);
 133                         ctsvc_stmt_finalize(stmt);
 134                         ctsvc_end_trans(false);
 135                         return ret;
 136                         /* LCOV_EXCL_STOP */
 137                 }
 138
 139                 free(group->image_thumbnail_path);
 140                 group->image_thumbnail_path = strdup(image);
 141                 if (group->image_thumbnail_path)
 142                         ctsvc_stmt_bind_text(stmt, 7, group->image_thumbnail_path);
 143         }
 144
 145         if (group->extra_data)
 146                 ctsvc_stmt_bind_text(stmt, 8, group->extra_data);
 147
 148         ret = ctsvc_stmt_step(stmt);
 149         if (CONTACTS_ERROR_NONE != ret) {
 150                 /* LCOV_EXCL_START */
 151                 ERR("ctsvc_stmt_step() Fail(%d)", ret);
 152                 ctsvc_stmt_finalize(stmt);
 153                 ctsvc_end_trans(false);
 154                 return ret;
 155                 /* LCOV_EXCL_STOP */
 156         }
 157
 158         ctsvc_set_group_noti();
 159
 160         ctsvc_stmt_finalize(stmt);
 161
 162         ret = ctsvc_end_trans(true);
 163         if (ret < CONTACTS_ERROR_NONE) {
 164                 /* LCOV_EXCL_START */
 165                 ERR("ctsvc_end_trans() Fail(%d)", ret);
 166                 return ret;
 167                 /* LCOV_EXCL_STOP */
 168         }
 169
 170         return CONTACTS_ERROR_NONE;
 171 }
 172
 173 static int __ctsvc_db_group_update_record(contacts_record_h record)
 174 {
 175         int addressbook_id = 0;
 176         int ret = CONTACTS_ERROR_NONE;
 177         int wrn = 0;
 178         char *set = NULL;
 179         GSList *bind_text = NULL;
 180         GSList *cursor = NULL;
 181         ctsvc_group_s *group = (ctsvc_group_s*)record;
 182         char query[CTS_SQL_MAX_LEN] = {0};
 183         cts_stmt stmt = NULL;
 184         bool is_read_only = false;
 185         char *image = NULL;
 186         char *temp = NULL;
 187
 188         RETV_IF(NULL == record, CONTACTS_ERROR_INVALID_PARAMETER);
 189         RETVM_IF(CTSVC_RECORD_GROUP != group->base.r_type, CONTACTS_ERROR_INVALID_PARAMETER,
 190                         "group is invalid type(%d)", group->base.r_type);
 191         RETVM_IF(CTSVC_PROPERTY_FLAG_DIRTY != (group->base.property_flag & CTSVC_PROPERTY_FLAG_DIRTY), CONTACTS_ERROR_NONE, "No update");
 192         RETVM_IF(NULL == group->name, CONTACTS_ERROR_INVALID_PARAMETER,
 193                         "The name of group is empty.");
 194
 195         ret = ctsvc_begin_trans();
 196         RETVM_IF(ret, ret, "ctsvc_begin_trans() Fail(%d)", ret);
 197
 198         snprintf(query, sizeof(query),
 199                         "SELECT addressbook_id, is_read_only, image_thumbnail_path FROM %s WHERE group_id = %d",
 200                         CTS_TABLE_GROUPS, group->id);
 201         ret = ctsvc_query_prepare(query, &stmt);
 202         if (NULL == stmt) {
 203                 /* LCOV_EXCL_START */
 204                 ERR("ctsvc_query_prepare() Fail(%d)", ret);
 205                 ctsvc_end_trans(false);
 206                 return ret;
 207                 /* LCOV_EXCL_STOP */
 208         }
 209
 210         ret = ctsvc_stmt_step(stmt);
 211         if (1 != ret) {
 212                 /* LCOV_EXCL_START */
 213                 ERR("ctsvc_stmt_step() Fail(%d)", ret);
 214                 ctsvc_stmt_finalize(stmt);
 215                 ctsvc_end_trans(false);
 216                 if (CONTACTS_ERROR_NONE == ret) {
 217                         ERR("The group record(%d) is Invalid(%d)", group->id, ret);
 218                         return CONTACTS_ERROR_NO_DATA;
 219                 } else {
 220                         return ret;
 221                 }
 222                 /* LCOV_EXCL_STOP */
 223         }
 224
 225         addressbook_id = ctsvc_stmt_get_int(stmt, 0);
 226         is_read_only = ctsvc_stmt_get_int(stmt, 1);
 227         temp = ctsvc_stmt_get_text(stmt, 2);
 228         image = SAFE_STRDUP(temp);
 229         ctsvc_stmt_finalize(stmt);
 230
 231         if (is_read_only && ctsvc_record_check_property_flag((ctsvc_record_s*)record, _contacts_group.name, CTSVC_PROPERTY_FLAG_DIRTY)) {
 232                 /* LCOV_EXCL_START */
 233                 ERR("Can not change the group name. It is a read-only group (group_id : %d)", group->id);
 234                 ctsvc_end_trans(false);
 235                 free(image);
 236                 return CONTACTS_ERROR_INVALID_PARAMETER;
 237                 /* LCOV_EXCL_STOP */
 238         }
 239
 240         if (false == ctsvc_have_ab_write_permission(addressbook_id, true)) {
 241                 /* LCOV_EXCL_START */
 242                 ERR("No permission in this addresbook_id(%d)", addressbook_id);
 243                 ctsvc_end_trans(false);
 244                 free(image);
 245                 return CONTACTS_ERROR_PERMISSION_DENIED;
 246                 /* LCOV_EXCL_STOP */
 247         }
 248
 249         if (ctsvc_record_check_property_flag((ctsvc_record_s*)group, _contacts_group.image_path, CTSVC_PROPERTY_FLAG_DIRTY)) {
 250                 bool same = false;
 251                 bool check_permission = 0;
 252                 /* delete current image */
 253                 if (image) {
 254                         char full_path[CTSVC_IMG_FULL_PATH_SIZE_MAX] = {0};
 255                         snprintf(full_path, sizeof(full_path), "%s/%s", CTS_GROUP_IMAGE_LOCATION, image);
 256
 257                         if (group->image_thumbnail_path && STRING_EQUAL == strcmp(group->image_thumbnail_path, full_path)) {
 258                                 int index = _contacts_group.image_path & 0x000000FF;
 259                                 ((ctsvc_record_s*)record)->properties_flags[index] = 0;
 260                                 same = true;
 261                         } else {
 262                                 if (group->image_thumbnail_path) {
 263                                         ret = ctsvc_have_file_read_permission(group->image_thumbnail_path);
 264                                         if (ret != CONTACTS_ERROR_NONE) {
 265                                                 /* LCOV_EXCL_START */
 266                                                 ERR("Your module does not have read permission of the image file()");
 267                                                 ctsvc_end_trans(false);
 268                                                 free(image);
 269                                                 return ret;
 270                                                 /* LCOV_EXCL_STOP */
 271                                         }
 272                                         check_permission = true;
 273                                 }
 274                                 ret = unlink(full_path);
 275                                 if (ret < 0)
 276                                         WARN("unlink() Fail(%d)", errno);
 277                         }
 278                 }
 279
 280                 /* add new image file */
 281                 if (false == same && group->image_thumbnail_path) {
 282                         char dest[CTS_SQL_MAX_LEN] = {0};
 283                         if (false == check_permission) {
 284                                 ret = ctsvc_have_file_read_permission(group->image_thumbnail_path);
 285                                 if (ret != CONTACTS_ERROR_NONE) {
 286                                         /* LCOV_EXCL_START */
 287                                         ERR("ctsvc_have_file_read_permission Fail(%d)", ret);
 288                                         ctsvc_end_trans(false);
 289                                         free(image);
 290                                         return ret;
 291                                         /* LCOV_EXCL_STOP */
 292                                 }
 293                         }
 294                         ctsvc_utils_make_image_file_name(0, group->id, group->image_thumbnail_path, dest, sizeof(dest));
 295                         ret = ctsvc_utils_copy_image(CTS_GROUP_IMAGE_LOCATION, group->image_thumbnail_path, dest);
 296                         if (CONTACTS_ERROR_NONE != ret) {
 297                                 /* LCOV_EXCL_START */
 298                                 ERR("cts_copy_file() Fail(%d)", ret);
 299                                 ctsvc_end_trans(false);
 300                                 free(image);
 301                                 return ret;
 302                                 /* LCOV_EXCL_STOP */
 303                         }
 304
 305                         free(group->image_thumbnail_path);
 306                         group->image_thumbnail_path = strdup(dest);
 307                 }
 308         }
 309         free(image);
 310
 311         do {
 312                 char query[CTS_SQL_MAX_LEN] = {0};
 313                 char query_set[CTS_SQL_MAX_LEN] = {0};
 314                 cts_stmt stmt = NULL;
 315
 316                 if (CONTACTS_ERROR_NONE != (ret = ctsvc_db_create_set_query(record, &set, &bind_text))) break;
 317                 if (NULL == set || '\0' == *set)
 318                         break;
 319                 snprintf(query_set, sizeof(query_set), "%s, changed_ver=%d ", set, ctsvc_get_next_ver());
 320
 321                 wrn = snprintf(query, sizeof(query), "UPDATE %s SET %s WHERE group_id = %d", CTS_TABLE_GROUPS, query_set, group->id);
 322                 if (wrn < 0)
 323                         WARN("Error writing in query set (%s)", query_set);
 324
 325                 ret = ctsvc_query_prepare(query, &stmt);
 326                 if (NULL == stmt) {
 327                         /* LCOV_EXCL_START */
 328                         ERR("ctsvc_query_prepare() Fail(%d)", ret);
 329                         break;
 330                         /* LCOV_EXCL_STOP */
 331                 }
 332                 if (bind_text) {
 333                         int i = 0;
 334                         for (cursor = bind_text, i = 1; cursor; cursor = cursor->next, i++) {
 335                                 const char *text = cursor->data;
 336                                 if (text && *text)
 337                                         ctsvc_stmt_bind_text(stmt, i, text);
 338                         }
 339                 }
 340                 ret = ctsvc_stmt_step(stmt);
 341                 if (CONTACTS_ERROR_NONE != ret) {
 342                         /* LCOV_EXCL_START */
 343                         ERR("ctsvc_stmt_step() Fail(%d)", ret);
 344                         ctsvc_stmt_finalize(stmt);
 345                         break;
 346                         /* LCOV_EXCL_STOP */
 347                 }
 348                 ctsvc_stmt_finalize(stmt);
 349
 350                 ctsvc_set_group_noti();
 351         } while (0);
 352
 353         CTSVC_RECORD_RESET_PROPERTY_FLAGS((ctsvc_record_s*)record);
 354         free(set);
 355
 356         if (bind_text) {
 357                 for (cursor = bind_text; cursor; cursor = cursor->next) {
 358                         free(cursor->data);
 359                         cursor->data = NULL;
 360                 }
 361                 g_slist_free(bind_text);
 362         }
 363
 364         if (CONTACTS_ERROR_NONE != ret) {
 365                 ctsvc_end_trans(false);
 366                 return ret;
 367         }
 368
 369         ret = ctsvc_end_trans(true);
 370         RETVM_IF(ret < CONTACTS_ERROR_NONE, ret, "ctsvc_end_trans() Fail(%d)", ret);
 371
 372         return CONTACTS_ERROR_NONE;
 373 }
 374
 375 static int __ctsvc_db_group_delete_record(int id)
 376 {
 377         int ret;
 378         int count = 0;
 379         int addressbook_id;
 380         char query[CTS_SQL_MAX_LEN] = {0};
 381
 382         ret = ctsvc_begin_trans();
 383         RETVM_IF(ret < CONTACTS_ERROR_NONE, ret, "ctsvc_begin_trans() Fail(%d)", ret);
 384
 385         snprintf(query, sizeof(query),
 386                         "SELECT addressbook_id FROM %s WHERE group_id = %d",
 387                         CTS_TABLE_GROUPS, id);
 388
 389         ret = ctsvc_query_get_first_int_result(query, &addressbook_id);
 390         if (ret < CONTACTS_ERROR_NONE) {
 391                 /* LCOV_EXCL_START */
 392                 ERR("The id(%d) is Invalid(%d)", id, addressbook_id);
 393                 ctsvc_end_trans(false);
 394                 return ret;
 395                 /* LCOV_EXCL_STOP */
 396         }
 397
 398         if (false == ctsvc_have_ab_write_permission(addressbook_id, true)) {
 399                 /* LCOV_EXCL_START */
 400                 ERR("No permission in this addresbook_id(%d)", addressbook_id);
 401                 ctsvc_end_trans(false);
 402                 return CONTACTS_ERROR_PERMISSION_DENIED;
 403                 /* LCOV_EXCL_STOP */
 404         }
 405
 406         snprintf(query, sizeof(query),
 407                         "SELECT COUNT(contact_id) FROM "CTS_TABLE_GROUP_RELATIONS" WHERE group_id = %d", id);
 408         ret = ctsvc_query_get_first_int_result(query, &count);
 409         if (ret < CONTACTS_ERROR_NONE) {
 410                 /* LCOV_EXCL_START */
 411                 ERR("ctsvc_query_get_first_int_result() Fail(%d)", ret);
 412                 ctsvc_end_trans(false);
 413                 return ret;
 414                 /* LCOV_EXCL_STOP */
 415         }
 416
 417         snprintf(query, sizeof(query), "DELETE FROM %s WHERE group_id=%d AND is_read_only=0",
 418                         CTS_TABLE_GROUPS, id);
 419
 420         ret = ctsvc_query_exec(query);
 421         if (CONTACTS_ERROR_NONE != ret) {
 422                 /* LCOV_EXCL_START */
 423                 ERR("ctsvc_query_exec() Fail(%d)", ret);
 424                 ctsvc_end_trans(false);
 425                 return ret;
 426                 /* LCOV_EXCL_STOP */
 427         }
 428
 429         ret = ctsvc_db_change();
 430         if (ret <= 0) {
 431                 ctsvc_end_trans(false);
 432                 return CONTACTS_ERROR_NO_DATA;
 433         }
 434
 435         ctsvc_get_next_ver();
 436
 437         ctsvc_set_group_noti();
 438         if (0 < count) {
 439                 ctsvc_set_group_rel_noti();
 440                 ctsvc_set_contact_noti();
 441                 ctsvc_set_person_noti();
 442         }
 443
 444         ret = ctsvc_end_trans(true);
 445         if (ret < CONTACTS_ERROR_NONE) {
 446                 /* LCOV_EXCL_START */
 447                 ERR("ctsvc_end_trans() Fail(%d)", ret);
 448                 return ret;
 449                 /* LCOV_EXCL_STOP */
 450         }
 451
 452         return CONTACTS_ERROR_NONE;
 453 }
 454
 455 static int __ctsvc_db_group_value_set(cts_stmt stmt, contacts_record_h *record)
 456 {
 457         int i;
 458         int ret;
 459         char *temp;
 460         ctsvc_group_s *group;
 461         char full_path[CTSVC_IMG_FULL_PATH_SIZE_MAX] = {0};
 462
 463         ret = contacts_record_create(_contacts_group._uri, record);
 464         RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "contacts_record_create Fail(%d)", ret);
 465         group = (ctsvc_group_s*)*record;
 466
 467         i = 0;
 468         group->id = ctsvc_stmt_get_int(stmt, i++);
 469         group->addressbook_id = ctsvc_stmt_get_int(stmt, i++);
 470         temp = ctsvc_stmt_get_text(stmt, i++);
 471         group->name = SAFE_STRDUP(temp);
 472         temp = ctsvc_stmt_get_text(stmt, i++);
 473         group->extra_data = SAFE_STRDUP(temp);
 474         group->is_read_only = ctsvc_stmt_get_int(stmt, i++);
 475         temp = ctsvc_stmt_get_text(stmt, i++);
 476         group->ringtone_path = SAFE_STRDUP(temp);
 477         temp = ctsvc_stmt_get_text(stmt, i++);
 478         group->vibration = SAFE_STRDUP(temp);
 479         temp = ctsvc_stmt_get_text(stmt, i++);
 480         group->message_alert = SAFE_STRDUP(temp);
 481         temp = ctsvc_stmt_get_text(stmt, i++);
 482         if (temp) {
 483                 snprintf(full_path, sizeof(full_path), "%s/%s", CTS_GROUP_IMAGE_LOCATION, temp);
 484                 group->image_thumbnail_path = strdup(full_path);
 485         }
 486
 487         return CONTACTS_ERROR_NONE;
 488 }
 489
 490 static int __ctsvc_db_group_get_record(int id, contacts_record_h *out_record)
 491 {
 492         int ret;
 493         cts_stmt stmt = NULL;
 494         char query[CTS_SQL_MAX_LEN] = {0};
 495         contacts_record_h record;
 496
 497         RETV_IF(NULL == out_record, CONTACTS_ERROR_INVALID_PARAMETER);
 498         *out_record = NULL;
 499
 500         snprintf(query, sizeof(query),
 501                         "SELECT group_id, addressbook_id, group_name, extra_data, is_read_only, "
 502                         "ringtone_path, vibration, message_alert, image_thumbnail_path "
 503                         "FROM "CTS_TABLE_GROUPS" WHERE group_id = %d", id);
 504
 505         ret = ctsvc_query_prepare(query, &stmt);
 506         RETVM_IF(NULL == stmt, ret, "ctsvc_query_prepare() Fail(%d)", ret);
 507
 508         ret = ctsvc_stmt_step(stmt);
 509         if (1 /*CTS_TRUE*/ != ret) {
 510                 /* LCOV_EXCL_START */
 511                 ERR("ctsvc_stmt_step() Fail(%d)", ret);
 512                 ctsvc_stmt_finalize(stmt);
 513                 if (CONTACTS_ERROR_NONE == ret)
 514                         return CONTACTS_ERROR_NO_DATA;
 515                 else
 516                         return ret;
 517                 /* LCOV_EXCL_STOP */
 518         }
 519
 520         ret = __ctsvc_db_group_value_set(stmt, &record);
 521
 522         ctsvc_stmt_finalize(stmt);
 523         if (CONTACTS_ERROR_NONE != ret) {
 524                 /* LCOV_EXCL_START */
 525                 ERR("__ctsvc_db_group_value_set(ALL) Fail(%d)", ret);
 526                 return ret;
 527                 /* LCOV_EXCL_STOP */
 528         }
 529         *out_record = record;
 530
 531         return CONTACTS_ERROR_NONE;
 532 }
 533
 534 static int __ctsvc_db_group_get_all_records(int offset, int limit, contacts_list_h *out_list)
 535 {
 536         int ret;
 537         int len;
 538         cts_stmt stmt;
 539         char query[CTS_SQL_MAX_LEN] = {0};
 540         contacts_list_h list;
 541
 542         len = snprintf(query, sizeof(query),
 543                         "SELECT group_id, addressbook_id, group_name, extra_data, is_read_only, "
 544                         "ringtone_path, vibration, message_alert, image_thumbnail_path "
 545                         "FROM "CTS_TABLE_GROUPS);
 546
 547
 548         len += snprintf(query+len, sizeof(query)-len, " ORDER BY addressbook_id, group_prio");
 549
 550         if (0 != limit) {
 551                 len += snprintf(query+len, sizeof(query)-len, " LIMIT %d", limit);
 552                 if (0 < offset)
 553                         len += snprintf(query+len, sizeof(query)-len, " OFFSET %d", offset);
 554         }
 555
 556         ret = ctsvc_query_prepare(query, &stmt);
 557         RETVM_IF(NULL == stmt, ret, "ctsvc_query_prepare() Fail(%d)", ret);
 558
 559         contacts_list_create(&list);
 560         while ((ret = ctsvc_stmt_step(stmt))) {
 561                 contacts_record_h record;
 562                 if (1 != ret) {
 563                         /* LCOV_EXCL_START */
 564                         ERR("ctsvc_stmt_step() Fail(%d)", ret);
 565                         ctsvc_stmt_finalize(stmt);
 566                         contacts_list_destroy(list, true);
 567                         return ret;
 568                         /* LCOV_EXCL_STOP */
 569                 }
 570                 __ctsvc_db_group_value_set(stmt, &record);
 571
 572                 ctsvc_list_prepend(list, record);
 573         }
 574         ctsvc_stmt_finalize(stmt);
 575         ctsvc_list_reverse(list);
 576
 577         *out_list = (contacts_list_h)list;
 578
 579         return CONTACTS_ERROR_NONE;
 580 }
 581
 582 static int __ctsvc_db_group_get_records_with_query(contacts_query_h query,
 583                 int offset, int limit, contacts_list_h *out_list)
 584 {
 585         int ret;
 586         int i;
 587         int field_count;
 588         ctsvc_query_s *s_query;
 589         cts_stmt stmt;
 590         contacts_list_h list;
 591         ctsvc_group_s *group;
 592         char full_path[CTSVC_IMG_FULL_PATH_SIZE_MAX] = {0};
 593
 594         RETV_IF(NULL == query, CONTACTS_ERROR_INVALID_PARAMETER);
 595         s_query = (ctsvc_query_s*)query;
 596
 597         ret = ctsvc_db_make_get_records_query_stmt(s_query, offset, limit, &stmt);
 598         RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "ctsvc_db_make_get_records_query_stmt fail(%d)", ret);
 599
 600         contacts_list_create(&list);
 601         while ((ret = ctsvc_stmt_step(stmt))) {
 602                 contacts_record_h record;
 603                 if (1 != ret) {
 604                         /* LCOV_EXCL_START */
 605                         ERR("ctsvc_stmt_step() Fail(%d)", ret);
 606                         ctsvc_stmt_finalize(stmt);
 607                         contacts_list_destroy(list, true);
 608                         return ret;
 609                         /* LCOV_EXCL_STOP */
 610                 }
 611
 612                 contacts_record_create(_contacts_group._uri, &record);
 613                 group = (ctsvc_group_s*)record;
 614                 if (0 == s_query->projection_count) {
 615                         field_count = s_query->property_count;
 616                 } else {
 617                         field_count = s_query->projection_count;
 618
 619                         int err = ctsvc_record_set_projection_flags(record, s_query->projection,
 620                                         s_query->projection_count, s_query->property_count);
 621                         if (CONTACTS_ERROR_NONE != err)
 622                                 ASSERT_NOT_REACHED("To set projection is Fail.\n");
 623                 }
 624
 625                 for (i = 0; i < field_count; i++) {
 626                         char *temp;
 627                         int property_id;
 628                         if (0 == s_query->projection_count)
 629                                 property_id = s_query->properties[i].property_id;
 630                         else
 631                                 property_id = s_query->projection[i];
 632
 633                         switch (property_id) {
 634                         case CTSVC_PROPERTY_GROUP_ID:
 635                                 group->id = ctsvc_stmt_get_int(stmt, i);
 636                                 break;
 637                         case CTSVC_PROPERTY_GROUP_ADDRESSBOOK_ID:
 638                                 group->addressbook_id = ctsvc_stmt_get_int(stmt, i);
 639                                 break;
 640                         case CTSVC_PROPERTY_GROUP_NAME:
 641                                 temp = ctsvc_stmt_get_text(stmt, i);
 642                                 free(group->name);
 643                                 group->name = SAFE_STRDUP(temp);
 644                                 break;
 645                         case CTSVC_PROPERTY_GROUP_RINGTONE:
 646                                 temp = ctsvc_stmt_get_text(stmt, i);
 647                                 free(group->ringtone_path);
 648                                 group->ringtone_path = SAFE_STRDUP(temp);
 649                                 break;
 650                         case CTSVC_PROPERTY_GROUP_IMAGE:
 651                                 temp = ctsvc_stmt_get_text(stmt, i);
 652                                 if (temp) {
 653                                         snprintf(full_path, sizeof(full_path), "%s/%s", CTS_GROUP_IMAGE_LOCATION, temp);
 654                                         free(group->image_thumbnail_path);
 655                                         group->image_thumbnail_path = strdup(full_path);
 656                                 }
 657                                 break;
 658                         case CTSVC_PROPERTY_GROUP_VIBRATION:
 659                                 temp = ctsvc_stmt_get_text(stmt, i);
 660                                 free(group->vibration);
 661                                 group->vibration = SAFE_STRDUP(temp);
 662                                 break;
 663                         case CTSVC_PROPERTY_GROUP_MESSAGE_ALERT:
 664                                 temp = ctsvc_stmt_get_text(stmt, i);
 665                                 free(group->message_alert);
 666                                 group->message_alert = SAFE_STRDUP(temp);
 667                                 break;
 668                         case CTSVC_PROPERTY_GROUP_EXTRA_DATA:
 669                                 temp = ctsvc_stmt_get_text(stmt, i);
 670                                 free(group->extra_data);
 671                                 group->extra_data = SAFE_STRDUP(temp);
 672                                 break;
 673                         case CTSVC_PROPERTY_GROUP_IS_READ_ONLY:
 674                                 group->is_read_only = ctsvc_stmt_get_int(stmt, i);
 675                                 break;
 676                         default:
 677                                 break;
 678                         }
 679                 }
 680                 ctsvc_list_prepend(list, record);
 681         }
 682         ctsvc_stmt_finalize(stmt);
 683         ctsvc_list_reverse(list);
 684
 685         *out_list = (contacts_list_h)list;
 686
 687         return CONTACTS_ERROR_NONE;
 688 }
 689
 690 ctsvc_db_plugin_info_s ctsvc_db_plugin_group = {
 691         .is_query_only = false,
 692         .insert_record = __ctsvc_db_group_insert_record,
 693         .get_record = __ctsvc_db_group_get_record,
 694         .update_record = __ctsvc_db_group_update_record,
 695         .delete_record = __ctsvc_db_group_delete_record,
 696         .get_all_records = __ctsvc_db_group_get_all_records,
 697         .get_records_with_query = __ctsvc_db_group_get_records_with_query,
 698         .insert_records = NULL,
 699         .update_records = NULL,
 700         .delete_records = NULL,
 701         .get_count = NULL,
 702         .get_count_with_query = NULL,
 703         .replace_record = NULL,
 704         .replace_records = NULL,
 705 };
 706