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  * sticker_recent_history_info
  55  * +------------+-----------------+-------+-----------+
  56  * | INT        | INT             | INT   | TEXT      |
  57  * +------------+-----------------+-------+-----------+
  58  * | history_id | sticker_info_id | count | timestamp |
  59  * +------------+-----------------+-------+-----------+
  60  *
  61  * * sticker_group_info
  62  * +----------+--------+------------+------+------+
  63  * | INT      | TEXT   | TEXT       | INT  | TEXT |
  64  * +----------+--------+------------+------+------+
  65  * | group_id | app_id | group_name | type | uri  |
  66  * +----------+--------+------------+------+------+
  67  *
  68  */
  69
  70 #define STICKER_DB_PATH tzplatform_mkpath(TZ_SYS_DB, ".sticker_info.db")
  71 #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)"
  72 #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)"
  73 #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)"
  74 #define STICKER_RECENT_HISTORY_INFO_CREATE_TABLE "CREATE TABLE IF NOT EXISTS sticker_recent_history_info(history_id INTEGER PRIMARY KEY AUTOINCREMENT, sticker_info_id INTEGER, count INTEGER NOT NULL, timestamp TEXT NOT NULL, FOREIGN KEY (sticker_info_id) REFERENCES sticker_info(sticker_info_id) ON DELETE CASCADE)"
  75 #define STICKER_GROUP_INFO_CREATE_TABLE "CREATE TABLE IF NOT EXISTS sticker_group_info(group_id INTEGER PRIMARY KEY AUTOINCREMENT, app_id TEXT NOT NULL, group_name TEXT NOT NULL, type INTEGER NOT NULL, uri TEXT NOT NULL)"
  76
  77 #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'), ?)"
  78 #define STICKER_DB_INSERT_STICKER_KEYWORD_INFO "INSERT INTO sticker_keyword_info (sticker_info_id, keyword) VALUES (?, ?)"
  79 #define STICKER_DB_INSERT_RECENT_HISTORY "INSERT INTO sticker_recent_history_info (sticker_info_id, count, timestamp) VALUES (?, 1, DateTime('now','localtime'))"
  80 #define STICKER_DB_INSERT_GROUP_IMAGE "INSERT INTO sticker_group_info (app_id, group_name, type, uri) VALUES (?, ?, ?, ?)"
  81
  82 #define STICKER_DB_DELETE_STICKER_INFO "DELETE FROM sticker_info WHERE sticker_info_id = ?"
  83 #define STICKER_DB_DELETE_STICKER_KEYWORD_INFO "DELETE FROM sticker_keyword_info WHERE sticker_info_id = ?"
  84 #define STICKER_DB_DELETE_STICKER_INFO_BY_URI "DELETE FROM sticker_info WHERE uri = ?"
  85
  86 #define STICKER_DB_UPDATE_STICKER_TYPE "UPDATE sticker_info SET type = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  87 #define STICKER_DB_UPDATE_STICKER_URI "UPDATE sticker_info SET uri = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  88 #define STICKER_DB_UPDATE_STICKER_THUMBNAIL "UPDATE sticker_info SET thumbnail = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  89 #define STICKER_DB_UPDATE_STICKER_DESCRIPTION "UPDATE sticker_info SET description = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  90 #define STICKER_DB_UPDATE_STICKER_GROUP "UPDATE sticker_info SET group_name = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  91 #define STICKER_DB_UPDATE_STICKER_DISP_TYPE "UPDATE sticker_info SET display_type = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  92 #define STICKER_DB_UPDATE_RECENT_HISTORY "UPDATE sticker_recent_history_info SET count = count + 1, timestamp = DateTime('now','localtime') WHERE sticker_info_id = ?"
  93 #define STICKER_DB_UPDATE_GROUP_IMAGE "UPDATE sticker_group_info SET type = ?, uri = ? WHERE app_id = ? AND group_name = ?"
  94
  95 #define STICKER_DB_GET_LATEST_RECORD_ID "SELECT sticker_info_id FROM sticker_info ORDER BY sticker_info_id DESC LIMIT 1"
  96 #define STICKER_DB_GET_STICKER_INFO_BY_RECORD_ID "SELECT * FROM sticker_info WHERE sticker_info_id = ?"
  97 #define STICKER_DB_GET_KEYWORD_INFO_BY_RECORD_ID "SELECT keyword FROM sticker_keyword_info WHERE sticker_info_id = ?"
  98 #define STICKER_DB_GET_IMAGE_INFO_BY_RECORD_ID "SELECT type, uri, thumbnail FROM sticker_info WHERE sticker_info_id = ?"
  99 #define STICKER_DB_GET_IMAGE_INFO_BY_URI "SELECT type, thumbnail FROM sticker_info WHERE uri = ?"
 100 #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 = ?))"
 101 #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 = ?)))"
 102 #define STICKER_DB_GET_STICKER_COUNT "SELECT count(*) FROM sticker_info WHERE app_id = ?"
 103 #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 = ?)) ORDER BY sticker_info_id DESC LIMIT ?, ?"
 104 #define STICKER_DB_GET_RECORD_ID_BY_APP_ID "SELECT sticker_info_id from sticker_info WHERE app_id = ? ORDER BY sticker_info_id DESC LIMIT ?, ?"
 105 #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 = ?)) ORDER BY sticker_info_id DESC LIMIT ?, ?"
 106 #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 = ?)) ORDER BY sticker_info_id DESC LIMIT ?, ?"
 107 #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 = ?)) ORDER BY sticker_info_id DESC LIMIT ?, ?"
 108 #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 = ?)) ORDER BY sticker_info_id DESC LIMIT ?, ?"
 109 #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 = ?))"
 110 #define STICKER_DB_CHECK_FILE_EXISTS "SELECT EXISTS(SELECT 1 FROM sticker_info WHERE uri = ? LIMIT 1)"
 111 #define STICKER_DB_CHECK_RECENT_HISTORY_EXISTS "SELECT EXISTS(SELECT 1 FROM sticker_recent_history_info WHERE sticker_info_id = ? LIMIT 1)"
 112 #define STICKER_DB_GET_RECENT_HISTORY "SELECT sticker_info_id FROM sticker_recent_history_info ORDER BY datetime(timestamp) DESC LIMIT ?"
 113 #define STICKER_DB_GET_STICKER_INFO_BY_URI "SELECT * FROM sticker_info WHERE uri = ?"
 114 #define STICKER_DB_CHECK_GROUP_EXISTS_IN_STICKER_INFO "SELECT EXISTS(SELECT 1 FROM sticker_info WHERE group_name = ? AND app_id = ? LIMIT 1)"
 115 #define STICKER_DB_CHECK_GROUP_EXISTS_IN_GROUP_INFO "SELECT EXISTS(SELECT 1 FROM sticker_group_info WHERE group_name = ? AND app_id = ? LIMIT 1)"
 116 #define STICKER_DB_GET_ALL_GROUP_IMAGE_LIST "SELECT group_name, type, uri FROM sticker_group_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 = ?))"
 117
 118 typedef enum
 119 {
 120     CMD_UPDATE,
 121     CMD_SELECT,
 122 } command_type;
 123
 124 static gboolean is_corrupted = FALSE;
 125
 126 static const char *_db_get_query(sticker_info_db_type sticker_type, command_type cmd_type)
 127 {
 128     static const char* query = NULL;
 129
 130     if (cmd_type == CMD_UPDATE) {
 131         switch(sticker_type) {
 132             case STICKER_DB_STICKER_TYPE:
 133             query = STICKER_DB_UPDATE_STICKER_TYPE;
 134             break;
 135             case STICKER_DB_STICKER_URI:
 136             query = STICKER_DB_UPDATE_STICKER_URI;
 137             break;
 138             case STICKER_DB_STICKER_THUMBNAIL:
 139             query = STICKER_DB_UPDATE_STICKER_THUMBNAIL;
 140             break;
 141             case STICKER_DB_STICKER_DESCRIPTION:
 142             query = STICKER_DB_UPDATE_STICKER_DESCRIPTION;
 143             break;
 144             case STICKER_DB_STICKER_GROUP:
 145             query = STICKER_DB_UPDATE_STICKER_GROUP;
 146             break;
 147             case STICKER_DB_STICKER_KEYWORD:
 148             query = STICKER_DB_DELETE_STICKER_KEYWORD_INFO;
 149             break;
 150             case STICKER_DB_STICKER_DISP_TYPE:
 151             query = STICKER_DB_UPDATE_STICKER_DISP_TYPE;
 152             break;
 153             default :
 154             query = "";
 155             break;
 156         }
 157     } else if (cmd_type == CMD_SELECT) {
 158         switch(sticker_type) {
 159             case STICKER_DB_STICKER_ALL:
 160             query = STICKER_DB_GET_ALL_RECORD_ID;
 161             break;
 162             case STICKER_DB_STICKER_APPID:
 163             query = STICKER_DB_GET_RECORD_ID_BY_APP_ID;
 164             break;
 165             case STICKER_DB_STICKER_TYPE:
 166             query = STICKER_DB_GET_RECORD_ID_BY_TYPE;
 167             break;
 168             case STICKER_DB_STICKER_GROUP:
 169             query = STICKER_DB_GET_RECORD_ID_BY_GROUP;
 170             break;
 171             case STICKER_DB_STICKER_KEYWORD:
 172             query = STICKER_DB_GET_RECORD_ID_BY_KEYWORD;
 173             break;
 174             case STICKER_DB_STICKER_DISP_TYPE:
 175             query = STICKER_DB_GET_RECORD_ID_BY_DISP_TYPE;
 176             break;
 177             case STICKER_DB_STICKER_RECENT_HISTORY:
 178             query = STICKER_DB_GET_RECENT_HISTORY;
 179             break;
 180             default :
 181             query = "";
 182             break;
 183         }
 184     }
 185
 186     return query;
 187 }
 188
 189 static int _create_db_table(sqlite3 *db)
 190 {
 191     char *err = NULL;
 192     int ret = STICKERD_SERVER_ERROR_NONE;
 193
 194     ret = sqlite3_exec(db, STICKER_INFO_CREATE_TABLE, NULL, NULL, &err);
 195     if (ret != SQLITE_OK) {
 196         LOGE("Failed to create sticker_info table : %s" , err);
 197         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 198         goto cleanup;
 199     }
 200
 201     ret = sqlite3_exec(db, STICKER_KEYWORD_INFO_CREATE_TABLE, NULL, NULL, &err);
 202     if (ret != SQLITE_OK) {
 203         LOGE("Failed to create sticker_keyword_info table : %s", err);
 204         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 205         goto cleanup;
 206     }
 207
 208     ret = sqlite3_exec(db, STICKER_WHITELIST_INFO_CREATE_TABLE, NULL, NULL, &err);
 209     if (ret != SQLITE_OK) {
 210         LOGE("Failed to create sticker_whitelist_info table : %s", err);
 211         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 212         goto cleanup;
 213     }
 214
 215     ret = sqlite3_exec(db, STICKER_RECENT_HISTORY_INFO_CREATE_TABLE, NULL, NULL, &err);
 216     if (ret != SQLITE_OK) {
 217         LOGE("Failed to create sticker_recent_history_info table : %s", err);
 218         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 219         goto cleanup;
 220     }
 221
 222     ret = sqlite3_exec(db, STICKER_GROUP_INFO_CREATE_TABLE, NULL, NULL, &err);
 223     if (ret != SQLITE_OK) {
 224         LOGE("Failed to create sticker_group_info table : %s", err);
 225         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 226     }
 227
 228 cleanup:
 229     if (err)
 230         sqlite3_free(err);
 231
 232     return ret;
 233 }
 234
 235 static int _recover_db(void)
 236 {
 237     int ret = STICKERD_SERVER_ERROR_NONE;
 238     sqlite3 *db = NULL;
 239
 240     LOGD("Start to recover sticker db");
 241     //Remove sticker database file
 242     if (unlink(STICKER_DB_PATH) == -1)
 243         LOGE("Failed to remove db file");
 244
 245     ret = sqlite3_open_v2(STICKER_DB_PATH, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
 246     if (ret != SQLITE_OK) {
 247         LOGE("Failed to open db : %s", sqlite3_errmsg(db));
 248         if (unlink(STICKER_DB_PATH) == -1)
 249             LOGE("Failed to remove db file");
 250         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 251         goto cleanup;
 252     }
 253
 254     ret = _create_db_table(db);
 255     if (ret != SQLITE_OK)
 256         goto cleanup;
 257
 258     is_corrupted = FALSE;
 259
 260 cleanup:
 261     if (db)
 262         sqlite3_close(db);
 263
 264     return ret;
 265 }
 266
 267 static int _integrity_check_cb(void *pid, int argc, char **argv, char **notUsed)
 268 {
 269     if (strcmp(argv[0], "ok") != 0) {
 270         LOGE("DB integrity check failed : %s", argv[0]);
 271         is_corrupted = TRUE;
 272         return -1;
 273     }
 274
 275     LOGD("Result integrity : %s", argv[0]);
 276     return 0;
 277 }
 278
 279 int stickerd_db_init(void)
 280 {
 281     int ret = STICKERD_SERVER_ERROR_NONE;
 282     sqlite3 *db = NULL;
 283     char *err = NULL;
 284
 285     ret = sqlite3_open_v2(STICKER_DB_PATH, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
 286     if (ret != SQLITE_OK) {
 287         LOGE("Failed to open db : %s", sqlite3_errmsg(db));
 288         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 289         goto cleanup;
 290     }
 291
 292     ret = _create_db_table(db);
 293     if (ret != SQLITE_OK)
 294         goto cleanup;
 295
 296     ret = sqlite3_exec(db, "PRAGMA journal_mode = WAL", NULL, NULL, &err);
 297     if (ret != SQLITE_OK) {
 298         LOGE("Failed to set journal_mode : %s", err);
 299         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 300         goto cleanup;
 301     }
 302
 303     ret = sqlite3_exec(db, "PRAGMA integrity_check", _integrity_check_cb, NULL, &err);
 304     if (ret != SQLITE_OK) {
 305         LOGE("Failed to check integrity : %s", err);
 306         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 307     }
 308
 309 cleanup:
 310     if (err)
 311         sqlite3_free(err);
 312
 313     if (db)
 314         sqlite3_close(db);
 315
 316     if (ret == SQLITE_CORRUPT || ret == SQLITE_NOTADB || is_corrupted)
 317         ret = _recover_db();
 318
 319     return ret;
 320 }
 321
 322 static sqlite3 *_db_open(void)
 323 {
 324     int ret;
 325     sqlite3 *db = NULL;
 326     char *err = NULL;
 327
 328     if (is_corrupted && _recover_db() != SQLITE_OK)
 329         return NULL;
 330
 331     ret = sqlite3_open(STICKER_DB_PATH, &db);
 332     if (ret != SQLITE_OK) {
 333         LOGE("Failed to open db : %s", sqlite3_errmsg(db));
 334         return NULL;
 335     }
 336
 337     ret = sqlite3_exec(db, "PRAGMA foreign_keys = ON", NULL, NULL, &err);
 338     if (ret != SQLITE_OK) {
 339         LOGE("Failed to turn on foreign keys : %s", err);
 340     }
 341
 342     if (err)
 343         sqlite3_free(err);
 344
 345     return db;
 346 }
 347
 348 static gboolean _check_group_exists(char *app_id, char *group)
 349 {
 350     int ret;
 351     gboolean result = FALSE;
 352     sqlite3 *db = NULL;
 353     sqlite3_stmt *stmt = NULL;
 354
 355     db = _db_open();
 356     if (!db)
 357         return FALSE;
 358
 359     ret = sqlite3_prepare_v2(db, STICKER_DB_CHECK_GROUP_EXISTS_IN_GROUP_INFO, -1, &stmt, NULL);
 360     if (ret != SQLITE_OK) {
 361         LOGE("fail to check group exists : %s", sqlite3_errmsg(db));
 362         goto cleanup;
 363     }
 364
 365     sqlite3_bind_text(stmt, 1, group, -1, SQLITE_TRANSIENT);
 366     sqlite3_bind_text(stmt, 2, app_id, -1, SQLITE_TRANSIENT);
 367
 368     ret = sqlite3_step(stmt);
 369     if (ret == SQLITE_ERROR) {
 370         LOGE("sqlite3_step() failed : ret(%d)", ret);
 371         goto cleanup;
 372     }
 373
 374     result = sqlite3_column_int(stmt, 0);
 375
 376     sqlite3_finalize(stmt);
 377     sqlite3_close(db);
 378
 379     return result;
 380
 381 cleanup:
 382     sqlite3_finalize(stmt);
 383     sqlite3_close(db);
 384
 385     return FALSE;
 386 }
 387
 388 int stickerd_db_insert_sticker_info(int *record_id, sticker_info_db *sticker_info)
 389 {
 390     int ret;
 391     sqlite3 *db = NULL;
 392     sqlite3_stmt *stmt = NULL;
 393
 394     db = _db_open();
 395     if (!db)
 396         return STICKERD_SERVER_ERROR_DB_FAILED;
 397
 398     ret = sqlite3_prepare_v2(db, STICKER_DB_INSERT_STICKER_INFO, -1, &stmt, NULL);
 399     if (ret != SQLITE_OK) {
 400         LOGE("fail to insert sticker information : %s", sqlite3_errmsg(db));
 401         goto cleanup;
 402     }
 403
 404     sqlite3_bind_text(stmt, 1, sticker_info->app_id, -1, SQLITE_TRANSIENT);
 405     sqlite3_bind_int(stmt, 2, sticker_info->type);
 406     sqlite3_bind_text(stmt, 3, sticker_info->uri, -1, SQLITE_TRANSIENT);
 407     sqlite3_bind_text(stmt, 4, sticker_info->thumbnail, -1, SQLITE_TRANSIENT);
 408     sqlite3_bind_text(stmt, 5, sticker_info->description, -1, SQLITE_TRANSIENT);
 409     sqlite3_bind_text(stmt, 6, sticker_info->group, -1, SQLITE_TRANSIENT);
 410     sqlite3_bind_int(stmt, 7, sticker_info->display_type);
 411
 412     ret = sqlite3_step(stmt);
 413     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 414         LOGE("sqlite3_step() failed : ret(%d)", ret);
 415         goto cleanup;
 416     } else if (sqlite3_changes(db) == 0) {
 417         LOGE("No changes to DB");
 418         goto cleanup;
 419     }
 420
 421     sqlite3_finalize(stmt);
 422     stmt = NULL;
 423
 424     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_LATEST_RECORD_ID, -1, &stmt, NULL);
 425     if (ret != SQLITE_OK) {
 426         LOGE("fail to get sticker id : %s", sqlite3_errmsg(db));
 427         goto cleanup;
 428     }
 429
 430     ret = sqlite3_step(stmt);
 431     if (ret == SQLITE_ERROR) {
 432         LOGE("sqlite3_step() failed : ret(%d)", ret);
 433         *record_id = 0;
 434         goto cleanup;
 435     } else {
 436         *record_id = sqlite3_column_int(stmt, 0);
 437         LOGD("record_id : %d", *record_id);
 438     }
 439
 440     GList *list;
 441     for(list = sticker_info->keyword; list != NULL; list=list->next) {
 442         sqlite3_finalize(stmt);
 443         stmt = NULL;
 444
 445         ret = sqlite3_prepare_v2(db, STICKER_DB_INSERT_STICKER_KEYWORD_INFO, -1, &stmt, NULL);
 446         if (ret != SQLITE_OK) {
 447             LOGE("fail to insert sticker keyword : %s", sqlite3_errmsg(db));
 448             goto cleanup;
 449         }
 450
 451         sqlite3_bind_int(stmt, 1, *record_id);
 452         sqlite3_bind_text(stmt, 2, (char *)list->data, -1, SQLITE_TRANSIENT);
 453
 454         ret = sqlite3_step(stmt);
 455         if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 456             LOGE("sqlite3_step() failed : ret(%d)", ret);
 457             goto cleanup;
 458         } else if (sqlite3_changes(db) == 0) {
 459             LOGE("No changes to DB");
 460             goto cleanup;
 461         }
 462     }
 463
 464     sqlite3_finalize(stmt);
 465     sqlite3_close(db);
 466
 467     return STICKERD_SERVER_ERROR_NONE;
 468
 469 cleanup:
 470     sqlite3_finalize(stmt);
 471     sqlite3_close(db);
 472
 473     return STICKERD_SERVER_ERROR_DB_FAILED;
 474 }
 475
 476 int stickerd_db_delete_sticker_info(int record_id)
 477 {
 478     int ret;
 479     int uri_type = 0;
 480     sqlite3 *db = NULL;
 481     sqlite3_stmt *stmt = NULL;
 482     const unsigned char *uri = NULL;
 483     const unsigned char *thumbnail = NULL;
 484
 485     db = _db_open();
 486     if (!db)
 487         return STICKERD_SERVER_ERROR_DB_FAILED;
 488
 489     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_IMAGE_INFO_BY_RECORD_ID, -1, &stmt, NULL);
 490     if (ret != SQLITE_OK) {
 491         LOGE("fail to get image files : %s", sqlite3_errmsg(db));
 492         goto cleanup;
 493     }
 494
 495     sqlite3_bind_int(stmt, 1, record_id);
 496
 497     ret = sqlite3_step(stmt);
 498     if (ret == SQLITE_ERROR) {
 499         LOGE("sqlite3_step() failed : ret(%d)", ret);
 500         goto cleanup;
 501     }
 502
 503     uri_type = sqlite3_column_int(stmt, 0);
 504     uri = sqlite3_column_text(stmt, 1);
 505     thumbnail = sqlite3_column_text(stmt, 2);
 506
 507     if (uri_type == 1 && uri && unlink((const char *)uri) == -1)
 508         LOGE("fail to delete sticker file");
 509
 510     if (thumbnail && unlink((const char *)thumbnail) == -1)
 511         LOGE("fail to delete thumbnail image");
 512
 513     sqlite3_finalize(stmt);
 514     stmt = NULL;
 515
 516     ret = sqlite3_prepare_v2(db, STICKER_DB_DELETE_STICKER_INFO, -1, &stmt, NULL);
 517     if (ret != SQLITE_OK) {
 518         LOGE("fail to delete sticker information : %s", sqlite3_errmsg(db));
 519         goto cleanup;
 520     }
 521
 522     sqlite3_bind_int(stmt, 1, record_id);
 523
 524     ret = sqlite3_step(stmt);
 525     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 526         LOGE("sqlite3_step() failed : ret(%d)", ret);
 527         goto cleanup;
 528     } else if (sqlite3_changes(db) == 0) {
 529         LOGE("No changes to DB");
 530         goto cleanup;
 531     }
 532
 533     sqlite3_finalize(stmt);
 534     sqlite3_close(db);
 535
 536     return STICKERD_SERVER_ERROR_NONE;
 537
 538 cleanup:
 539     sqlite3_finalize(stmt);
 540     sqlite3_close(db);
 541
 542     return STICKERD_SERVER_ERROR_DB_FAILED;
 543 }
 544
 545 int stickerd_db_delete_sticker_info_by_uri(char *uri)
 546 {
 547     int ret;
 548     sqlite3 *db = NULL;
 549     sqlite3_stmt *stmt = NULL;
 550
 551     int uri_type = 0;
 552     const unsigned char *thumbnail = NULL;
 553
 554     db = _db_open();
 555     if (!db)
 556         return STICKERD_SERVER_ERROR_DB_FAILED;
 557
 558     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_IMAGE_INFO_BY_URI, -1, &stmt, NULL);
 559     if (ret != SQLITE_OK) {
 560         LOGE("fail to delete sticker information : %s", sqlite3_errmsg(db));
 561         goto cleanup;
 562     }
 563
 564     sqlite3_bind_text(stmt, 1, uri, -1, SQLITE_TRANSIENT);
 565
 566     ret = sqlite3_step(stmt);
 567     if (ret == SQLITE_ERROR) {
 568         LOGE("sqlite3_step() failed : ret(%d)", ret);
 569         goto cleanup;
 570     }
 571
 572     uri_type = sqlite3_column_int(stmt, 0);
 573     thumbnail = sqlite3_column_text(stmt, 1);
 574
 575     if (uri_type == 1 && unlink((const char *)uri) == -1)
 576         LOGE("fail to delete sticker file");
 577
 578     if (thumbnail && unlink((const char *)thumbnail) == -1)
 579         LOGE("fail to delete thumbnail image");
 580
 581     sqlite3_finalize(stmt);
 582     stmt = NULL;
 583
 584     ret = sqlite3_prepare_v2(db, STICKER_DB_DELETE_STICKER_INFO_BY_URI, -1, &stmt, NULL);
 585     if (ret != SQLITE_OK) {
 586         LOGE("fail to delete sticker information : %s", sqlite3_errmsg(db));
 587         goto cleanup;
 588     }
 589
 590     sqlite3_bind_text(stmt, 1, uri, -1, SQLITE_TRANSIENT);
 591
 592     ret = sqlite3_step(stmt);
 593     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 594         LOGE("sqlite3_step() failed : ret(%d)", ret);
 595         goto cleanup;
 596     } else if (sqlite3_changes(db) == 0) {
 597         LOGE("No changes to DB");
 598         goto cleanup;
 599     }
 600
 601     sqlite3_finalize(stmt);
 602     sqlite3_close(db);
 603
 604     return STICKERD_SERVER_ERROR_NONE;
 605
 606 cleanup:
 607     sqlite3_finalize(stmt);
 608     sqlite3_close(db);
 609
 610     return STICKERD_SERVER_ERROR_DB_FAILED;
 611 }
 612
 613 int stickerd_db_update_sticker_info(int record_id, sticker_info_db_type type, void *data)
 614 {
 615     int ret;
 616     sqlite3 *db = NULL;
 617     sqlite3_stmt *stmt = NULL;
 618
 619     db = _db_open();
 620     if (!db)
 621         return STICKERD_SERVER_ERROR_DB_FAILED;
 622
 623     const char* query = _db_get_query(type, CMD_UPDATE);
 624     ret = sqlite3_prepare_v2(db, query, -1, &stmt, NULL);
 625     if (ret != SQLITE_OK) {
 626         LOGE("fail to update sticker information : %s", sqlite3_errmsg(db));
 627         goto cleanup;
 628     }
 629
 630     if (type == STICKER_DB_STICKER_TYPE || type == STICKER_DB_STICKER_DISP_TYPE) {
 631         sqlite3_bind_int(stmt, 1, *(int *)data);
 632     } else if (type == STICKER_DB_STICKER_KEYWORD) {
 633         sqlite3_bind_int(stmt, 1, record_id);
 634     } else {
 635         sqlite3_bind_text(stmt, 1, (char *)data, -1, SQLITE_TRANSIENT);
 636     }
 637
 638     if (type != STICKER_DB_STICKER_KEYWORD)
 639         sqlite3_bind_int(stmt, 2, record_id);
 640
 641     ret = sqlite3_step(stmt);
 642     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 643         LOGE("sqlite3_step() failed : ret(%d)", ret);
 644         goto cleanup;
 645     }
 646
 647     if (type == STICKER_DB_STICKER_KEYWORD) {
 648         GList *list;
 649         for(list = (GList *)data; list != NULL; list=list->next) {
 650             sqlite3_finalize(stmt);
 651             stmt = NULL;
 652
 653             ret = sqlite3_prepare_v2(db, STICKER_DB_INSERT_STICKER_KEYWORD_INFO, -1, &stmt, NULL);
 654             if (ret != SQLITE_OK) {
 655                 LOGE("fail to insert sticker information : %s", sqlite3_errmsg(db));
 656                 goto cleanup;
 657             }
 658
 659             sqlite3_bind_int(stmt, 1, record_id);
 660             sqlite3_bind_text(stmt, 2, (char *)list->data, -1, SQLITE_TRANSIENT);
 661
 662             ret = sqlite3_step(stmt);
 663             if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 664                 LOGE("sqlite3_step() failed : ret(%d)", ret);
 665                 goto cleanup;
 666             } else if (sqlite3_changes(db) == 0) {
 667                 LOGE("No changes to DB");
 668                 goto cleanup;
 669             }
 670         }
 671     }
 672
 673     sqlite3_finalize(stmt);
 674     sqlite3_close(db);
 675
 676     return STICKERD_SERVER_ERROR_NONE;
 677
 678 cleanup:
 679     sqlite3_finalize(stmt);
 680     sqlite3_close(db);
 681
 682     return STICKERD_SERVER_ERROR_DB_FAILED;
 683 }
 684
 685 int stickerd_db_get_sticker_info_by_record_id(int record_id, sticker_info_db *sticker_info)
 686 {
 687     int ret;
 688     sqlite3 *db = NULL;
 689     sqlite3_stmt *stmt = NULL;
 690
 691     const unsigned char *tmp_app_id = NULL;
 692     const unsigned char *tmp_uri = NULL;
 693     const unsigned char *tmp_thumbnail = NULL;
 694     const unsigned char *tmp_description = NULL;
 695     const unsigned char *tmp_group = NULL;
 696     const unsigned char *tmp_date = NULL;
 697
 698     db = _db_open();
 699     if (!db)
 700         return STICKERD_SERVER_ERROR_DB_FAILED;
 701
 702     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_STICKER_INFO_BY_RECORD_ID, -1, &stmt, NULL);
 703     if (ret != SQLITE_OK) {
 704         LOGE("fail to get sticker information : %s", sqlite3_errmsg(db));
 705         goto cleanup;
 706     }
 707
 708     sqlite3_bind_int(stmt, 1, record_id);
 709
 710     ret = sqlite3_step(stmt);
 711     if (ret == SQLITE_ERROR) {
 712         LOGE("sqlite3_step() failed : ret(%d)", ret);
 713         goto cleanup;
 714     }
 715
 716     tmp_app_id = sqlite3_column_text(stmt, 1);
 717     if (tmp_app_id) {
 718         sticker_info->app_id = strdup((const char *)tmp_app_id);
 719     } else {
 720         LOGW("invalid record_id : %d", record_id);
 721         goto cleanup;
 722     }
 723
 724     sticker_info->type = sqlite3_column_int(stmt, 2);
 725
 726     tmp_uri = sqlite3_column_text(stmt, 3);
 727     if (tmp_uri)
 728         sticker_info->uri = strdup((const char *)tmp_uri);
 729
 730     tmp_thumbnail = sqlite3_column_text(stmt, 4);
 731     if (tmp_thumbnail)
 732         sticker_info->thumbnail = strdup((const char *)tmp_thumbnail);
 733
 734     tmp_description = sqlite3_column_text(stmt, 5);
 735     if (tmp_description)
 736         sticker_info->description = strdup((const char *)tmp_description);
 737
 738     tmp_group = sqlite3_column_text(stmt, 6);
 739     if (tmp_group)
 740         sticker_info->group = strdup((const char *)tmp_group);
 741
 742     tmp_date = sqlite3_column_text(stmt, 7);
 743     if (tmp_date)
 744         sticker_info->date = strdup((const char *)tmp_date);
 745
 746     sticker_info->display_type = sqlite3_column_int(stmt, 8);
 747
 748     sqlite3_finalize(stmt);
 749     stmt = NULL;
 750
 751     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_KEYWORD_INFO_BY_RECORD_ID, -1, &stmt, NULL);
 752     if (ret != SQLITE_OK) {
 753         LOGE("fail to get sticker keyword : %s", sqlite3_errmsg(db));
 754         goto cleanup;
 755     }
 756
 757     sqlite3_bind_int(stmt, 1, record_id);
 758
 759     while (sqlite3_step(stmt) == SQLITE_ROW) {
 760         const unsigned char *keyword = sqlite3_column_text(stmt, 0);
 761         if (keyword)
 762             sticker_info->keyword = g_list_append(sticker_info->keyword, strdup((const char *)keyword));
 763     }
 764
 765     sqlite3_finalize(stmt);
 766     sqlite3_close(db);
 767
 768     return STICKERD_SERVER_ERROR_NONE;
 769
 770 cleanup:
 771     sqlite3_finalize(stmt);
 772     sqlite3_close(db);
 773
 774     return STICKERD_SERVER_ERROR_DB_FAILED;
 775 }
 776
 777 int stickerd_db_get_group_list(GVariantBuilder *builder, char *app_id)
 778 {
 779     int ret;
 780     sqlite3 *db = NULL;
 781     sqlite3_stmt *stmt = NULL;
 782
 783     db = _db_open();
 784     if (!db)
 785         return STICKERD_SERVER_ERROR_DB_FAILED;
 786
 787     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_ALL_GROUP_LIST, -1, &stmt, NULL);
 788     if (ret != SQLITE_OK) {
 789         LOGE("fail to get group list : %s", sqlite3_errmsg(db));
 790         goto cleanup;
 791     }
 792
 793     sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
 794
 795     while (sqlite3_step(stmt) == SQLITE_ROW) {
 796         const unsigned char *group = sqlite3_column_text(stmt, 0);
 797         if (group)
 798             g_variant_builder_add(builder, "(s)", strdup((const char *)group));
 799     }
 800
 801     sqlite3_finalize(stmt);
 802     sqlite3_close(db);
 803
 804     return STICKERD_SERVER_ERROR_NONE;
 805
 806 cleanup:
 807     sqlite3_finalize(stmt);
 808     sqlite3_close(db);
 809
 810     return STICKERD_SERVER_ERROR_DB_FAILED;
 811 }
 812
 813 int stickerd_db_get_keyword_list(GVariantBuilder *builder, char *app_id)
 814 {
 815     int ret;
 816     sqlite3 *db = NULL;
 817     sqlite3_stmt *stmt = NULL;
 818
 819     db = _db_open();
 820     if (!db)
 821         return STICKERD_SERVER_ERROR_DB_FAILED;
 822
 823     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_ALL_KEYWORD_LIST, -1, &stmt, NULL);
 824     if (ret != SQLITE_OK) {
 825         LOGE("fail to get keyword list : %s", sqlite3_errmsg(db));
 826         goto cleanup;
 827     }
 828
 829     sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
 830
 831     while (sqlite3_step(stmt) == SQLITE_ROW) {
 832         const unsigned char *keyword = sqlite3_column_text(stmt, 0);
 833         if (keyword)
 834             g_variant_builder_add(builder, "(s)", strdup((const char *)keyword));
 835     }
 836
 837     sqlite3_finalize(stmt);
 838     sqlite3_close(db);
 839
 840     return STICKERD_SERVER_ERROR_NONE;
 841
 842 cleanup:
 843     sqlite3_finalize(stmt);
 844     sqlite3_close(db);
 845
 846     return STICKERD_SERVER_ERROR_DB_FAILED;
 847 }
 848
 849 int stickerd_db_get_sticker_count(int *count, char *app_id)
 850 {
 851     int ret;
 852     sqlite3 *db = NULL;
 853     sqlite3_stmt *stmt = NULL;
 854
 855     db = _db_open();
 856     if (!db)
 857         return STICKERD_SERVER_ERROR_DB_FAILED;
 858
 859     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_STICKER_COUNT, -1, &stmt, NULL);
 860     if (ret != SQLITE_OK) {
 861         LOGE("fail to get sticker count : %s", sqlite3_errmsg(db));
 862         goto cleanup;
 863     }
 864
 865     sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
 866
 867     ret = sqlite3_step(stmt);
 868     if (ret == SQLITE_ERROR) {
 869         LOGE("sqlite3_step() failed : ret(%d)", ret);
 870         goto cleanup;
 871     }
 872
 873     *count = sqlite3_column_int(stmt, 0);
 874
 875     sqlite3_finalize(stmt);
 876     sqlite3_close(db);
 877
 878     return STICKERD_SERVER_ERROR_NONE;
 879
 880 cleanup:
 881     sqlite3_finalize(stmt);
 882     sqlite3_close(db);
 883
 884     return STICKERD_SERVER_ERROR_DB_FAILED;
 885 }
 886
 887 int stickerd_db_get_record_id(sticker_info_db_type type, GList **id_list, void *data, char *app_id, int offset, int count)
 888 {
 889     int ret;
 890     sqlite3 *db = NULL;
 891     sqlite3_stmt *stmt = NULL;
 892
 893     db = _db_open();
 894     if (!db)
 895         return STICKERD_SERVER_ERROR_DB_FAILED;
 896
 897     const char* query = _db_get_query(type, CMD_SELECT);
 898     ret = sqlite3_prepare_v2(db, query, -1, &stmt, NULL);
 899     if (ret != SQLITE_OK) {
 900         LOGE("fail to get record id : %s", sqlite3_errmsg(db));
 901         goto cleanup;
 902     }
 903
 904     if (type == STICKER_DB_STICKER_ALL || type == STICKER_DB_STICKER_APPID) {
 905         sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
 906         sqlite3_bind_int(stmt, 2, offset);
 907         sqlite3_bind_int(stmt, 3, count);
 908     } else if (type == STICKER_DB_STICKER_RECENT_HISTORY) {
 909         sqlite3_bind_int(stmt, 1, count);
 910     } else {
 911         if (type == STICKER_DB_STICKER_TYPE || type == STICKER_DB_STICKER_DISP_TYPE)
 912             sqlite3_bind_int(stmt, 1, *(int *)data);
 913         else
 914             sqlite3_bind_text(stmt, 1, (char *)data, -1, SQLITE_TRANSIENT);
 915
 916         sqlite3_bind_text(stmt, 2, app_id, -1, SQLITE_TRANSIENT);
 917         sqlite3_bind_int(stmt, 3, offset);
 918         sqlite3_bind_int(stmt, 4, count);
 919     }
 920
 921     while (sqlite3_step(stmt) == SQLITE_ROW) {
 922         const unsigned char *tmp_id = sqlite3_column_text(stmt, 0);
 923         if (tmp_id)
 924             *id_list = g_list_append(*id_list, strdup((const char *)tmp_id));
 925     }
 926
 927     sqlite3_finalize(stmt);
 928     sqlite3_close(db);
 929
 930     return STICKERD_SERVER_ERROR_NONE;
 931
 932 cleanup:
 933     sqlite3_finalize(stmt);
 934     sqlite3_close(db);
 935
 936     return STICKERD_SERVER_ERROR_DB_FAILED;
 937 }
 938
 939 int stickerd_db_get_group_list_by_display_type(GVariantBuilder *builder, char *app_id, int disp_type)
 940 {
 941     int ret;
 942     sqlite3 *db = NULL;
 943     sqlite3_stmt *stmt = NULL;
 944
 945     db = _db_open();
 946     if (!db)
 947         return STICKERD_SERVER_ERROR_DB_FAILED;
 948
 949     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_GROUP_LIST_BY_DISP_TYPE, -1, &stmt, NULL);
 950     if (ret != SQLITE_OK) {
 951         LOGE("fail to get group list : %s", sqlite3_errmsg(db));
 952         goto cleanup;
 953     }
 954
 955     sqlite3_bind_int(stmt, 1, disp_type);
 956     sqlite3_bind_text(stmt, 2, app_id, -1, SQLITE_TRANSIENT);
 957
 958     while (sqlite3_step(stmt) == SQLITE_ROW) {
 959         const unsigned char *group = sqlite3_column_text(stmt, 0);
 960         if (group)
 961             g_variant_builder_add(builder, "(s)", strdup((const char *)group));
 962     }
 963
 964     sqlite3_finalize(stmt);
 965     sqlite3_close(db);
 966
 967     return STICKERD_SERVER_ERROR_NONE;
 968
 969 cleanup:
 970     sqlite3_finalize(stmt);
 971     sqlite3_close(db);
 972
 973     return STICKERD_SERVER_ERROR_DB_FAILED;
 974 }
 975
 976 int stickerd_db_check_file_exists(int *result, char *uri)
 977 {
 978     int ret;
 979     sqlite3 *db = NULL;
 980     sqlite3_stmt *stmt = NULL;
 981
 982     db = _db_open();
 983     if (!db)
 984         return STICKERD_SERVER_ERROR_DB_FAILED;
 985
 986     ret = sqlite3_prepare_v2(db, STICKER_DB_CHECK_FILE_EXISTS, -1, &stmt, NULL);
 987     if (ret != SQLITE_OK) {
 988         LOGE("fail to check file exists : %s", sqlite3_errmsg(db));
 989         goto cleanup;
 990     }
 991
 992     sqlite3_bind_text(stmt, 1, uri, -1, SQLITE_TRANSIENT);
 993
 994     ret = sqlite3_step(stmt);
 995     if (ret == SQLITE_ERROR) {
 996         LOGE("sqlite3_step() failed : ret(%d)", ret);
 997         goto cleanup;
 998     }
 999
1000     *result = sqlite3_column_int(stmt, 0);
1001
1002     sqlite3_finalize(stmt);
1003     sqlite3_close(db);
1004
1005     return STICKERD_SERVER_ERROR_NONE;
1006
1007 cleanup:
1008     sqlite3_finalize(stmt);
1009     sqlite3_close(db);
1010
1011     return STICKERD_SERVER_ERROR_DB_FAILED;
1012 }
1013
1014 int stickerd_db_insert_recent_sticker_info(int record_id)
1015 {
1016     int ret;
1017     sqlite3 *db = NULL;
1018     sqlite3_stmt *stmt = NULL;
1019     int result = 0;
1020
1021     db = _db_open();
1022     if (!db)
1023         return STICKERD_SERVER_ERROR_DB_FAILED;
1024
1025     ret = sqlite3_prepare_v2(db, STICKER_DB_CHECK_RECENT_HISTORY_EXISTS, -1, &stmt, NULL);
1026     if (ret != SQLITE_OK) {
1027         LOGE("fail to check recent sticker exists : %s", sqlite3_errmsg(db));
1028         goto cleanup;
1029     }
1030
1031     sqlite3_bind_int(stmt, 1, record_id);
1032
1033     ret = sqlite3_step(stmt);
1034     if (ret == SQLITE_ERROR) {
1035         LOGE("sqlite3_step() failed : ret(%d)", ret);
1036         goto cleanup;
1037     }
1038
1039     result = sqlite3_column_int(stmt, 0);
1040
1041     sqlite3_finalize(stmt);
1042     stmt = NULL;
1043
1044     if (result)
1045         ret = sqlite3_prepare_v2(db, STICKER_DB_UPDATE_RECENT_HISTORY, -1, &stmt, NULL);
1046     else
1047         ret = sqlite3_prepare_v2(db, STICKER_DB_INSERT_RECENT_HISTORY, -1, &stmt, NULL);
1048
1049     if (ret != SQLITE_OK) {
1050         LOGE("fail to update recent history : %s", sqlite3_errmsg(db));
1051         goto cleanup;
1052     }
1053
1054     sqlite3_bind_int(stmt, 1, record_id);
1055
1056     ret = sqlite3_step(stmt);
1057     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
1058         LOGE("sqlite3_step() failed : ret(%d)", ret);
1059         goto cleanup;
1060     } else if (sqlite3_changes(db) == 0) {
1061         LOGE("No changes to DB");
1062         goto cleanup;
1063     }
1064
1065     sqlite3_finalize(stmt);
1066     sqlite3_close(db);
1067
1068     return STICKERD_SERVER_ERROR_NONE;
1069
1070 cleanup:
1071     sqlite3_finalize(stmt);
1072     sqlite3_close(db);
1073
1074     return STICKERD_SERVER_ERROR_DB_FAILED;
1075 }
1076
1077 int stickerd_db_get_sticker_info_by_uri(char *uri, sticker_info_db *sticker_info)
1078 {
1079     int ret;
1080     sqlite3 *db = NULL;
1081     sqlite3_stmt *stmt = NULL;
1082
1083     const unsigned char *tmp_app_id = NULL;
1084     const unsigned char *tmp_uri = NULL;
1085     const unsigned char *tmp_thumbnail = NULL;
1086     const unsigned char *tmp_description = NULL;
1087     const unsigned char *tmp_group = NULL;
1088     const unsigned char *tmp_date = NULL;
1089
1090     db = _db_open();
1091     if (!db)
1092         return STICKERD_SERVER_ERROR_DB_FAILED;
1093
1094     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_STICKER_INFO_BY_URI, -1, &stmt, NULL);
1095     if (ret != SQLITE_OK) {
1096         LOGE("fail to get sticker information : %s", sqlite3_errmsg(db));
1097         goto cleanup;
1098     }
1099
1100     sqlite3_bind_text(stmt, 1, uri, -1, SQLITE_TRANSIENT);
1101
1102     ret = sqlite3_step(stmt);
1103     if (ret == SQLITE_ERROR) {
1104         LOGE("sqlite3_step() failed : ret(%d)", ret);
1105         goto cleanup;
1106     }
1107
1108     sticker_info->record_id = sqlite3_column_int(stmt, 0);
1109
1110     tmp_app_id = sqlite3_column_text(stmt, 1);
1111     if (tmp_app_id)
1112         sticker_info->app_id = strdup((const char *)tmp_app_id);
1113
1114     sticker_info->type = sqlite3_column_int(stmt, 2);
1115
1116     tmp_uri = sqlite3_column_text(stmt, 3);
1117     if (tmp_uri)
1118         sticker_info->uri = strdup((const char *)tmp_uri);
1119
1120     tmp_thumbnail = sqlite3_column_text(stmt, 4);
1121     if (tmp_thumbnail)
1122         sticker_info->thumbnail = strdup((const char *)tmp_thumbnail);
1123
1124     tmp_description = sqlite3_column_text(stmt, 5);
1125     if (tmp_description)
1126         sticker_info->description = strdup((const char *)tmp_description);
1127
1128     tmp_group = sqlite3_column_text(stmt, 6);
1129     if (tmp_group)
1130         sticker_info->group = strdup((const char *)tmp_group);
1131
1132     tmp_date = sqlite3_column_text(stmt, 7);
1133     if (tmp_date)
1134         sticker_info->date = strdup((const char *)tmp_date);
1135
1136     sticker_info->display_type = sqlite3_column_int(stmt, 8);
1137
1138     sqlite3_finalize(stmt);
1139     stmt = NULL;
1140
1141     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_KEYWORD_INFO_BY_RECORD_ID, -1, &stmt, NULL);
1142     if (ret != SQLITE_OK) {
1143         LOGE("fail to get sticker keyword : %s", sqlite3_errmsg(db));
1144         goto cleanup;
1145     }
1146
1147     sqlite3_bind_int(stmt, 1, sticker_info->record_id);
1148
1149     while (sqlite3_step(stmt) == SQLITE_ROW) {
1150         const unsigned char *keyword = sqlite3_column_text(stmt, 0);
1151         if (keyword)
1152             sticker_info->keyword = g_list_append(sticker_info->keyword, strdup((const char *)keyword));
1153     }
1154
1155     sqlite3_finalize(stmt);
1156     sqlite3_close(db);
1157
1158     return STICKERD_SERVER_ERROR_NONE;
1159
1160 cleanup:
1161     sqlite3_finalize(stmt);
1162     sqlite3_close(db);
1163
1164     return STICKERD_SERVER_ERROR_DB_FAILED;
1165 }
1166
1167 int stickerd_db_check_group_exists(int *result, char *app_id, char *group)
1168 {
1169     int ret;
1170     sqlite3 *db = NULL;
1171     sqlite3_stmt *stmt = NULL;
1172
1173     db = _db_open();
1174     if (!db)
1175         return STICKERD_SERVER_ERROR_DB_FAILED;
1176
1177     ret = sqlite3_prepare_v2(db, STICKER_DB_CHECK_GROUP_EXISTS_IN_STICKER_INFO, -1, &stmt, NULL);
1178     if (ret != SQLITE_OK) {
1179         LOGE("fail to check group exists : %s", sqlite3_errmsg(db));
1180         goto cleanup;
1181     }
1182
1183     sqlite3_bind_text(stmt, 1, group, -1, SQLITE_TRANSIENT);
1184     sqlite3_bind_text(stmt, 2, app_id, -1, SQLITE_TRANSIENT);
1185
1186     ret = sqlite3_step(stmt);
1187     if (ret == SQLITE_ERROR) {
1188         LOGE("sqlite3_step() failed : ret(%d)", ret);
1189         goto cleanup;
1190     }
1191
1192     *result = sqlite3_column_int(stmt, 0);
1193
1194     sqlite3_finalize(stmt);
1195     sqlite3_close(db);
1196
1197     return STICKERD_SERVER_ERROR_NONE;
1198
1199 cleanup:
1200     sqlite3_finalize(stmt);
1201     sqlite3_close(db);
1202
1203     return STICKERD_SERVER_ERROR_DB_FAILED;
1204 }
1205
1206 int stickerd_db_set_group_image(char *app_id, char *group, int type, char *uri)
1207 {
1208     int ret;
1209     gboolean is_exist = FALSE;
1210     sqlite3 *db = NULL;
1211     sqlite3_stmt *stmt = NULL;
1212
1213     db = _db_open();
1214     if (!db)
1215         return STICKERD_SERVER_ERROR_DB_FAILED;
1216
1217     is_exist = _check_group_exists(app_id, group);
1218     const char* query = is_exist ? STICKER_DB_UPDATE_GROUP_IMAGE : STICKER_DB_INSERT_GROUP_IMAGE;
1219     ret = sqlite3_prepare_v2(db, query, -1, &stmt, NULL);
1220     if (ret != SQLITE_OK) {
1221         LOGE("fail to set group image : %s", sqlite3_errmsg(db));
1222         goto cleanup;
1223     }
1224
1225     if (is_exist) {
1226         sqlite3_bind_int(stmt, 1, type);
1227         sqlite3_bind_text(stmt, 2, uri, -1, SQLITE_TRANSIENT);
1228         sqlite3_bind_text(stmt, 3, app_id, -1, SQLITE_TRANSIENT);
1229         sqlite3_bind_text(stmt, 4, group, -1, SQLITE_TRANSIENT);
1230     } else {
1231         sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
1232         sqlite3_bind_text(stmt, 2, group, -1, SQLITE_TRANSIENT);
1233         sqlite3_bind_int(stmt, 3, type);
1234         sqlite3_bind_text(stmt, 4, uri, -1, SQLITE_TRANSIENT);
1235     }
1236
1237     ret = sqlite3_step(stmt);
1238     if (ret == SQLITE_ERROR) {
1239         LOGE("sqlite3_step() failed : ret(%d)", ret);
1240         goto cleanup;
1241     }
1242
1243     sqlite3_finalize(stmt);
1244     sqlite3_close(db);
1245
1246     return STICKERD_SERVER_ERROR_NONE;
1247
1248 cleanup:
1249     sqlite3_finalize(stmt);
1250     sqlite3_close(db);
1251
1252     return STICKERD_SERVER_ERROR_DB_FAILED;
1253 }
1254
1255 int stickerd_db_get_group_image_list(GVariantBuilder *builder, char *app_id)
1256 {
1257     int ret;
1258     sqlite3 *db = NULL;
1259     sqlite3_stmt *stmt = NULL;
1260
1261     db = _db_open();
1262     if (!db)
1263         return STICKERD_SERVER_ERROR_DB_FAILED;
1264
1265     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_ALL_GROUP_IMAGE_LIST, -1, &stmt, NULL);
1266     if (ret != SQLITE_OK) {
1267         LOGE("fail to get group image list : %s", sqlite3_errmsg(db));
1268         goto cleanup;
1269     }
1270
1271     sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
1272
1273     while (sqlite3_step(stmt) == SQLITE_ROW) {
1274         const unsigned char *group = sqlite3_column_text(stmt, 0);
1275         int uri_type = sqlite3_column_int(stmt, 1);
1276         const unsigned char *uri = sqlite3_column_text(stmt, 2);
1277         if (group && uri)
1278             g_variant_builder_add(builder, "(sis)", strdup((const char *)group), uri_type, strdup((const char *)uri));
1279     }
1280
1281     sqlite3_finalize(stmt);
1282     sqlite3_close(db);
1283
1284     return STICKERD_SERVER_ERROR_NONE;
1285
1286 cleanup:
1287     sqlite3_finalize(stmt);
1288     sqlite3_close(db);
1289
1290     return STICKERD_SERVER_ERROR_DB_FAILED;
1291 }