server/stickerd_db_manager.c

   1 /*
   2  * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <unistd.h>
  18 #include <string.h>
  19 #include <dlog.h>
  20 #include <sqlite3.h>
  21
  22 #include "stickerd_db_manager.h"
  23 #include "stickerd_error.h"
  24
  25 #ifdef LOG_TAG
  26 #undef LOG_TAG
  27 #endif
  28 #define LOG_TAG "STICKERD_DB_MANAGER"
  29
  30 /*
  31  * Table Information
  32  *
  33  * sticker_info
  34  * +-----------------+--------+------+------+-----------+-------------+------------+------+--------------+
  35  * | INT             | TEXT   | INT  | TEXT | TEXT      | TEXT        | TEXT       | TEXT | INT          |
  36  * +-----------------+--------+------+------+-----------+-------------+------------+------+--------------+
  37  * | sticker_info_id | app_id | type | uri  | thumbnail | description | group_name | date | display_type |
  38  * +-----------------+--------+------+------+-----------+-------------+------------+------+--------------+
  39  *
  40  * sticker_keyword_info
  41  * +------------+-----------------+---------+
  42  * | INT        | INT             | TEXT    |
  43  * +------------+-----------------+---------+
  44  * | keyword_id | sticker_info_id | keyword |
  45  * +------------+-----------------+---------+
  46  *
  47  * sticker_whitelist_info
  48  * +--------------+-------------+-------------+
  49  * | INT          | TEXT        | TEXT        |
  50  * +--------------+-------------+-------------+
  51  * | whitelist_id | provider_id | consumer_id |
  52  * +------------+---------------+-------------+
  53  *
  54  */
  55
  56 #define STICKER_DB_PATH tzplatform_mkpath(TZ_SYS_DB, ".sticker_info.db")
  57 #define STICKER_INFO_CREATE_TABLE "CREATE TABLE IF NOT EXISTS sticker_info(sticker_info_id INTEGER PRIMARY KEY AUTOINCREMENT, app_id TEXT NOT NULL, type INTEGER NOT NULL, uri TEXT NOT NULL, thumbnail TEXT, description TEXT, group_name TEXT NOT NULL, date TEXT NOT NULL, display_type INTEGER)"
  58 #define STICKER_KEYWORD_INFO_CREATE_TABLE "CREATE TABLE IF NOT EXISTS sticker_keyword_info(keyword_id INTEGER PRIMARY KEY AUTOINCREMENT, sticker_info_id INTEGER, keyword TEXT NOT NULL, FOREIGN KEY (sticker_info_id) REFERENCES sticker_info(sticker_info_id) ON DELETE CASCADE)"
  59 #define STICKER_WHITELIST_INFO_CREATE_TABLE "CREATE TABLE IF NOT EXISTS sticker_whitelist_info(whitelist_id INTEGER PRIMARY KEY AUTOINCREMENT, provider_id TEXT NOT NULL, consumer_id TEXT NOT NULL)"
  60
  61 #define STICKER_DB_INSERT_STICKER_INFO "INSERT INTO sticker_info (app_id, type, uri, thumbnail, description, group_name, date, display_type) VALUES (?, ?, ?, ?, ?, ?, DateTime('now','localtime'), ?)"
  62 #define STICKER_DB_INSERT_STICKER_KEYWORD_INFO "INSERT INTO sticker_keyword_info (sticker_info_id, keyword) VALUES (?, ?)"
  63
  64 #define STICKER_DB_DELETE_STICKER_INFO "DELETE FROM sticker_info WHERE sticker_info_id = ?"
  65 #define STICKER_DB_DELETE_STICKER_KEYWORD_INFO "DELETE FROM sticker_keyword_info WHERE sticker_info_id = ?"
  66 #define STICKER_DB_DELETE_STICKER_INFO_BY_URI "DELETE FROM sticker_info WHERE uri = ?"
  67
  68 #define STICKER_DB_UPDATE_STICKER_TYPE "UPDATE sticker_info SET type = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  69 #define STICKER_DB_UPDATE_STICKER_URI "UPDATE sticker_info SET uri = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  70 #define STICKER_DB_UPDATE_STICKER_THUMBNAIL "UPDATE sticker_info SET thumbnail = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  71 #define STICKER_DB_UPDATE_STICKER_DESCRIPTION "UPDATE sticker_info SET description = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  72 #define STICKER_DB_UPDATE_STICKER_GROUP "UPDATE sticker_info SET group_name = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  73 #define STICKER_DB_UPDATE_STICKER_DISP_TYPE "UPDATE sticker_info SET display_type = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  74
  75 #define STICKER_DB_GET_LATEST_RECORD_ID "SELECT sticker_info_id FROM sticker_info ORDER BY sticker_info_id DESC LIMIT 1"
  76 #define STICKER_DB_GET_STICKER_INFO_BY_RECORD_ID "SELECT * FROM sticker_info WHERE sticker_info_id = ?"
  77 #define STICKER_DB_GET_KEYWORD_INFO_BY_RECORD_ID "SELECT keyword FROM sticker_keyword_info WHERE sticker_info_id = ?"
  78 #define STICKER_DB_GET_ALL_GROUP_LIST "SELECT DISTINCT group_name FROM sticker_info WHERE app_id NOT IN (SELECT DISTINCT provider_id FROM sticker_whitelist_info WHERE provider_id NOT IN (SELECT provider_id FROM sticker_whitelist_info WHERE consumer_id = ?))"
  79 #define STICKER_DB_GET_ALL_KEYWORD_LIST "SELECT DISTINCT keyword FROM sticker_keyword_info WHERE sticker_info_id IN (SELECT sticker_info_id from sticker_info WHERE app_id NOT IN (SELECT DISTINCT provider_id FROM sticker_whitelist_info WHERE provider_id NOT IN (SELECT provider_id FROM sticker_whitelist_info WHERE consumer_id = ?)))"
  80 #define STICKER_DB_GET_STICKER_COUNT "SELECT count(*) FROM sticker_info WHERE app_id = ?"
  81 #define STICKER_DB_GET_ALL_RECORD_ID "SELECT sticker_info_id FROM sticker_info WHERE app_id NOT IN (SELECT DISTINCT provider_id FROM sticker_whitelist_info WHERE provider_id NOT IN (SELECT provider_id FROM sticker_whitelist_info WHERE consumer_id = ?)) LIMIT ?, ?"
  82 #define STICKER_DB_GET_RECORD_ID_BY_APP_ID "SELECT sticker_info_id from sticker_info WHERE app_id = ? LIMIT ?, ?"
  83 #define STICKER_DB_GET_RECORD_ID_BY_TYPE "SELECT sticker_info_id FROM sticker_info WHERE type = ? AND app_id NOT IN (SELECT DISTINCT provider_id FROM sticker_whitelist_info WHERE provider_id NOT IN (SELECT provider_id FROM sticker_whitelist_info WHERE consumer_id = ?)) LIMIT ?, ?"
  84 #define STICKER_DB_GET_RECORD_ID_BY_GROUP "SELECT sticker_info_id from sticker_info WHERE group_name = ? AND app_id NOT IN (SELECT DISTINCT provider_id FROM sticker_whitelist_info WHERE provider_id NOT IN (SELECT provider_id FROM sticker_whitelist_info WHERE consumer_id = ?)) LIMIT ?, ?"
  85 #define STICKER_DB_GET_RECORD_ID_BY_KEYWORD "SELECT sticker_info_id FROM sticker_keyword_info WHERE keyword = ? INTERSECT SELECT sticker_info_id from sticker_info WHERE app_id NOT IN (SELECT DISTINCT provider_id FROM sticker_whitelist_info WHERE provider_id NOT IN (SELECT provider_id FROM sticker_whitelist_info WHERE consumer_id = ?)) LIMIT ?, ?"
  86 #define STICKER_DB_GET_RECORD_ID_BY_DISP_TYPE "SELECT sticker_info_id FROM sticker_info WHERE display_type = ? AND app_id NOT IN (SELECT DISTINCT provider_id FROM sticker_whitelist_info WHERE provider_id NOT IN (SELECT provider_id FROM sticker_whitelist_info WHERE consumer_id = ?)) LIMIT ?, ?"
  87 #define STICKER_DB_GET_GROUP_LIST_BY_DISP_TYPE "SELECT DISTINCT group_name FROM sticker_info WHERE display_type = ? AND app_id NOT IN (SELECT DISTINCT provider_id FROM sticker_whitelist_info WHERE provider_id NOT IN (SELECT provider_id FROM sticker_whitelist_info WHERE consumer_id = ?))"
  88 #define STICKER_DB_CHECK_FILE_EXISTS "SELECT EXISTS(SELECT 1 FROM sticker_info WHERE uri = ? LIMIT 1)"
  89
  90 typedef enum
  91 {
  92     CMD_UPDATE,
  93     CMD_SELECT,
  94 } command_type;
  95
  96 static gboolean is_corrupted = FALSE;
  97
  98 static const char *_db_get_query(sticker_info_db_type sticker_type, command_type cmd_type)
  99 {
 100     static const char* query = NULL;
 101
 102     if (cmd_type == CMD_UPDATE) {
 103         switch(sticker_type) {
 104             case STICKER_DB_STICKER_TYPE:
 105             query = STICKER_DB_UPDATE_STICKER_TYPE;
 106             break;
 107             case STICKER_DB_STICKER_URI:
 108             query = STICKER_DB_UPDATE_STICKER_URI;
 109             break;
 110             case STICKER_DB_STICKER_THUMBNAIL:
 111             query = STICKER_DB_UPDATE_STICKER_THUMBNAIL;
 112             break;
 113             case STICKER_DB_STICKER_DESCRIPTION:
 114             query = STICKER_DB_UPDATE_STICKER_DESCRIPTION;
 115             break;
 116             case STICKER_DB_STICKER_GROUP:
 117             query = STICKER_DB_UPDATE_STICKER_GROUP;
 118             break;
 119             case STICKER_DB_STICKER_KEYWORD:
 120             query = STICKER_DB_DELETE_STICKER_KEYWORD_INFO;
 121             break;
 122             case STICKER_DB_STICKER_DISP_TYPE:
 123             query = STICKER_DB_UPDATE_STICKER_DISP_TYPE;
 124             break;
 125             default :
 126             query = "";
 127             break;
 128         }
 129     } else if (cmd_type == CMD_SELECT) {
 130         switch(sticker_type) {
 131             case STICKER_DB_STICKER_ALL:
 132             query = STICKER_DB_GET_ALL_RECORD_ID;
 133             break;
 134             case STICKER_DB_STICKER_APPID:
 135             query = STICKER_DB_GET_RECORD_ID_BY_APP_ID;
 136             break;
 137             case STICKER_DB_STICKER_TYPE:
 138             query = STICKER_DB_GET_RECORD_ID_BY_TYPE;
 139             break;
 140             case STICKER_DB_STICKER_GROUP:
 141             query = STICKER_DB_GET_RECORD_ID_BY_GROUP;
 142             break;
 143             case STICKER_DB_STICKER_KEYWORD:
 144             query = STICKER_DB_GET_RECORD_ID_BY_KEYWORD;
 145             break;
 146             case STICKER_DB_STICKER_DISP_TYPE:
 147             query = STICKER_DB_GET_RECORD_ID_BY_DISP_TYPE;
 148             break;
 149             default :
 150             query = "";
 151             break;
 152         }
 153     }
 154
 155     return query;
 156 }
 157
 158 static int _recover_db(void)
 159 {
 160     int ret = STICKERD_SERVER_ERROR_NONE;
 161     sqlite3 *db = NULL;
 162     char *err = NULL;
 163
 164     LOGD("Start to recover sticker db");
 165     //Remove sticker database file
 166     if (unlink(STICKER_DB_PATH) == -1)
 167         LOGE("Failed to remove db file");
 168
 169     ret = sqlite3_open_v2(STICKER_DB_PATH, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
 170     if (ret != SQLITE_OK) {
 171         LOGE("Failed to open db : %s", sqlite3_errmsg(db));
 172         if (unlink(STICKER_DB_PATH) == -1)
 173             LOGE("Failed to remove db file");
 174         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 175         goto cleanup;
 176     }
 177
 178     ret = sqlite3_exec(db, STICKER_INFO_CREATE_TABLE, NULL, NULL, &err);
 179     if (ret != SQLITE_OK) {
 180         LOGE("Failed to create sticker_info table : %s" , err);
 181         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 182         goto cleanup;
 183     }
 184
 185     ret = sqlite3_exec(db, STICKER_KEYWORD_INFO_CREATE_TABLE, NULL, NULL, &err);
 186     if (ret != SQLITE_OK) {
 187         LOGE("Failed to create sticker_keyword_info table : %s", err);
 188         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 189     }
 190
 191     ret = sqlite3_exec(db, STICKER_WHITELIST_INFO_CREATE_TABLE, NULL, NULL, &err);
 192     if (ret != SQLITE_OK) {
 193         LOGE("Failed to create sticker_whitelist_info table : %s", err);
 194         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 195     }
 196
 197     is_corrupted = FALSE;
 198
 199 cleanup:
 200     if (err)
 201         sqlite3_free(err);
 202
 203     if (db)
 204         sqlite3_close(db);
 205
 206     return ret;
 207 }
 208
 209 static int _integrity_check_cb(void *pid, int argc, char **argv, char **notUsed)
 210 {
 211     if (strcmp(argv[0], "ok") != 0) {
 212         LOGE("DB integrity check failed : %s", argv[0]);
 213         is_corrupted = TRUE;
 214         return -1;
 215     }
 216
 217     LOGD("Result integrity : %s", argv[0]);
 218     return 0;
 219 }
 220
 221 int stickerd_db_init(void)
 222 {
 223     int ret = STICKERD_SERVER_ERROR_NONE;
 224     sqlite3 *db = NULL;
 225     char *err = NULL;
 226
 227     ret = sqlite3_open_v2(STICKER_DB_PATH, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
 228     if (ret != SQLITE_OK) {
 229         LOGE("Failed to open db : %s", sqlite3_errmsg(db));
 230         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 231         goto cleanup;
 232     }
 233
 234     ret = sqlite3_exec(db, STICKER_INFO_CREATE_TABLE, NULL, NULL, &err);
 235     if (ret != SQLITE_OK) {
 236         LOGE("Failed to create sticker_info table : %s" , err);
 237         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 238         goto cleanup;
 239     }
 240
 241     ret = sqlite3_exec(db, STICKER_KEYWORD_INFO_CREATE_TABLE, NULL, NULL, &err);
 242     if (ret != SQLITE_OK) {
 243         LOGE("Failed to create sticker_keyword_info table : %s", err);
 244         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 245         goto cleanup;
 246     }
 247
 248     ret = sqlite3_exec(db, STICKER_WHITELIST_INFO_CREATE_TABLE, NULL, NULL, &err);
 249     if (ret != SQLITE_OK) {
 250         LOGE("Failed to create sticker_whitelist_info table : %s", err);
 251         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 252     }
 253
 254     ret = sqlite3_exec(db, "PRAGMA journal_mode = WAL", NULL, NULL, &err);
 255     if (ret != SQLITE_OK) {
 256         LOGE("Failed to set journal_mode : %s", err);
 257         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 258         goto cleanup;
 259     }
 260
 261     ret = sqlite3_exec(db, "PRAGMA integrity_check", _integrity_check_cb, NULL, &err);
 262     if (ret != SQLITE_OK) {
 263         LOGE("Failed to check integrity : %s", err);
 264         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 265     }
 266
 267 cleanup:
 268     if (err)
 269         sqlite3_free(err);
 270
 271     if (db)
 272         sqlite3_close(db);
 273
 274     if (ret == SQLITE_CORRUPT || ret == SQLITE_NOTADB || is_corrupted)
 275         ret = _recover_db();
 276
 277     return ret;
 278 }
 279
 280 static sqlite3 *_db_open(void)
 281 {
 282     int ret;
 283     sqlite3 *db = NULL;
 284     char *err = NULL;
 285
 286     ret = sqlite3_open(STICKER_DB_PATH, &db);
 287     if (ret != SQLITE_OK) {
 288         LOGE("Failed to open db : %s", sqlite3_errmsg(db));
 289         return NULL;
 290     }
 291
 292     ret = sqlite3_exec(db, "PRAGMA foreign_keys = ON", NULL, NULL, &err);
 293     if (ret != SQLITE_OK) {
 294         LOGE("Failed to turn on foreign keys : %s", err);
 295     }
 296
 297     if (err)
 298         sqlite3_free(err);
 299
 300     return db;
 301 }
 302
 303 int stickerd_db_insert_sticker_info(int *record_id, sticker_info_db *sticker_info)
 304 {
 305     int ret;
 306     sqlite3 *db = NULL;
 307     sqlite3_stmt *stmt = NULL;
 308
 309     db = _db_open();
 310     if (!db)
 311         return STICKERD_SERVER_ERROR_DB_FAILED;
 312
 313     ret = sqlite3_prepare_v2(db, STICKER_DB_INSERT_STICKER_INFO, -1, &stmt, NULL);
 314     if (ret != SQLITE_OK) {
 315         LOGE("fail to insert sticker information : %s", sqlite3_errmsg(db));
 316         goto cleanup;
 317     }
 318
 319     sqlite3_bind_text(stmt, 1, sticker_info->app_id, -1, SQLITE_TRANSIENT);
 320     sqlite3_bind_int(stmt, 2, sticker_info->type);
 321     sqlite3_bind_text(stmt, 3, sticker_info->uri, -1, SQLITE_TRANSIENT);
 322     sqlite3_bind_text(stmt, 4, sticker_info->thumbnail, -1, SQLITE_TRANSIENT);
 323     sqlite3_bind_text(stmt, 5, sticker_info->description, -1, SQLITE_TRANSIENT);
 324     sqlite3_bind_text(stmt, 6, sticker_info->group, -1, SQLITE_TRANSIENT);
 325     sqlite3_bind_int(stmt, 7, sticker_info->display_type);
 326
 327     ret = sqlite3_step(stmt);
 328     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 329         LOGE("sqlite3_step() failed : ret(%d)", ret);
 330         goto cleanup;
 331     } else if (sqlite3_changes(db) == 0) {
 332         LOGE("No changes to DB");
 333         goto cleanup;
 334     }
 335
 336     sqlite3_finalize(stmt);
 337     stmt = NULL;
 338
 339     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_LATEST_RECORD_ID, -1, &stmt, NULL);
 340     if (ret != SQLITE_OK) {
 341         LOGE("fail to get sticker id : %s", sqlite3_errmsg(db));
 342         goto cleanup;
 343     }
 344
 345     ret = sqlite3_step(stmt);
 346     if (ret == SQLITE_ERROR) {
 347         LOGE("sqlite3_step() failed : ret(%d)", ret);
 348         *record_id = 0;
 349         goto cleanup;
 350     } else {
 351         *record_id = sqlite3_column_int(stmt, 0);
 352         LOGD("record_id : %d", *record_id);
 353     }
 354
 355     GList *list;
 356     for(list = sticker_info->keyword; list != NULL; list=list->next) {
 357         sqlite3_finalize(stmt);
 358         stmt = NULL;
 359
 360         ret = sqlite3_prepare_v2(db, STICKER_DB_INSERT_STICKER_KEYWORD_INFO, -1, &stmt, NULL);
 361         if (ret != SQLITE_OK) {
 362             LOGE("fail to insert sticker keyword : %s", sqlite3_errmsg(db));
 363             goto cleanup;
 364         }
 365
 366         sqlite3_bind_int(stmt, 1, *record_id);
 367         sqlite3_bind_text(stmt, 2, (char *)list->data, -1, SQLITE_TRANSIENT);
 368
 369         ret = sqlite3_step(stmt);
 370         if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 371             LOGE("sqlite3_step() failed : ret(%d)", ret);
 372             goto cleanup;
 373         } else if (sqlite3_changes(db) == 0) {
 374             LOGE("No changes to DB");
 375             goto cleanup;
 376         }
 377     }
 378
 379     sqlite3_finalize(stmt);
 380     sqlite3_close(db);
 381
 382     return STICKERD_SERVER_ERROR_NONE;
 383
 384 cleanup:
 385     sqlite3_finalize(stmt);
 386     sqlite3_close(db);
 387
 388     return STICKERD_SERVER_ERROR_DB_FAILED;
 389 }
 390
 391 int stickerd_db_delete_sticker_info(int record_id)
 392 {
 393     int ret;
 394     sqlite3 *db = NULL;
 395     sqlite3_stmt *stmt = NULL;
 396
 397     db = _db_open();
 398     if (!db)
 399         return STICKERD_SERVER_ERROR_DB_FAILED;
 400
 401     ret = sqlite3_prepare_v2(db, STICKER_DB_DELETE_STICKER_INFO, -1, &stmt, NULL);
 402     if (ret != SQLITE_OK) {
 403         LOGE("fail to delete sticker information : %s", sqlite3_errmsg(db));
 404         goto cleanup;
 405     }
 406
 407     sqlite3_bind_int(stmt, 1, record_id);
 408
 409     ret = sqlite3_step(stmt);
 410     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 411         LOGE("sqlite3_step() failed : ret(%d)", ret);
 412         goto cleanup;
 413     } else if (sqlite3_changes(db) == 0) {
 414         LOGE("No changes to DB");
 415         goto cleanup;
 416     }
 417
 418     sqlite3_finalize(stmt);
 419     sqlite3_close(db);
 420
 421     return STICKERD_SERVER_ERROR_NONE;
 422
 423 cleanup:
 424     sqlite3_finalize(stmt);
 425     sqlite3_close(db);
 426
 427     return STICKERD_SERVER_ERROR_DB_FAILED;
 428 }
 429
 430 int stickerd_db_delete_sticker_info_by_uri(char *uri)
 431 {
 432     int ret;
 433     sqlite3 *db = NULL;
 434     sqlite3_stmt *stmt = NULL;
 435
 436     db = _db_open();
 437     if (!db)
 438         return STICKERD_SERVER_ERROR_DB_FAILED;
 439
 440     ret = sqlite3_prepare_v2(db, STICKER_DB_DELETE_STICKER_INFO_BY_URI, -1, &stmt, NULL);
 441     if (ret != SQLITE_OK) {
 442         LOGE("fail to delete sticker information : %s", sqlite3_errmsg(db));
 443         goto cleanup;
 444     }
 445
 446     sqlite3_bind_text(stmt, 1, uri, -1, SQLITE_TRANSIENT);
 447
 448     ret = sqlite3_step(stmt);
 449     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 450         LOGE("sqlite3_step() failed : ret(%d)", ret);
 451         goto cleanup;
 452     } else if (sqlite3_changes(db) == 0) {
 453         LOGE("No changes to DB");
 454         goto cleanup;
 455     }
 456
 457     sqlite3_finalize(stmt);
 458     sqlite3_close(db);
 459
 460     return STICKERD_SERVER_ERROR_NONE;
 461
 462 cleanup:
 463     sqlite3_finalize(stmt);
 464     sqlite3_close(db);
 465
 466     return STICKERD_SERVER_ERROR_DB_FAILED;
 467 }
 468
 469 int stickerd_db_update_sticker_info(int record_id, sticker_info_db_type type, void *data)
 470 {
 471     int ret;
 472     sqlite3 *db = NULL;
 473     sqlite3_stmt *stmt = NULL;
 474
 475     db = _db_open();
 476     if (!db)
 477         return STICKERD_SERVER_ERROR_DB_FAILED;
 478
 479     const char* query = _db_get_query(type, CMD_UPDATE);
 480     ret = sqlite3_prepare_v2(db, query, -1, &stmt, NULL);
 481     if (ret != SQLITE_OK) {
 482         LOGE("fail to update sticker information : %s", sqlite3_errmsg(db));
 483         goto cleanup;
 484     }
 485
 486     if (type == STICKER_DB_STICKER_TYPE || type == STICKER_DB_STICKER_DISP_TYPE) {
 487         sqlite3_bind_int(stmt, 1, *(int *)data);
 488     } else if (type == STICKER_DB_STICKER_KEYWORD) {
 489         sqlite3_bind_int(stmt, 1, record_id);
 490     } else {
 491         sqlite3_bind_text(stmt, 1, (char *)data, -1, SQLITE_TRANSIENT);
 492     }
 493
 494     if (type != STICKER_DB_STICKER_KEYWORD)
 495         sqlite3_bind_int(stmt, 2, record_id);
 496
 497     ret = sqlite3_step(stmt);
 498     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 499         LOGE("sqlite3_step() failed : ret(%d)", ret);
 500         goto cleanup;
 501     }
 502
 503     if (type == STICKER_DB_STICKER_KEYWORD) {
 504         GList *list;
 505         for(list = (GList *)data; list != NULL; list=list->next) {
 506             sqlite3_finalize(stmt);
 507             stmt = NULL;
 508
 509             ret = sqlite3_prepare_v2(db, STICKER_DB_INSERT_STICKER_KEYWORD_INFO, -1, &stmt, NULL);
 510             if (ret != SQLITE_OK) {
 511                 LOGE("fail to insert sticker information : %s", sqlite3_errmsg(db));
 512                 goto cleanup;
 513             }
 514
 515             sqlite3_bind_int(stmt, 1, record_id);
 516             sqlite3_bind_text(stmt, 2, (char *)list->data, -1, SQLITE_TRANSIENT);
 517
 518             ret = sqlite3_step(stmt);
 519             if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 520                 LOGE("sqlite3_step() failed : ret(%d)", ret);
 521                 goto cleanup;
 522             } else if (sqlite3_changes(db) == 0) {
 523                 LOGE("No changes to DB");
 524                 goto cleanup;
 525             }
 526         }
 527     }
 528
 529     sqlite3_finalize(stmt);
 530     sqlite3_close(db);
 531
 532     return STICKERD_SERVER_ERROR_NONE;
 533
 534 cleanup:
 535     sqlite3_finalize(stmt);
 536     sqlite3_close(db);
 537
 538     return STICKERD_SERVER_ERROR_DB_FAILED;
 539 }
 540
 541 int stickerd_db_get_sticker_info_by_record_id(int record_id, sticker_info_db *sticker_info)
 542 {
 543     int ret;
 544     sqlite3 *db = NULL;
 545     sqlite3_stmt *stmt = NULL;
 546
 547     db = _db_open();
 548     if (!db)
 549         return STICKERD_SERVER_ERROR_DB_FAILED;
 550
 551     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_STICKER_INFO_BY_RECORD_ID, -1, &stmt, NULL);
 552     if (ret != SQLITE_OK) {
 553         LOGE("fail to get sticker information : %s", sqlite3_errmsg(db));
 554         goto cleanup;
 555     }
 556
 557     sqlite3_bind_int(stmt, 1, record_id);
 558
 559     ret = sqlite3_step(stmt);
 560     if (ret == SQLITE_ERROR) {
 561         LOGE("sqlite3_step() failed : ret(%d)", ret);
 562         goto cleanup;
 563     }
 564
 565     const unsigned char *tmp_app_id = sqlite3_column_text(stmt, 1);
 566     if (tmp_app_id) {
 567         sticker_info->app_id = strdup((const char *)tmp_app_id);
 568     } else {
 569         LOGW("invalid record_id : %d", record_id);
 570         goto cleanup;
 571     }
 572
 573     sticker_info->type = sqlite3_column_int(stmt, 2);
 574
 575     const unsigned char *tmp_uri = sqlite3_column_text(stmt, 3);
 576     if (tmp_uri)
 577         sticker_info->uri = strdup((const char *)tmp_uri);
 578
 579     const unsigned char *tmp_thumbnail = sqlite3_column_text(stmt, 4);
 580     if (tmp_thumbnail)
 581         sticker_info->thumbnail = strdup((const char *)tmp_thumbnail);
 582
 583     const unsigned char *tmp_description = sqlite3_column_text(stmt, 5);
 584     if (tmp_description)
 585         sticker_info->description = strdup((const char *)tmp_description);
 586
 587     const unsigned char *tmp_group = sqlite3_column_text(stmt, 6);
 588     if (tmp_group)
 589         sticker_info->group = strdup((const char *)tmp_group);
 590
 591     const unsigned char *tmp_date = sqlite3_column_text(stmt, 7);
 592     if (tmp_date)
 593         sticker_info->date = strdup((const char *)tmp_date);
 594
 595     sticker_info->display_type = sqlite3_column_int(stmt, 8);
 596
 597     sqlite3_finalize(stmt);
 598     stmt = NULL;
 599
 600     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_KEYWORD_INFO_BY_RECORD_ID, -1, &stmt, NULL);
 601     if (ret != SQLITE_OK) {
 602         LOGE("fail to get sticker keyword : %s", sqlite3_errmsg(db));
 603         goto cleanup;
 604     }
 605
 606     sqlite3_bind_int(stmt, 1, record_id);
 607
 608     while (sqlite3_step(stmt) == SQLITE_ROW) {
 609         const unsigned char *keyword = sqlite3_column_text(stmt, 0);
 610         if (keyword)
 611             sticker_info->keyword = g_list_append(sticker_info->keyword, strdup((const char *)keyword));
 612     }
 613
 614     sqlite3_finalize(stmt);
 615     sqlite3_close(db);
 616
 617     return STICKERD_SERVER_ERROR_NONE;
 618
 619 cleanup:
 620     sqlite3_finalize(stmt);
 621     sqlite3_close(db);
 622
 623     return STICKERD_SERVER_ERROR_DB_FAILED;
 624 }
 625
 626 int stickerd_db_get_group_list(GVariantBuilder *builder, char *app_id)
 627 {
 628     int ret;
 629     sqlite3 *db = NULL;
 630     sqlite3_stmt *stmt = NULL;
 631
 632     db = _db_open();
 633     if (!db)
 634         return STICKERD_SERVER_ERROR_DB_FAILED;
 635
 636     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_ALL_GROUP_LIST, -1, &stmt, NULL);
 637     if (ret != SQLITE_OK) {
 638         LOGE("fail to get group list : %s", sqlite3_errmsg(db));
 639         goto cleanup;
 640     }
 641
 642     sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
 643
 644     while (sqlite3_step(stmt) == SQLITE_ROW) {
 645         const unsigned char *group = sqlite3_column_text(stmt, 0);
 646         if (group)
 647             g_variant_builder_add(builder, "(s)", strdup((const char *)group));
 648     }
 649
 650     sqlite3_finalize(stmt);
 651     sqlite3_close(db);
 652
 653     return STICKERD_SERVER_ERROR_NONE;
 654
 655 cleanup:
 656     sqlite3_finalize(stmt);
 657     sqlite3_close(db);
 658
 659     return STICKERD_SERVER_ERROR_DB_FAILED;
 660 }
 661
 662 int stickerd_db_get_keyword_list(GVariantBuilder *builder, char *app_id)
 663 {
 664     int ret;
 665     sqlite3 *db = NULL;
 666     sqlite3_stmt *stmt = NULL;
 667
 668     db = _db_open();
 669     if (!db)
 670         return STICKERD_SERVER_ERROR_DB_FAILED;
 671
 672     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_ALL_KEYWORD_LIST, -1, &stmt, NULL);
 673     if (ret != SQLITE_OK) {
 674         LOGE("fail to get keyword list : %s", sqlite3_errmsg(db));
 675         goto cleanup;
 676     }
 677
 678     sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
 679
 680     while (sqlite3_step(stmt) == SQLITE_ROW) {
 681         const unsigned char *keyword = sqlite3_column_text(stmt, 0);
 682         if (keyword)
 683             g_variant_builder_add(builder, "(s)", strdup((const char *)keyword));
 684     }
 685
 686     sqlite3_finalize(stmt);
 687     sqlite3_close(db);
 688
 689     return STICKERD_SERVER_ERROR_NONE;
 690
 691 cleanup:
 692     sqlite3_finalize(stmt);
 693     sqlite3_close(db);
 694
 695     return STICKERD_SERVER_ERROR_DB_FAILED;
 696 }
 697
 698 int stickerd_db_get_sticker_count(int *count, char *app_id)
 699 {
 700     int ret;
 701     sqlite3 *db = NULL;
 702     sqlite3_stmt *stmt = NULL;
 703
 704     db = _db_open();
 705     if (!db)
 706         return STICKERD_SERVER_ERROR_DB_FAILED;
 707
 708     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_STICKER_COUNT, -1, &stmt, NULL);
 709     if (ret != SQLITE_OK) {
 710         LOGE("fail to get sticker count : %s", sqlite3_errmsg(db));
 711         goto cleanup;
 712     }
 713
 714     sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
 715
 716     ret = sqlite3_step(stmt);
 717     if (ret == SQLITE_ERROR) {
 718         LOGE("sqlite3_step() failed : ret(%d)", ret);
 719         goto cleanup;
 720     }
 721
 722     *count = sqlite3_column_int(stmt, 0);
 723
 724     sqlite3_finalize(stmt);
 725     sqlite3_close(db);
 726
 727     return STICKERD_SERVER_ERROR_NONE;
 728
 729 cleanup:
 730     sqlite3_finalize(stmt);
 731     sqlite3_close(db);
 732
 733     return STICKERD_SERVER_ERROR_DB_FAILED;
 734 }
 735
 736 int stickerd_db_get_record_id(sticker_info_db_type type, GList **id_list, void *data, char *app_id, int offset, int count)
 737 {
 738     int ret;
 739     sqlite3 *db = NULL;
 740     sqlite3_stmt *stmt = NULL;
 741
 742     db = _db_open();
 743     if (!db)
 744         return STICKERD_SERVER_ERROR_DB_FAILED;
 745
 746     const char* query = _db_get_query(type, CMD_SELECT);
 747     ret = sqlite3_prepare_v2(db, query, -1, &stmt, NULL);
 748     if (ret != SQLITE_OK) {
 749         LOGE("fail to get record id : %s", sqlite3_errmsg(db));
 750         goto cleanup;
 751     }
 752
 753     if (type == STICKER_DB_STICKER_ALL || type == STICKER_DB_STICKER_APPID) {
 754         sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
 755         sqlite3_bind_int(stmt, 2, offset);
 756         sqlite3_bind_int(stmt, 3, count);
 757     } else {
 758         if (type == STICKER_DB_STICKER_TYPE || type == STICKER_DB_STICKER_DISP_TYPE)
 759             sqlite3_bind_int(stmt, 1, *(int *)data);
 760         else
 761             sqlite3_bind_text(stmt, 1, (char *)data, -1, SQLITE_TRANSIENT);
 762
 763         sqlite3_bind_text(stmt, 2, app_id, -1, SQLITE_TRANSIENT);
 764         sqlite3_bind_int(stmt, 3, offset);
 765         sqlite3_bind_int(stmt, 4, count);
 766     }
 767
 768     while (sqlite3_step(stmt) == SQLITE_ROW) {
 769         const unsigned char *tmp_id = sqlite3_column_text(stmt, 0);
 770         if (tmp_id)
 771             *id_list = g_list_append(*id_list, strdup((const char *)tmp_id));
 772     }
 773
 774     sqlite3_finalize(stmt);
 775     sqlite3_close(db);
 776
 777     return STICKERD_SERVER_ERROR_NONE;
 778
 779 cleanup:
 780     sqlite3_finalize(stmt);
 781     sqlite3_close(db);
 782
 783     return STICKERD_SERVER_ERROR_DB_FAILED;
 784 }
 785
 786 int stickerd_db_get_group_list_by_display_type(GVariantBuilder *builder, char *app_id, int disp_type)
 787 {
 788     int ret;
 789     sqlite3 *db = NULL;
 790     sqlite3_stmt *stmt = NULL;
 791
 792     db = _db_open();
 793     if (!db)
 794         return STICKERD_SERVER_ERROR_DB_FAILED;
 795
 796     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_GROUP_LIST_BY_DISP_TYPE, -1, &stmt, NULL);
 797     if (ret != SQLITE_OK) {
 798         LOGE("fail to get group list : %s", sqlite3_errmsg(db));
 799         goto cleanup;
 800     }
 801
 802     sqlite3_bind_int(stmt, 1, disp_type);
 803     sqlite3_bind_text(stmt, 2, app_id, -1, SQLITE_TRANSIENT);
 804
 805     while (sqlite3_step(stmt) == SQLITE_ROW) {
 806         const unsigned char *group = sqlite3_column_text(stmt, 0);
 807         if (group)
 808             g_variant_builder_add(builder, "(s)", strdup((const char *)group));
 809     }
 810
 811     sqlite3_finalize(stmt);
 812     sqlite3_close(db);
 813
 814     return STICKERD_SERVER_ERROR_NONE;
 815
 816 cleanup:
 817     sqlite3_finalize(stmt);
 818     sqlite3_close(db);
 819
 820     return STICKERD_SERVER_ERROR_DB_FAILED;
 821 }
 822
 823 int stickerd_db_check_file_exists(int *result, char *uri)
 824 {
 825     int ret;
 826     sqlite3 *db = NULL;
 827     sqlite3_stmt *stmt = NULL;
 828
 829     db = _db_open();
 830     if (!db)
 831         return STICKERD_SERVER_ERROR_DB_FAILED;
 832
 833     ret = sqlite3_prepare_v2(db, STICKER_DB_CHECK_FILE_EXISTS, -1, &stmt, NULL);
 834     if (ret != SQLITE_OK) {
 835         LOGE("fail to check file exists : %s", sqlite3_errmsg(db));
 836         goto cleanup;
 837     }
 838
 839     sqlite3_bind_text(stmt, 1, uri, -1, SQLITE_TRANSIENT);
 840
 841     ret = sqlite3_step(stmt);
 842     if (ret == SQLITE_ERROR) {
 843         LOGE("sqlite3_step() failed : ret(%d)", ret);
 844         goto cleanup;
 845     }
 846
 847     *result = sqlite3_column_int(stmt, 0);
 848
 849     sqlite3_finalize(stmt);
 850     sqlite3_close(db);
 851
 852     return STICKERD_SERVER_ERROR_NONE;
 853
 854 cleanup:
 855     sqlite3_finalize(stmt);
 856     sqlite3_close(db);
 857
 858     return STICKERD_SERVER_ERROR_DB_FAILED;
 859 }