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         char *set = NULL;
 178         GSList *bind_text = NULL;
 179         GSList *cursor = NULL;
 180         ctsvc_group_s *group = (ctsvc_group_s*)record;
 181         char query[CTS_SQL_MAX_LEN] = {0};
 182         cts_stmt stmt = NULL;
 183         bool is_read_only = false;
 184         char *image = NULL;
 185         char *temp = NULL;
 186
 187         RETV_IF(NULL == record, CONTACTS_ERROR_INVALID_PARAMETER);
 188         RETVM_IF(CTSVC_RECORD_GROUP != group->base.r_type, CONTACTS_ERROR_INVALID_PARAMETER,
 189                         "group is invalid type(%d)", group->base.r_type);
 190         RETVM_IF(CTSVC_PROPERTY_FLAG_DIRTY != (group->base.property_flag & CTSVC_PROPERTY_FLAG_DIRTY), CONTACTS_ERROR_NONE, "No update");
 191         RETVM_IF(NULL == group->name, CONTACTS_ERROR_INVALID_PARAMETER,
 192                         "The name of group is empty.");
 193
 194         ret = ctsvc_begin_trans();
 195         RETVM_IF(ret, ret, "ctsvc_begin_trans() Fail(%d)", ret);
 196
 197         snprintf(query, sizeof(query),
 198                         "SELECT addressbook_id, is_read_only, image_thumbnail_path FROM %s WHERE group_id = %d",
 199                         CTS_TABLE_GROUPS, group->id);
 200         ret = ctsvc_query_prepare(query, &stmt);
 201         if (NULL == stmt) {
 202                 /* LCOV_EXCL_START */
 203                 ERR("ctsvc_query_prepare() Fail(%d)", ret);
 204                 ctsvc_end_trans(false);
 205                 return ret;
 206                 /* LCOV_EXCL_STOP */
 207         }
 208
 209         ret = ctsvc_stmt_step(stmt);
 210         if (1 != ret) {
 211                 /* LCOV_EXCL_START */
 212                 ERR("ctsvc_stmt_step() Fail(%d)", ret);
 213                 ctsvc_stmt_finalize(stmt);
 214                 ctsvc_end_trans(false);
 215                 if (CONTACTS_ERROR_NONE == ret) {
 216                         ERR("The group record(%d) is Invalid(%d)", group->id, ret);
 217                         return CONTACTS_ERROR_NO_DATA;
 218                 } else {
 219                         return ret;
 220                 }
 221                 /* LCOV_EXCL_STOP */
 222         }
 223
 224         addressbook_id = ctsvc_stmt_get_int(stmt, 0);
 225         is_read_only = ctsvc_stmt_get_int(stmt, 1);
 226         temp = ctsvc_stmt_get_text(stmt, 2);
 227         image = SAFE_STRDUP(temp);
 228         ctsvc_stmt_finalize(stmt);
 229
 230         if (is_read_only && ctsvc_record_check_property_flag((ctsvc_record_s*)record, _contacts_group.name, CTSVC_PROPERTY_FLAG_DIRTY)) {
 231                 /* LCOV_EXCL_START */
 232                 ERR("Can not change the group name. It is a read-only group (group_id : %d)", group->id);
 233                 ctsvc_end_trans(false);
 234                 free(image);
 235                 return CONTACTS_ERROR_INVALID_PARAMETER;
 236                 /* LCOV_EXCL_STOP */
 237         }
 238
 239         if (false == ctsvc_have_ab_write_permission(addressbook_id, true)) {
 240                 /* LCOV_EXCL_START */
 241                 ERR("No permission in this addresbook_id(%d)", addressbook_id);
 242                 ctsvc_end_trans(false);
 243                 free(image);
 244                 return CONTACTS_ERROR_PERMISSION_DENIED;
 245                 /* LCOV_EXCL_STOP */
 246         }
 247
 248         if (ctsvc_record_check_property_flag((ctsvc_record_s*)group, _contacts_group.image_path, CTSVC_PROPERTY_FLAG_DIRTY)) {
 249                 bool same = false;
 250                 bool check_permission = 0;
 251                 /* delete current image */
 252                 if (image) {
 253                         char full_path[CTSVC_IMG_FULL_PATH_SIZE_MAX] = {0};
 254                         snprintf(full_path, sizeof(full_path), "%s/%s", CTS_GROUP_IMAGE_LOCATION, image);
 255
 256                         if (group->image_thumbnail_path && STRING_EQUAL == strcmp(group->image_thumbnail_path, full_path)) {
 257                                 int index = _contacts_group.image_path & 0x000000FF;
 258                                 ((ctsvc_record_s*)record)->properties_flags[index] = 0;
 259                                 same = true;
 260                         } else {
 261                                 if (group->image_thumbnail_path) {
 262                                         ret = ctsvc_have_file_read_permission(group->image_thumbnail_path);
 263                                         if (ret != CONTACTS_ERROR_NONE) {
 264                                                 /* LCOV_EXCL_START */
 265                                                 ERR("Your module does not have read permission of the image file()");
 266                                                 ctsvc_end_trans(false);
 267                                                 free(image);
 268                                                 return ret;
 269                                                 /* LCOV_EXCL_STOP */
 270                                         }
 271                                         check_permission = true;
 272                                 }
 273                                 ret = unlink(full_path);
 274                                 if (ret < 0)
 275                                         WARN("unlink() Fail(%d)", errno);
 276                         }
 277                 }
 278
 279                 /* add new image file */
 280                 if (false == same && group->image_thumbnail_path) {
 281                         char dest[CTS_SQL_MAX_LEN] = {0};
 282                         if (false == check_permission) {
 283                                 ret = ctsvc_have_file_read_permission(group->image_thumbnail_path);
 284                                 if (ret != CONTACTS_ERROR_NONE) {
 285                                         /* LCOV_EXCL_START */
 286                                         ERR("ctsvc_have_file_read_permission Fail(%d)", ret);
 287                                         ctsvc_end_trans(false);
 288                                         free(image);
 289                                         return ret;
 290                                         /* LCOV_EXCL_STOP */
 291                                 }
 292                         }
 293                         ctsvc_utils_make_image_file_name(0, group->id, group->image_thumbnail_path, dest, sizeof(dest));
 294                         ret = ctsvc_utils_copy_image(CTS_GROUP_IMAGE_LOCATION, group->image_thumbnail_path, dest);
 295                         if (CONTACTS_ERROR_NONE != ret) {
 296                                 /* LCOV_EXCL_START */
 297                                 ERR("cts_copy_file() Fail(%d)", ret);
 298                                 ctsvc_end_trans(false);
 299                                 free(image);
 300                                 return ret;
 301                                 /* LCOV_EXCL_STOP */
 302                         }
 303
 304                         free(group->image_thumbnail_path);
 305                         group->image_thumbnail_path = strdup(dest);
 306                 }
 307         }
 308         free(image);
 309
 310         do {
 311                 char query[CTS_SQL_MAX_LEN] = {0};
 312                 char query_set[CTS_SQL_MAX_LEN] = {0};
 313                 cts_stmt stmt = NULL;
 314
 315                 if (CONTACTS_ERROR_NONE != (ret = ctsvc_db_create_set_query(record, &set, &bind_text))) break;
 316                 if (NULL == set || '\0' == *set)
 317                         break;
 318                 snprintf(query_set, sizeof(query_set), "%s, changed_ver=%d ", set, ctsvc_get_next_ver());
 319
 320                 snprintf(query, sizeof(query), "UPDATE %s SET %s WHERE group_id = %d", CTS_TABLE_GROUPS, query_set, group->id);
 321                 ret = ctsvc_query_prepare(query, &stmt);
 322                 if (NULL == stmt) {
 323                         /* LCOV_EXCL_START */
 324                         ERR("ctsvc_query_prepare() Fail(%d)", ret);
 325                         break;
 326                         /* LCOV_EXCL_STOP */
 327                 }
 328                 if (bind_text) {
 329                         int i = 0;
 330                         for (cursor = bind_text, i = 1; cursor; cursor = cursor->next, i++) {
 331                                 const char *text = cursor->data;
 332                                 if (text && *text)
 333                                         ctsvc_stmt_bind_text(stmt, i, text);
 334                         }
 335                 }
 336                 ret = ctsvc_stmt_step(stmt);
 337                 if (CONTACTS_ERROR_NONE != ret) {
 338                         /* LCOV_EXCL_START */
 339                         ERR("ctsvc_stmt_step() Fail(%d)", ret);
 340                         ctsvc_stmt_finalize(stmt);
 341                         break;
 342                         /* LCOV_EXCL_STOP */
 343                 }
 344                 ctsvc_stmt_finalize(stmt);
 345
 346                 ctsvc_set_group_noti();
 347         } while (0);
 348
 349         CTSVC_RECORD_RESET_PROPERTY_FLAGS((ctsvc_record_s*)record);
 350         free(set);
 351
 352         if (bind_text) {
 353                 for (cursor = bind_text; cursor; cursor = cursor->next) {
 354                         free(cursor->data);
 355                         cursor->data = NULL;
 356                 }
 357                 g_slist_free(bind_text);
 358         }
 359
 360         if (CONTACTS_ERROR_NONE != ret) {
 361                 ctsvc_end_trans(false);
 362                 return ret;
 363         }
 364
 365         ret = ctsvc_end_trans(true);
 366         RETVM_IF(ret < CONTACTS_ERROR_NONE, ret, "ctsvc_end_trans() Fail(%d)", ret);
 367
 368         return CONTACTS_ERROR_NONE;
 369 }
 370
 371 static int __ctsvc_db_group_delete_record(int id)
 372 {
 373         int ret;
 374         int count = 0;
 375         int addressbook_id;
 376         char query[CTS_SQL_MAX_LEN] = {0};
 377
 378         ret = ctsvc_begin_trans();
 379         RETVM_IF(ret < CONTACTS_ERROR_NONE, ret, "ctsvc_begin_trans() Fail(%d)", ret);
 380
 381         snprintf(query, sizeof(query),
 382                         "SELECT addressbook_id FROM %s WHERE group_id = %d",
 383                         CTS_TABLE_GROUPS, id);
 384
 385         ret = ctsvc_query_get_first_int_result(query, &addressbook_id);
 386         if (ret < CONTACTS_ERROR_NONE) {
 387                 /* LCOV_EXCL_START */
 388                 ERR("The id(%d) is Invalid(%d)", id, addressbook_id);
 389                 ctsvc_end_trans(false);
 390                 return ret;
 391                 /* LCOV_EXCL_STOP */
 392         }
 393
 394         if (false == ctsvc_have_ab_write_permission(addressbook_id, true)) {
 395                 /* LCOV_EXCL_START */
 396                 ERR("No permission in this addresbook_id(%d)", addressbook_id);
 397                 ctsvc_end_trans(false);
 398                 return CONTACTS_ERROR_PERMISSION_DENIED;
 399                 /* LCOV_EXCL_STOP */
 400         }
 401
 402         snprintf(query, sizeof(query),
 403                         "SELECT COUNT(contact_id) FROM "CTS_TABLE_GROUP_RELATIONS" WHERE group_id = %d", id);
 404         ret = ctsvc_query_get_first_int_result(query, &count);
 405         if (ret < CONTACTS_ERROR_NONE) {
 406                 /* LCOV_EXCL_START */
 407                 ERR("ctsvc_query_get_first_int_result() Fail(%d)", ret);
 408                 ctsvc_end_trans(false);
 409                 return ret;
 410                 /* LCOV_EXCL_STOP */
 411         }
 412
 413         snprintf(query, sizeof(query), "DELETE FROM %s WHERE group_id=%d AND is_read_only=0",
 414                         CTS_TABLE_GROUPS, id);
 415
 416         ret = ctsvc_query_exec(query);
 417         if (CONTACTS_ERROR_NONE != ret) {
 418                 /* LCOV_EXCL_START */
 419                 ERR("ctsvc_query_exec() Fail(%d)", ret);
 420                 ctsvc_end_trans(false);
 421                 return ret;
 422                 /* LCOV_EXCL_STOP */
 423         }
 424
 425         ret = ctsvc_db_change();
 426         if (ret <= 0) {
 427                 ctsvc_end_trans(false);
 428                 return CONTACTS_ERROR_NO_DATA;
 429         }
 430
 431         ctsvc_get_next_ver();
 432
 433         ctsvc_set_group_noti();
 434         if (0 < count) {
 435                 ctsvc_set_group_rel_noti();
 436                 ctsvc_set_contact_noti();
 437                 ctsvc_set_person_noti();
 438         }
 439
 440         ret = ctsvc_end_trans(true);
 441         if (ret < CONTACTS_ERROR_NONE) {
 442                 /* LCOV_EXCL_START */
 443                 ERR("ctsvc_end_trans() Fail(%d)", ret);
 444                 return ret;
 445                 /* LCOV_EXCL_STOP */
 446         }
 447
 448         return CONTACTS_ERROR_NONE;
 449 }
 450
 451 static int __ctsvc_db_group_value_set(cts_stmt stmt, contacts_record_h *record)
 452 {
 453         int i;
 454         int ret;
 455         char *temp;
 456         ctsvc_group_s *group;
 457         char full_path[CTSVC_IMG_FULL_PATH_SIZE_MAX] = {0};
 458
 459         ret = contacts_record_create(_contacts_group._uri, record);
 460         RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "contacts_record_create Fail(%d)", ret);
 461         group = (ctsvc_group_s*)*record;
 462
 463         i = 0;
 464         group->id = ctsvc_stmt_get_int(stmt, i++);
 465         group->addressbook_id = ctsvc_stmt_get_int(stmt, i++);
 466         temp = ctsvc_stmt_get_text(stmt, i++);
 467         group->name = SAFE_STRDUP(temp);
 468         temp = ctsvc_stmt_get_text(stmt, i++);
 469         group->extra_data = SAFE_STRDUP(temp);
 470         group->is_read_only = ctsvc_stmt_get_int(stmt, i++);
 471         temp = ctsvc_stmt_get_text(stmt, i++);
 472         group->ringtone_path = SAFE_STRDUP(temp);
 473         temp = ctsvc_stmt_get_text(stmt, i++);
 474         group->vibration = SAFE_STRDUP(temp);
 475         temp = ctsvc_stmt_get_text(stmt, i++);
 476         group->message_alert = SAFE_STRDUP(temp);
 477         temp = ctsvc_stmt_get_text(stmt, i++);
 478         if (temp) {
 479                 snprintf(full_path, sizeof(full_path), "%s/%s", CTS_GROUP_IMAGE_LOCATION, temp);
 480                 group->image_thumbnail_path = strdup(full_path);
 481         }
 482
 483         return CONTACTS_ERROR_NONE;
 484 }
 485
 486 static int __ctsvc_db_group_get_record(int id, contacts_record_h *out_record)
 487 {
 488         int ret;
 489         cts_stmt stmt = NULL;
 490         char query[CTS_SQL_MAX_LEN] = {0};
 491         contacts_record_h record;
 492
 493         RETV_IF(NULL == out_record, CONTACTS_ERROR_INVALID_PARAMETER);
 494         *out_record = NULL;
 495
 496         snprintf(query, sizeof(query),
 497                         "SELECT group_id, addressbook_id, group_name, extra_data, is_read_only, "
 498                         "ringtone_path, vibration, message_alert, image_thumbnail_path "
 499                         "FROM "CTS_TABLE_GROUPS" WHERE group_id = %d", id);
 500
 501         ret = ctsvc_query_prepare(query, &stmt);
 502         RETVM_IF(NULL == stmt, ret, "ctsvc_query_prepare() Fail(%d)", ret);
 503
 504         ret = ctsvc_stmt_step(stmt);
 505         if (1 /*CTS_TRUE*/ != ret) {
 506                 /* LCOV_EXCL_START */
 507                 ERR("ctsvc_stmt_step() Fail(%d)", ret);
 508                 ctsvc_stmt_finalize(stmt);
 509                 if (CONTACTS_ERROR_NONE == ret)
 510                         return CONTACTS_ERROR_NO_DATA;
 511                 else
 512                         return ret;
 513                 /* LCOV_EXCL_STOP */
 514         }
 515
 516         ret = __ctsvc_db_group_value_set(stmt, &record);
 517
 518         ctsvc_stmt_finalize(stmt);
 519         if (CONTACTS_ERROR_NONE != ret) {
 520                 /* LCOV_EXCL_START */
 521                 ERR("__ctsvc_db_group_value_set(ALL) Fail(%d)", ret);
 522                 return ret;
 523                 /* LCOV_EXCL_STOP */
 524         }
 525         *out_record = record;
 526
 527         return CONTACTS_ERROR_NONE;
 528 }
 529
 530 static int __ctsvc_db_group_get_all_records(int offset, int limit, contacts_list_h *out_list)
 531 {
 532         int ret;
 533         int len;
 534         cts_stmt stmt;
 535         char query[CTS_SQL_MAX_LEN] = {0};
 536         contacts_list_h list;
 537
 538         len = snprintf(query, sizeof(query),
 539                         "SELECT group_id, addressbook_id, group_name, extra_data, is_read_only, "
 540                         "ringtone_path, vibration, message_alert, image_thumbnail_path "
 541                         "FROM "CTS_TABLE_GROUPS);
 542
 543
 544         len += snprintf(query+len, sizeof(query)-len, " ORDER BY addressbook_id, group_prio");
 545
 546         if (0 != limit) {
 547                 len += snprintf(query+len, sizeof(query)-len, " LIMIT %d", limit);
 548                 if (0 < offset)
 549                         len += snprintf(query+len, sizeof(query)-len, " OFFSET %d", offset);
 550         }
 551
 552         ret = ctsvc_query_prepare(query, &stmt);
 553         RETVM_IF(NULL == stmt, ret, "ctsvc_query_prepare() Fail(%d)", ret);
 554
 555         contacts_list_create(&list);
 556         while ((ret = ctsvc_stmt_step(stmt))) {
 557                 contacts_record_h record;
 558                 if (1 != ret) {
 559                         /* LCOV_EXCL_START */
 560                         ERR("ctsvc_stmt_step() Fail(%d)", ret);
 561                         ctsvc_stmt_finalize(stmt);
 562                         contacts_list_destroy(list, true);
 563                         return ret;
 564                         /* LCOV_EXCL_STOP */
 565                 }
 566                 __ctsvc_db_group_value_set(stmt, &record);
 567
 568                 ctsvc_list_prepend(list, record);
 569         }
 570         ctsvc_stmt_finalize(stmt);
 571         ctsvc_list_reverse(list);
 572
 573         *out_list = (contacts_list_h)list;
 574
 575         return CONTACTS_ERROR_NONE;
 576 }
 577
 578 static int __ctsvc_db_group_get_records_with_query(contacts_query_h query,
 579                 int offset, int limit, contacts_list_h *out_list)
 580 {
 581         int ret;
 582         int i;
 583         int field_count;
 584         ctsvc_query_s *s_query;
 585         cts_stmt stmt;
 586         contacts_list_h list;
 587         ctsvc_group_s *group;
 588         char full_path[CTSVC_IMG_FULL_PATH_SIZE_MAX] = {0};
 589
 590         RETV_IF(NULL == query, CONTACTS_ERROR_INVALID_PARAMETER);
 591         s_query = (ctsvc_query_s*)query;
 592
 593         ret = ctsvc_db_make_get_records_query_stmt(s_query, offset, limit, &stmt);
 594         RETVM_IF(CONTACTS_ERROR_NONE != ret, ret, "ctsvc_db_make_get_records_query_stmt fail(%d)", ret);
 595
 596         contacts_list_create(&list);
 597         while ((ret = ctsvc_stmt_step(stmt))) {
 598                 contacts_record_h record;
 599                 if (1 != ret) {
 600                         /* LCOV_EXCL_START */
 601                         ERR("ctsvc_stmt_step() Fail(%d)", ret);
 602                         ctsvc_stmt_finalize(stmt);
 603                         contacts_list_destroy(list, true);
 604                         return ret;
 605                         /* LCOV_EXCL_STOP */
 606                 }
 607
 608                 contacts_record_create(_contacts_group._uri, &record);
 609                 group = (ctsvc_group_s*)record;
 610                 if (0 == s_query->projection_count) {
 611                         field_count = s_query->property_count;
 612                 } else {
 613                         field_count = s_query->projection_count;
 614
 615                         int err = ctsvc_record_set_projection_flags(record, s_query->projection,
 616                                         s_query->projection_count, s_query->property_count);
 617                         if (CONTACTS_ERROR_NONE != err)
 618                                 ASSERT_NOT_REACHED("To set projection is Fail.\n");
 619                 }
 620
 621                 for (i = 0; i < field_count; i++) {
 622                         char *temp;
 623                         int property_id;
 624                         if (0 == s_query->projection_count)
 625                                 property_id = s_query->properties[i].property_id;
 626                         else
 627                                 property_id = s_query->projection[i];
 628
 629                         switch (property_id) {
 630                         case CTSVC_PROPERTY_GROUP_ID:
 631                                 group->id = ctsvc_stmt_get_int(stmt, i);
 632                                 break;
 633                         case CTSVC_PROPERTY_GROUP_ADDRESSBOOK_ID:
 634                                 group->addressbook_id = ctsvc_stmt_get_int(stmt, i);
 635                                 break;
 636                         case CTSVC_PROPERTY_GROUP_NAME:
 637                                 temp = ctsvc_stmt_get_text(stmt, i);
 638                                 free(group->name);
 639                                 group->name = SAFE_STRDUP(temp);
 640                                 break;
 641                         case CTSVC_PROPERTY_GROUP_RINGTONE:
 642                                 temp = ctsvc_stmt_get_text(stmt, i);
 643                                 free(group->ringtone_path);
 644                                 group->ringtone_path = SAFE_STRDUP(temp);
 645                                 break;
 646                         case CTSVC_PROPERTY_GROUP_IMAGE:
 647                                 temp = ctsvc_stmt_get_text(stmt, i);
 648                                 if (temp) {
 649                                         snprintf(full_path, sizeof(full_path), "%s/%s", CTS_GROUP_IMAGE_LOCATION, temp);
 650                                         free(group->image_thumbnail_path);
 651                                         group->image_thumbnail_path = strdup(full_path);
 652                                 }
 653                                 break;
 654                         case CTSVC_PROPERTY_GROUP_VIBRATION:
 655                                 temp = ctsvc_stmt_get_text(stmt, i);
 656                                 free(group->vibration);
 657                                 group->vibration = SAFE_STRDUP(temp);
 658                                 break;
 659                         case CTSVC_PROPERTY_GROUP_MESSAGE_ALERT:
 660                                 temp = ctsvc_stmt_get_text(stmt, i);
 661                                 free(group->message_alert);
 662                                 group->message_alert = SAFE_STRDUP(temp);
 663                                 break;
 664                         case CTSVC_PROPERTY_GROUP_EXTRA_DATA:
 665                                 temp = ctsvc_stmt_get_text(stmt, i);
 666                                 free(group->extra_data);
 667                                 group->extra_data = SAFE_STRDUP(temp);
 668                                 break;
 669                         case CTSVC_PROPERTY_GROUP_IS_READ_ONLY:
 670                                 group->is_read_only = ctsvc_stmt_get_int(stmt, i);
 671                                 break;
 672                         default:
 673                                 break;
 674                         }
 675                 }
 676                 ctsvc_list_prepend(list, record);
 677         }
 678         ctsvc_stmt_finalize(stmt);
 679         ctsvc_list_reverse(list);
 680
 681         *out_list = (contacts_list_h)list;
 682
 683         return CONTACTS_ERROR_NONE;
 684 }
 685
 686 ctsvc_db_plugin_info_s ctsvc_db_plugin_group = {
 687         .is_query_only = false,
 688         .insert_record = __ctsvc_db_group_insert_record,
 689         .get_record = __ctsvc_db_group_get_record,
 690         .update_record = __ctsvc_db_group_update_record,
 691         .delete_record = __ctsvc_db_group_delete_record,
 692         .get_all_records = __ctsvc_db_group_get_all_records,
 693         .get_records_with_query = __ctsvc_db_group_get_records_with_query,
 694         .insert_records = NULL,
 695         .update_records = NULL,
 696         .delete_records = NULL,
 697         .get_count = NULL,
 698         .get_count_with_query = NULL,
 699         .replace_record = NULL,
 700         .replace_records = NULL,
 701 };
 702