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  */
  62
  63 #define STICKER_DB_PATH tzplatform_mkpath(TZ_SYS_DB, ".sticker_info.db")
  64 #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)"
  65 #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)"
  66 #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)"
  67 #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)"
  68
  69 #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'), ?)"
  70 #define STICKER_DB_INSERT_STICKER_KEYWORD_INFO "INSERT INTO sticker_keyword_info (sticker_info_id, keyword) VALUES (?, ?)"
  71 #define STICKER_DB_INSERT_RECENT_HISTORY "INSERT INTO sticker_recent_history_info (sticker_info_id, count, timestamp) VALUES (?, 1, DateTime('now','localtime'))"
  72
  73 #define STICKER_DB_DELETE_STICKER_INFO "DELETE FROM sticker_info WHERE sticker_info_id = ?"
  74 #define STICKER_DB_DELETE_STICKER_KEYWORD_INFO "DELETE FROM sticker_keyword_info WHERE sticker_info_id = ?"
  75 #define STICKER_DB_DELETE_STICKER_INFO_BY_URI "DELETE FROM sticker_info WHERE uri = ?"
  76
  77 #define STICKER_DB_UPDATE_STICKER_TYPE "UPDATE sticker_info SET type = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  78 #define STICKER_DB_UPDATE_STICKER_URI "UPDATE sticker_info SET uri = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  79 #define STICKER_DB_UPDATE_STICKER_THUMBNAIL "UPDATE sticker_info SET thumbnail = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  80 #define STICKER_DB_UPDATE_STICKER_DESCRIPTION "UPDATE sticker_info SET description = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  81 #define STICKER_DB_UPDATE_STICKER_GROUP "UPDATE sticker_info SET group_name = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  82 #define STICKER_DB_UPDATE_STICKER_DISP_TYPE "UPDATE sticker_info SET display_type = ?, date = DateTime('now','localtime') WHERE sticker_info_id = ?"
  83 #define STICKER_DB_UPDATE_RECENT_HISTORY "UPDATE sticker_recent_history_info SET count = count + 1, timestamp = DateTime('now','localtime') WHERE sticker_info_id = ?"
  84
  85 #define STICKER_DB_GET_LATEST_RECORD_ID "SELECT sticker_info_id FROM sticker_info ORDER BY sticker_info_id DESC LIMIT 1"
  86 #define STICKER_DB_GET_STICKER_INFO_BY_RECORD_ID "SELECT * FROM sticker_info WHERE sticker_info_id = ?"
  87 #define STICKER_DB_GET_KEYWORD_INFO_BY_RECORD_ID "SELECT keyword FROM sticker_keyword_info WHERE sticker_info_id = ?"
  88 #define STICKER_DB_GET_IMAGE_INFO_BY_RECORED_ID "SELECT type, uri, thumbnail FROM sticker_info WHERE sticker_info_id = ?"
  89 #define STICKER_DB_GET_IMAGE_INFO_BY_URI "SELECT type, thumbnail FROM sticker_info WHERE uri = ?"
  90 #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 = ?))"
  91 #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 = ?)))"
  92 #define STICKER_DB_GET_STICKER_COUNT "SELECT count(*) FROM sticker_info WHERE app_id = ?"
  93 #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 ?, ?"
  94 #define STICKER_DB_GET_RECORD_ID_BY_APP_ID "SELECT sticker_info_id from sticker_info WHERE app_id = ? LIMIT ?, ?"
  95 #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 ?, ?"
  96 #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 ?, ?"
  97 #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 ?, ?"
  98 #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 ?, ?"
  99 #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 = ?))"
 100 #define STICKER_DB_CHECK_FILE_EXISTS "SELECT EXISTS(SELECT 1 FROM sticker_info WHERE uri = ? LIMIT 1)"
 101 #define STICKER_DB_CHECK_RECENT_HISTORY_EXISTS "SELECT EXISTS(SELECT 1 FROM sticker_recent_history_info WHERE sticker_info_id = ? LIMIT 1)"
 102 #define STICKER_DB_GET_RECENT_HISTORY "SELECT sticker_info_id FROM sticker_recent_history_info ORDER BY datetime(timestamp) DESC LIMIT ?"
 103
 104 typedef enum
 105 {
 106     CMD_UPDATE,
 107     CMD_SELECT,
 108 } command_type;
 109
 110 static gboolean is_corrupted = FALSE;
 111
 112 static const char *_db_get_query(sticker_info_db_type sticker_type, command_type cmd_type)
 113 {
 114     static const char* query = NULL;
 115
 116     if (cmd_type == CMD_UPDATE) {
 117         switch(sticker_type) {
 118             case STICKER_DB_STICKER_TYPE:
 119             query = STICKER_DB_UPDATE_STICKER_TYPE;
 120             break;
 121             case STICKER_DB_STICKER_URI:
 122             query = STICKER_DB_UPDATE_STICKER_URI;
 123             break;
 124             case STICKER_DB_STICKER_THUMBNAIL:
 125             query = STICKER_DB_UPDATE_STICKER_THUMBNAIL;
 126             break;
 127             case STICKER_DB_STICKER_DESCRIPTION:
 128             query = STICKER_DB_UPDATE_STICKER_DESCRIPTION;
 129             break;
 130             case STICKER_DB_STICKER_GROUP:
 131             query = STICKER_DB_UPDATE_STICKER_GROUP;
 132             break;
 133             case STICKER_DB_STICKER_KEYWORD:
 134             query = STICKER_DB_DELETE_STICKER_KEYWORD_INFO;
 135             break;
 136             case STICKER_DB_STICKER_DISP_TYPE:
 137             query = STICKER_DB_UPDATE_STICKER_DISP_TYPE;
 138             break;
 139             default :
 140             query = "";
 141             break;
 142         }
 143     } else if (cmd_type == CMD_SELECT) {
 144         switch(sticker_type) {
 145             case STICKER_DB_STICKER_ALL:
 146             query = STICKER_DB_GET_ALL_RECORD_ID;
 147             break;
 148             case STICKER_DB_STICKER_APPID:
 149             query = STICKER_DB_GET_RECORD_ID_BY_APP_ID;
 150             break;
 151             case STICKER_DB_STICKER_TYPE:
 152             query = STICKER_DB_GET_RECORD_ID_BY_TYPE;
 153             break;
 154             case STICKER_DB_STICKER_GROUP:
 155             query = STICKER_DB_GET_RECORD_ID_BY_GROUP;
 156             break;
 157             case STICKER_DB_STICKER_KEYWORD:
 158             query = STICKER_DB_GET_RECORD_ID_BY_KEYWORD;
 159             break;
 160             case STICKER_DB_STICKER_DISP_TYPE:
 161             query = STICKER_DB_GET_RECORD_ID_BY_DISP_TYPE;
 162             case STICKER_DB_STICKER_RECENT_HISTORY:
 163             query = STICKER_DB_GET_RECENT_HISTORY;
 164             break;
 165             default :
 166             query = "";
 167             break;
 168         }
 169     }
 170
 171     return query;
 172 }
 173
 174 static int _recover_db(void)
 175 {
 176     int ret = STICKERD_SERVER_ERROR_NONE;
 177     sqlite3 *db = NULL;
 178     char *err = NULL;
 179
 180     LOGD("Start to recover sticker db");
 181     //Remove sticker database file
 182     if (unlink(STICKER_DB_PATH) == -1)
 183         LOGE("Failed to remove db file");
 184
 185     ret = sqlite3_open_v2(STICKER_DB_PATH, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
 186     if (ret != SQLITE_OK) {
 187         LOGE("Failed to open db : %s", sqlite3_errmsg(db));
 188         if (unlink(STICKER_DB_PATH) == -1)
 189             LOGE("Failed to remove db file");
 190         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 191         goto cleanup;
 192     }
 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     }
 213
 214     ret = sqlite3_exec(db, STICKER_RECENT_HISTORY_INFO_CREATE_TABLE, NULL, NULL, &err);
 215     if (ret != SQLITE_OK) {
 216         LOGE("Failed to create sticker_recent_history_info table : %s", err);
 217         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 218     }
 219
 220     is_corrupted = FALSE;
 221
 222 cleanup:
 223     if (err)
 224         sqlite3_free(err);
 225
 226     if (db)
 227         sqlite3_close(db);
 228
 229     return ret;
 230 }
 231
 232 static int _integrity_check_cb(void *pid, int argc, char **argv, char **notUsed)
 233 {
 234     if (strcmp(argv[0], "ok") != 0) {
 235         LOGE("DB integrity check failed : %s", argv[0]);
 236         is_corrupted = TRUE;
 237         return -1;
 238     }
 239
 240     LOGD("Result integrity : %s", argv[0]);
 241     return 0;
 242 }
 243
 244 int stickerd_db_init(void)
 245 {
 246     int ret = STICKERD_SERVER_ERROR_NONE;
 247     sqlite3 *db = NULL;
 248     char *err = NULL;
 249
 250     ret = sqlite3_open_v2(STICKER_DB_PATH, &db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE, NULL);
 251     if (ret != SQLITE_OK) {
 252         LOGE("Failed to open db : %s", sqlite3_errmsg(db));
 253         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 254         goto cleanup;
 255     }
 256
 257     ret = sqlite3_exec(db, STICKER_INFO_CREATE_TABLE, NULL, NULL, &err);
 258     if (ret != SQLITE_OK) {
 259         LOGE("Failed to create sticker_info table : %s" , err);
 260         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 261         goto cleanup;
 262     }
 263
 264     ret = sqlite3_exec(db, STICKER_KEYWORD_INFO_CREATE_TABLE, NULL, NULL, &err);
 265     if (ret != SQLITE_OK) {
 266         LOGE("Failed to create sticker_keyword_info table : %s", err);
 267         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 268         goto cleanup;
 269     }
 270
 271     ret = sqlite3_exec(db, STICKER_WHITELIST_INFO_CREATE_TABLE, NULL, NULL, &err);
 272     if (ret != SQLITE_OK) {
 273         LOGE("Failed to create sticker_whitelist_info table : %s", err);
 274         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 275         goto cleanup;
 276     }
 277
 278     ret = sqlite3_exec(db, STICKER_RECENT_HISTORY_INFO_CREATE_TABLE, NULL, NULL, &err);
 279     if (ret != SQLITE_OK) {
 280         LOGE("Failed to create sticker_recent_history_info table : %s", err);
 281         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 282         goto cleanup;
 283     }
 284
 285     ret = sqlite3_exec(db, "PRAGMA journal_mode = WAL", NULL, NULL, &err);
 286     if (ret != SQLITE_OK) {
 287         LOGE("Failed to set journal_mode : %s", err);
 288         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 289         goto cleanup;
 290     }
 291
 292     ret = sqlite3_exec(db, "PRAGMA integrity_check", _integrity_check_cb, NULL, &err);
 293     if (ret != SQLITE_OK) {
 294         LOGE("Failed to check integrity : %s", err);
 295         ret = STICKERD_SERVER_ERROR_DB_FAILED;
 296     }
 297
 298 cleanup:
 299     if (err)
 300         sqlite3_free(err);
 301
 302     if (db)
 303         sqlite3_close(db);
 304
 305     if (ret == SQLITE_CORRUPT || ret == SQLITE_NOTADB || is_corrupted)
 306         ret = _recover_db();
 307
 308     return ret;
 309 }
 310
 311 static sqlite3 *_db_open(void)
 312 {
 313     int ret;
 314     sqlite3 *db = NULL;
 315     char *err = NULL;
 316
 317     ret = sqlite3_open(STICKER_DB_PATH, &db);
 318     if (ret != SQLITE_OK) {
 319         LOGE("Failed to open db : %s", sqlite3_errmsg(db));
 320         return NULL;
 321     }
 322
 323     ret = sqlite3_exec(db, "PRAGMA foreign_keys = ON", NULL, NULL, &err);
 324     if (ret != SQLITE_OK) {
 325         LOGE("Failed to turn on foreign keys : %s", err);
 326     }
 327
 328     if (err)
 329         sqlite3_free(err);
 330
 331     return db;
 332 }
 333
 334 int stickerd_db_insert_sticker_info(int *record_id, sticker_info_db *sticker_info)
 335 {
 336     int ret;
 337     sqlite3 *db = NULL;
 338     sqlite3_stmt *stmt = NULL;
 339
 340     db = _db_open();
 341     if (!db)
 342         return STICKERD_SERVER_ERROR_DB_FAILED;
 343
 344     ret = sqlite3_prepare_v2(db, STICKER_DB_INSERT_STICKER_INFO, -1, &stmt, NULL);
 345     if (ret != SQLITE_OK) {
 346         LOGE("fail to insert sticker information : %s", sqlite3_errmsg(db));
 347         goto cleanup;
 348     }
 349
 350     sqlite3_bind_text(stmt, 1, sticker_info->app_id, -1, SQLITE_TRANSIENT);
 351     sqlite3_bind_int(stmt, 2, sticker_info->type);
 352     sqlite3_bind_text(stmt, 3, sticker_info->uri, -1, SQLITE_TRANSIENT);
 353     sqlite3_bind_text(stmt, 4, sticker_info->thumbnail, -1, SQLITE_TRANSIENT);
 354     sqlite3_bind_text(stmt, 5, sticker_info->description, -1, SQLITE_TRANSIENT);
 355     sqlite3_bind_text(stmt, 6, sticker_info->group, -1, SQLITE_TRANSIENT);
 356     sqlite3_bind_int(stmt, 7, sticker_info->display_type);
 357
 358     ret = sqlite3_step(stmt);
 359     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 360         LOGE("sqlite3_step() failed : ret(%d)", ret);
 361         goto cleanup;
 362     } else if (sqlite3_changes(db) == 0) {
 363         LOGE("No changes to DB");
 364         goto cleanup;
 365     }
 366
 367     sqlite3_finalize(stmt);
 368     stmt = NULL;
 369
 370     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_LATEST_RECORD_ID, -1, &stmt, NULL);
 371     if (ret != SQLITE_OK) {
 372         LOGE("fail to get sticker id : %s", sqlite3_errmsg(db));
 373         goto cleanup;
 374     }
 375
 376     ret = sqlite3_step(stmt);
 377     if (ret == SQLITE_ERROR) {
 378         LOGE("sqlite3_step() failed : ret(%d)", ret);
 379         *record_id = 0;
 380         goto cleanup;
 381     } else {
 382         *record_id = sqlite3_column_int(stmt, 0);
 383         LOGD("record_id : %d", *record_id);
 384     }
 385
 386     GList *list;
 387     for(list = sticker_info->keyword; list != NULL; list=list->next) {
 388         sqlite3_finalize(stmt);
 389         stmt = NULL;
 390
 391         ret = sqlite3_prepare_v2(db, STICKER_DB_INSERT_STICKER_KEYWORD_INFO, -1, &stmt, NULL);
 392         if (ret != SQLITE_OK) {
 393             LOGE("fail to insert sticker keyword : %s", sqlite3_errmsg(db));
 394             goto cleanup;
 395         }
 396
 397         sqlite3_bind_int(stmt, 1, *record_id);
 398         sqlite3_bind_text(stmt, 2, (char *)list->data, -1, SQLITE_TRANSIENT);
 399
 400         ret = sqlite3_step(stmt);
 401         if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 402             LOGE("sqlite3_step() failed : ret(%d)", ret);
 403             goto cleanup;
 404         } else if (sqlite3_changes(db) == 0) {
 405             LOGE("No changes to DB");
 406             goto cleanup;
 407         }
 408     }
 409
 410     sqlite3_finalize(stmt);
 411     sqlite3_close(db);
 412
 413     return STICKERD_SERVER_ERROR_NONE;
 414
 415 cleanup:
 416     sqlite3_finalize(stmt);
 417     sqlite3_close(db);
 418
 419     return STICKERD_SERVER_ERROR_DB_FAILED;
 420 }
 421
 422 int stickerd_db_delete_sticker_info(int record_id)
 423 {
 424     int ret;
 425     sqlite3 *db = NULL;
 426     sqlite3_stmt *stmt = NULL;
 427
 428     db = _db_open();
 429     if (!db)
 430         return STICKERD_SERVER_ERROR_DB_FAILED;
 431
 432     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_IMAGE_INFO_BY_RECORED_ID, -1, &stmt, NULL);
 433     if (ret != SQLITE_OK) {
 434         LOGE("fail to get image files : %s", sqlite3_errmsg(db));
 435         goto cleanup;
 436     }
 437
 438     sqlite3_bind_int(stmt, 1, record_id);
 439
 440     ret = sqlite3_step(stmt);
 441     if (ret == SQLITE_ERROR) {
 442         LOGE("sqlite3_step() failed : ret(%d)", ret);
 443         goto cleanup;
 444     }
 445
 446     int uri_type = sqlite3_column_int(stmt, 0);
 447     const unsigned char *uri = sqlite3_column_text(stmt, 1);
 448     const unsigned char *thumbnail = sqlite3_column_text(stmt, 2);
 449
 450     if (uri_type == 1 && unlink((const char *)uri) == -1)
 451         LOGE("fail to delete sticker file");
 452
 453     if (thumbnail && unlink((const char *)thumbnail) == -1)
 454         LOGE("fail to delete thumbnail image");
 455
 456     sqlite3_finalize(stmt);
 457     stmt = NULL;
 458
 459     ret = sqlite3_prepare_v2(db, STICKER_DB_DELETE_STICKER_INFO, -1, &stmt, NULL);
 460     if (ret != SQLITE_OK) {
 461         LOGE("fail to delete sticker information : %s", sqlite3_errmsg(db));
 462         goto cleanup;
 463     }
 464
 465     sqlite3_bind_int(stmt, 1, record_id);
 466
 467     ret = sqlite3_step(stmt);
 468     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 469         LOGE("sqlite3_step() failed : ret(%d)", ret);
 470         goto cleanup;
 471     } else if (sqlite3_changes(db) == 0) {
 472         LOGE("No changes to DB");
 473         goto cleanup;
 474     }
 475
 476     sqlite3_finalize(stmt);
 477     sqlite3_close(db);
 478
 479     return STICKERD_SERVER_ERROR_NONE;
 480
 481 cleanup:
 482     sqlite3_finalize(stmt);
 483     sqlite3_close(db);
 484
 485     return STICKERD_SERVER_ERROR_DB_FAILED;
 486 }
 487
 488 int stickerd_db_delete_sticker_info_by_uri(char *uri)
 489 {
 490     int ret;
 491     sqlite3 *db = NULL;
 492     sqlite3_stmt *stmt = NULL;
 493
 494     db = _db_open();
 495     if (!db)
 496         return STICKERD_SERVER_ERROR_DB_FAILED;
 497
 498     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_IMAGE_INFO_BY_URI, -1, &stmt, NULL);
 499     if (ret != SQLITE_OK) {
 500         LOGE("fail to delete sticker information : %s", sqlite3_errmsg(db));
 501         goto cleanup;
 502     }
 503
 504     sqlite3_bind_text(stmt, 1, uri, -1, SQLITE_TRANSIENT);
 505
 506     ret = sqlite3_step(stmt);
 507     if (ret == SQLITE_ERROR) {
 508         LOGE("sqlite3_step() failed : ret(%d)", ret);
 509         goto cleanup;
 510     }
 511
 512     int uri_type = sqlite3_column_int(stmt, 0);
 513     const unsigned char *thumbnail = sqlite3_column_text(stmt, 1);
 514
 515     if (uri_type == 1 && unlink((const char *)uri) == -1)
 516         LOGE("fail to delete sticker file");
 517
 518     if (thumbnail && unlink((const char *)thumbnail) == -1)
 519         LOGE("fail to delete thumbnail image");
 520
 521     sqlite3_finalize(stmt);
 522     stmt = NULL;
 523
 524     ret = sqlite3_prepare_v2(db, STICKER_DB_DELETE_STICKER_INFO_BY_URI, -1, &stmt, NULL);
 525     if (ret != SQLITE_OK) {
 526         LOGE("fail to delete sticker information : %s", sqlite3_errmsg(db));
 527         goto cleanup;
 528     }
 529
 530     sqlite3_bind_text(stmt, 1, uri, -1, SQLITE_TRANSIENT);
 531
 532     ret = sqlite3_step(stmt);
 533     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 534         LOGE("sqlite3_step() failed : ret(%d)", ret);
 535         goto cleanup;
 536     } else if (sqlite3_changes(db) == 0) {
 537         LOGE("No changes to DB");
 538         goto cleanup;
 539     }
 540
 541     sqlite3_finalize(stmt);
 542     sqlite3_close(db);
 543
 544     return STICKERD_SERVER_ERROR_NONE;
 545
 546 cleanup:
 547     sqlite3_finalize(stmt);
 548     sqlite3_close(db);
 549
 550     return STICKERD_SERVER_ERROR_DB_FAILED;
 551 }
 552
 553 int stickerd_db_update_sticker_info(int record_id, sticker_info_db_type type, void *data)
 554 {
 555     int ret;
 556     sqlite3 *db = NULL;
 557     sqlite3_stmt *stmt = NULL;
 558
 559     db = _db_open();
 560     if (!db)
 561         return STICKERD_SERVER_ERROR_DB_FAILED;
 562
 563     const char* query = _db_get_query(type, CMD_UPDATE);
 564     ret = sqlite3_prepare_v2(db, query, -1, &stmt, NULL);
 565     if (ret != SQLITE_OK) {
 566         LOGE("fail to update sticker information : %s", sqlite3_errmsg(db));
 567         goto cleanup;
 568     }
 569
 570     if (type == STICKER_DB_STICKER_TYPE || type == STICKER_DB_STICKER_DISP_TYPE) {
 571         sqlite3_bind_int(stmt, 1, *(int *)data);
 572     } else if (type == STICKER_DB_STICKER_KEYWORD) {
 573         sqlite3_bind_int(stmt, 1, record_id);
 574     } else {
 575         sqlite3_bind_text(stmt, 1, (char *)data, -1, SQLITE_TRANSIENT);
 576     }
 577
 578     if (type != STICKER_DB_STICKER_KEYWORD)
 579         sqlite3_bind_int(stmt, 2, record_id);
 580
 581     ret = sqlite3_step(stmt);
 582     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 583         LOGE("sqlite3_step() failed : ret(%d)", ret);
 584         goto cleanup;
 585     }
 586
 587     if (type == STICKER_DB_STICKER_KEYWORD) {
 588         GList *list;
 589         for(list = (GList *)data; list != NULL; list=list->next) {
 590             sqlite3_finalize(stmt);
 591             stmt = NULL;
 592
 593             ret = sqlite3_prepare_v2(db, STICKER_DB_INSERT_STICKER_KEYWORD_INFO, -1, &stmt, NULL);
 594             if (ret != SQLITE_OK) {
 595                 LOGE("fail to insert sticker information : %s", sqlite3_errmsg(db));
 596                 goto cleanup;
 597             }
 598
 599             sqlite3_bind_int(stmt, 1, record_id);
 600             sqlite3_bind_text(stmt, 2, (char *)list->data, -1, SQLITE_TRANSIENT);
 601
 602             ret = sqlite3_step(stmt);
 603             if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 604                 LOGE("sqlite3_step() failed : ret(%d)", ret);
 605                 goto cleanup;
 606             } else if (sqlite3_changes(db) == 0) {
 607                 LOGE("No changes to DB");
 608                 goto cleanup;
 609             }
 610         }
 611     }
 612
 613     sqlite3_finalize(stmt);
 614     sqlite3_close(db);
 615
 616     return STICKERD_SERVER_ERROR_NONE;
 617
 618 cleanup:
 619     sqlite3_finalize(stmt);
 620     sqlite3_close(db);
 621
 622     return STICKERD_SERVER_ERROR_DB_FAILED;
 623 }
 624
 625 int stickerd_db_get_sticker_info_by_record_id(int record_id, sticker_info_db *sticker_info)
 626 {
 627     int ret;
 628     sqlite3 *db = NULL;
 629     sqlite3_stmt *stmt = NULL;
 630
 631     db = _db_open();
 632     if (!db)
 633         return STICKERD_SERVER_ERROR_DB_FAILED;
 634
 635     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_STICKER_INFO_BY_RECORD_ID, -1, &stmt, NULL);
 636     if (ret != SQLITE_OK) {
 637         LOGE("fail to get sticker information : %s", sqlite3_errmsg(db));
 638         goto cleanup;
 639     }
 640
 641     sqlite3_bind_int(stmt, 1, record_id);
 642
 643     ret = sqlite3_step(stmt);
 644     if (ret == SQLITE_ERROR) {
 645         LOGE("sqlite3_step() failed : ret(%d)", ret);
 646         goto cleanup;
 647     }
 648
 649     const unsigned char *tmp_app_id = sqlite3_column_text(stmt, 1);
 650     if (tmp_app_id) {
 651         sticker_info->app_id = strdup((const char *)tmp_app_id);
 652     } else {
 653         LOGW("invalid record_id : %d", record_id);
 654         goto cleanup;
 655     }
 656
 657     sticker_info->type = sqlite3_column_int(stmt, 2);
 658
 659     const unsigned char *tmp_uri = sqlite3_column_text(stmt, 3);
 660     if (tmp_uri)
 661         sticker_info->uri = strdup((const char *)tmp_uri);
 662
 663     const unsigned char *tmp_thumbnail = sqlite3_column_text(stmt, 4);
 664     if (tmp_thumbnail)
 665         sticker_info->thumbnail = strdup((const char *)tmp_thumbnail);
 666
 667     const unsigned char *tmp_description = sqlite3_column_text(stmt, 5);
 668     if (tmp_description)
 669         sticker_info->description = strdup((const char *)tmp_description);
 670
 671     const unsigned char *tmp_group = sqlite3_column_text(stmt, 6);
 672     if (tmp_group)
 673         sticker_info->group = strdup((const char *)tmp_group);
 674
 675     const unsigned char *tmp_date = sqlite3_column_text(stmt, 7);
 676     if (tmp_date)
 677         sticker_info->date = strdup((const char *)tmp_date);
 678
 679     sticker_info->display_type = sqlite3_column_int(stmt, 8);
 680
 681     sqlite3_finalize(stmt);
 682     stmt = NULL;
 683
 684     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_KEYWORD_INFO_BY_RECORD_ID, -1, &stmt, NULL);
 685     if (ret != SQLITE_OK) {
 686         LOGE("fail to get sticker keyword : %s", sqlite3_errmsg(db));
 687         goto cleanup;
 688     }
 689
 690     sqlite3_bind_int(stmt, 1, record_id);
 691
 692     while (sqlite3_step(stmt) == SQLITE_ROW) {
 693         const unsigned char *keyword = sqlite3_column_text(stmt, 0);
 694         if (keyword)
 695             sticker_info->keyword = g_list_append(sticker_info->keyword, strdup((const char *)keyword));
 696     }
 697
 698     sqlite3_finalize(stmt);
 699     sqlite3_close(db);
 700
 701     return STICKERD_SERVER_ERROR_NONE;
 702
 703 cleanup:
 704     sqlite3_finalize(stmt);
 705     sqlite3_close(db);
 706
 707     return STICKERD_SERVER_ERROR_DB_FAILED;
 708 }
 709
 710 int stickerd_db_get_group_list(GVariantBuilder *builder, char *app_id)
 711 {
 712     int ret;
 713     sqlite3 *db = NULL;
 714     sqlite3_stmt *stmt = NULL;
 715
 716     db = _db_open();
 717     if (!db)
 718         return STICKERD_SERVER_ERROR_DB_FAILED;
 719
 720     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_ALL_GROUP_LIST, -1, &stmt, NULL);
 721     if (ret != SQLITE_OK) {
 722         LOGE("fail to get group list : %s", sqlite3_errmsg(db));
 723         goto cleanup;
 724     }
 725
 726     sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
 727
 728     while (sqlite3_step(stmt) == SQLITE_ROW) {
 729         const unsigned char *group = sqlite3_column_text(stmt, 0);
 730         if (group)
 731             g_variant_builder_add(builder, "(s)", strdup((const char *)group));
 732     }
 733
 734     sqlite3_finalize(stmt);
 735     sqlite3_close(db);
 736
 737     return STICKERD_SERVER_ERROR_NONE;
 738
 739 cleanup:
 740     sqlite3_finalize(stmt);
 741     sqlite3_close(db);
 742
 743     return STICKERD_SERVER_ERROR_DB_FAILED;
 744 }
 745
 746 int stickerd_db_get_keyword_list(GVariantBuilder *builder, char *app_id)
 747 {
 748     int ret;
 749     sqlite3 *db = NULL;
 750     sqlite3_stmt *stmt = NULL;
 751
 752     db = _db_open();
 753     if (!db)
 754         return STICKERD_SERVER_ERROR_DB_FAILED;
 755
 756     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_ALL_KEYWORD_LIST, -1, &stmt, NULL);
 757     if (ret != SQLITE_OK) {
 758         LOGE("fail to get keyword list : %s", sqlite3_errmsg(db));
 759         goto cleanup;
 760     }
 761
 762     sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
 763
 764     while (sqlite3_step(stmt) == SQLITE_ROW) {
 765         const unsigned char *keyword = sqlite3_column_text(stmt, 0);
 766         if (keyword)
 767             g_variant_builder_add(builder, "(s)", strdup((const char *)keyword));
 768     }
 769
 770     sqlite3_finalize(stmt);
 771     sqlite3_close(db);
 772
 773     return STICKERD_SERVER_ERROR_NONE;
 774
 775 cleanup:
 776     sqlite3_finalize(stmt);
 777     sqlite3_close(db);
 778
 779     return STICKERD_SERVER_ERROR_DB_FAILED;
 780 }
 781
 782 int stickerd_db_get_sticker_count(int *count, char *app_id)
 783 {
 784     int ret;
 785     sqlite3 *db = NULL;
 786     sqlite3_stmt *stmt = NULL;
 787
 788     db = _db_open();
 789     if (!db)
 790         return STICKERD_SERVER_ERROR_DB_FAILED;
 791
 792     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_STICKER_COUNT, -1, &stmt, NULL);
 793     if (ret != SQLITE_OK) {
 794         LOGE("fail to get sticker count : %s", sqlite3_errmsg(db));
 795         goto cleanup;
 796     }
 797
 798     sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
 799
 800     ret = sqlite3_step(stmt);
 801     if (ret == SQLITE_ERROR) {
 802         LOGE("sqlite3_step() failed : ret(%d)", ret);
 803         goto cleanup;
 804     }
 805
 806     *count = sqlite3_column_int(stmt, 0);
 807
 808     sqlite3_finalize(stmt);
 809     sqlite3_close(db);
 810
 811     return STICKERD_SERVER_ERROR_NONE;
 812
 813 cleanup:
 814     sqlite3_finalize(stmt);
 815     sqlite3_close(db);
 816
 817     return STICKERD_SERVER_ERROR_DB_FAILED;
 818 }
 819
 820 int stickerd_db_get_record_id(sticker_info_db_type type, GList **id_list, void *data, char *app_id, int offset, int count)
 821 {
 822     int ret;
 823     sqlite3 *db = NULL;
 824     sqlite3_stmt *stmt = NULL;
 825
 826     db = _db_open();
 827     if (!db)
 828         return STICKERD_SERVER_ERROR_DB_FAILED;
 829
 830     const char* query = _db_get_query(type, CMD_SELECT);
 831     ret = sqlite3_prepare_v2(db, query, -1, &stmt, NULL);
 832     if (ret != SQLITE_OK) {
 833         LOGE("fail to get record id : %s", sqlite3_errmsg(db));
 834         goto cleanup;
 835     }
 836
 837     if (type == STICKER_DB_STICKER_ALL || type == STICKER_DB_STICKER_APPID) {
 838         sqlite3_bind_text(stmt, 1, app_id, -1, SQLITE_TRANSIENT);
 839         sqlite3_bind_int(stmt, 2, offset);
 840         sqlite3_bind_int(stmt, 3, count);
 841     } else if (type == STICKER_DB_STICKER_RECENT_HISTORY) {
 842         sqlite3_bind_int(stmt, 1, count);
 843     } else {
 844         if (type == STICKER_DB_STICKER_TYPE || type == STICKER_DB_STICKER_DISP_TYPE)
 845             sqlite3_bind_int(stmt, 1, *(int *)data);
 846         else
 847             sqlite3_bind_text(stmt, 1, (char *)data, -1, SQLITE_TRANSIENT);
 848
 849         sqlite3_bind_text(stmt, 2, app_id, -1, SQLITE_TRANSIENT);
 850         sqlite3_bind_int(stmt, 3, offset);
 851         sqlite3_bind_int(stmt, 4, count);
 852     }
 853
 854     while (sqlite3_step(stmt) == SQLITE_ROW) {
 855         const unsigned char *tmp_id = sqlite3_column_text(stmt, 0);
 856         if (tmp_id)
 857             *id_list = g_list_append(*id_list, strdup((const char *)tmp_id));
 858     }
 859
 860     sqlite3_finalize(stmt);
 861     sqlite3_close(db);
 862
 863     return STICKERD_SERVER_ERROR_NONE;
 864
 865 cleanup:
 866     sqlite3_finalize(stmt);
 867     sqlite3_close(db);
 868
 869     return STICKERD_SERVER_ERROR_DB_FAILED;
 870 }
 871
 872 int stickerd_db_get_group_list_by_display_type(GVariantBuilder *builder, char *app_id, int disp_type)
 873 {
 874     int ret;
 875     sqlite3 *db = NULL;
 876     sqlite3_stmt *stmt = NULL;
 877
 878     db = _db_open();
 879     if (!db)
 880         return STICKERD_SERVER_ERROR_DB_FAILED;
 881
 882     ret = sqlite3_prepare_v2(db, STICKER_DB_GET_GROUP_LIST_BY_DISP_TYPE, -1, &stmt, NULL);
 883     if (ret != SQLITE_OK) {
 884         LOGE("fail to get group list : %s", sqlite3_errmsg(db));
 885         goto cleanup;
 886     }
 887
 888     sqlite3_bind_int(stmt, 1, disp_type);
 889     sqlite3_bind_text(stmt, 2, app_id, -1, SQLITE_TRANSIENT);
 890
 891     while (sqlite3_step(stmt) == SQLITE_ROW) {
 892         const unsigned char *group = sqlite3_column_text(stmt, 0);
 893         if (group)
 894             g_variant_builder_add(builder, "(s)", strdup((const char *)group));
 895     }
 896
 897     sqlite3_finalize(stmt);
 898     sqlite3_close(db);
 899
 900     return STICKERD_SERVER_ERROR_NONE;
 901
 902 cleanup:
 903     sqlite3_finalize(stmt);
 904     sqlite3_close(db);
 905
 906     return STICKERD_SERVER_ERROR_DB_FAILED;
 907 }
 908
 909 int stickerd_db_check_file_exists(int *result, char *uri)
 910 {
 911     int ret;
 912     sqlite3 *db = NULL;
 913     sqlite3_stmt *stmt = NULL;
 914
 915     db = _db_open();
 916     if (!db)
 917         return STICKERD_SERVER_ERROR_DB_FAILED;
 918
 919     ret = sqlite3_prepare_v2(db, STICKER_DB_CHECK_FILE_EXISTS, -1, &stmt, NULL);
 920     if (ret != SQLITE_OK) {
 921         LOGE("fail to check file exists : %s", sqlite3_errmsg(db));
 922         goto cleanup;
 923     }
 924
 925     sqlite3_bind_text(stmt, 1, uri, -1, SQLITE_TRANSIENT);
 926
 927     ret = sqlite3_step(stmt);
 928     if (ret == SQLITE_ERROR) {
 929         LOGE("sqlite3_step() failed : ret(%d)", ret);
 930         goto cleanup;
 931     }
 932
 933     *result = sqlite3_column_int(stmt, 0);
 934
 935     sqlite3_finalize(stmt);
 936     sqlite3_close(db);
 937
 938     return STICKERD_SERVER_ERROR_NONE;
 939
 940 cleanup:
 941     sqlite3_finalize(stmt);
 942     sqlite3_close(db);
 943
 944     return STICKERD_SERVER_ERROR_DB_FAILED;
 945 }
 946
 947 int stickerd_db_insert_recent_sticker_info(int record_id)
 948 {
 949     int ret;
 950     sqlite3 *db = NULL;
 951     sqlite3_stmt *stmt = NULL;
 952
 953     db = _db_open();
 954     if (!db)
 955         return STICKERD_SERVER_ERROR_DB_FAILED;
 956
 957     ret = sqlite3_prepare_v2(db, STICKER_DB_CHECK_RECENT_HISTORY_EXISTS, -1, &stmt, NULL);
 958     if (ret != SQLITE_OK) {
 959         LOGE("fail to check recent sticker exists : %s", sqlite3_errmsg(db));
 960         goto cleanup;
 961     }
 962
 963     sqlite3_bind_int(stmt, 1, record_id);
 964
 965     ret = sqlite3_step(stmt);
 966     if (ret == SQLITE_ERROR) {
 967         LOGE("sqlite3_step() failed : ret(%d)", ret);
 968         goto cleanup;
 969     }
 970
 971     int result = sqlite3_column_int(stmt, 0);
 972
 973     sqlite3_finalize(stmt);
 974     stmt = NULL;
 975
 976     if (result)
 977         ret = sqlite3_prepare_v2(db, STICKER_DB_UPDATE_RECENT_HISTORY, -1, &stmt, NULL);
 978     else
 979         ret = sqlite3_prepare_v2(db, STICKER_DB_INSERT_RECENT_HISTORY, -1, &stmt, NULL);
 980
 981     if (ret != SQLITE_OK) {
 982         LOGE("fail to update recent history : %s", sqlite3_errmsg(db));
 983         goto cleanup;
 984     }
 985
 986     sqlite3_bind_int(stmt, 1, record_id);
 987
 988     ret = sqlite3_step(stmt);
 989     if (ret != SQLITE_OK && ret != SQLITE_DONE) {
 990         LOGE("sqlite3_step() failed : ret(%d)", ret);
 991         goto cleanup;
 992     } else if (sqlite3_changes(db) == 0) {
 993         LOGE("No changes to DB");
 994         goto cleanup;
 995     }
 996
 997     sqlite3_finalize(stmt);
 998     sqlite3_close(db);
 999
1000     return STICKERD_SERVER_ERROR_NONE;
1001
1002 cleanup:
1003     sqlite3_finalize(stmt);
1004     sqlite3_close(db);
1005
1006     return STICKERD_SERVER_ERROR_DB_FAILED;
1007 }