src/rua_stat_internal.c

   1 /*
   2  * Copyright (c) 2016 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 #include <unistd.h>
  17 #include <sys/types.h>
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21
  22 #include <dlog.h>
  23 #include <sqlite3.h>
  24
  25 #include "db-schema.h"
  26 #include "rua_util.h"
  27 #include "rua_private.h"
  28
  29 #define WIN_SCORE 100
  30 #define LOSE_SCORE_RATE 0.7f
  31
  32 int __rua_stat_insert(sqlite3 *db, char *caller, char *rua_stat_tag)
  33 {
  34         static const char query[] =
  35                 "INSERT INTO rua_panel_stat ("
  36                 "  caller_panel, rua_stat_tag, score) "
  37                 "VALUES (?, ?, ?)";
  38         int r;
  39         sqlite3_stmt *stmt;
  40         int idx = 1;
  41
  42         r = sqlite3_prepare(db, query, sizeof(query), &stmt, NULL);
  43         if (r != SQLITE_OK) {
  44                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
  45                 return -1;
  46         }
  47
  48         __BIND_TEXT(db, stmt, idx++, caller);
  49         __BIND_TEXT(db, stmt, idx++, rua_stat_tag);
  50         __BIND_INT(db, stmt, idx++, WIN_SCORE);
  51
  52         r = sqlite3_step(stmt);
  53         if (r != SQLITE_DONE) {
  54                 LOGE("step failed: %s", sqlite3_errmsg(db));
  55                 sqlite3_finalize(stmt);
  56                 return -1;
  57         }
  58
  59         sqlite3_finalize(stmt);
  60
  61         return r;
  62 }
  63
  64 int __rua_stat_lose_score_update(sqlite3 *db, char *caller, char *rua_stat_tag)
  65 {
  66         static const char query[] =
  67                 "UPDATE rua_panel_stat SET score=score*? "
  68                 "WHERE caller_panel=? AND rua_stat_tag!=?";
  69         int r;
  70         sqlite3_stmt *stmt;
  71         int idx = 1;
  72
  73         LOGD("lose score update sql: %s, %s", caller, rua_stat_tag);
  74         r = sqlite3_prepare(db, query, sizeof(query), &stmt, NULL);
  75         if (r != SQLITE_OK) {
  76                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
  77                 return r;
  78         }
  79
  80         __BIND_DOUBLE(db, stmt, idx++, LOSE_SCORE_RATE);
  81         __BIND_TEXT(db, stmt, idx++, caller);
  82         __BIND_TEXT(db, stmt, idx++, rua_stat_tag);
  83
  84         r = sqlite3_step(stmt);
  85         if (r != SQLITE_DONE) {
  86                 LOGE("step failed: %s", sqlite3_errmsg(db));
  87                 sqlite3_finalize(stmt);
  88                 return r;
  89         }
  90
  91         sqlite3_finalize(stmt);
  92
  93         return r;
  94 }
  95
  96 int __rua_stat_win_score_update(sqlite3 *db, char *caller, char *rua_stat_tag)
  97 {
  98         static const char query[] =
  99                 "UPDATE rua_panel_stat SET score=score+? "
 100                 "WHERE caller_panel=? AND rua_stat_tag=?";
 101         int r;
 102         sqlite3_stmt *stmt;
 103         int idx = 1;
 104
 105         LOGD("win score update sql: %s, %s", caller, rua_stat_tag);
 106
 107         r = sqlite3_prepare(db, query, sizeof(query), &stmt, NULL);
 108         if (r != SQLITE_OK) {
 109                 LOGE("prepare failed: %s", sqlite3_errmsg(db));
 110                 return r;
 111         }
 112
 113         __BIND_INT(db, stmt, idx++, WIN_SCORE);
 114         __BIND_TEXT(db, stmt, idx++, caller);
 115         __BIND_TEXT(db, stmt, idx++, rua_stat_tag);
 116
 117         r = sqlite3_step(stmt);
 118         if (r != SQLITE_DONE) {
 119                 LOGE("step failed: %s", sqlite3_errmsg(db));
 120                 sqlite3_finalize(stmt);
 121                 return r;
 122         }
 123
 124         sqlite3_finalize(stmt);
 125
 126         return r;
 127 }
 128
 129 static int __create_table(sqlite3 *db)
 130 {
 131         int r;
 132         char *errmsg = NULL;
 133
 134         r = sqlite3_exec(db, CREATE_RUA_STAT_TABLE, NULL, NULL, &errmsg);
 135         if (r != SQLITE_OK) {
 136                 LOGE("create table failed: %s", errmsg);
 137                 sqlite3_free(errmsg);
 138                 return -1;
 139         }
 140
 141         return 0;
 142 }
 143
 144 API int rua_stat_usr_db_update(char *caller, char *rua_stat_tag, uid_t uid)
 145 {
 146         int r;
 147         int affected_rows = 0;
 148         sqlite3 *db;
 149
 150         LOGD("rua_stat_update start");
 151
 152         if (caller == NULL || rua_stat_tag == NULL) {
 153                 LOGE("invalid parameter");
 154                 return -1;
 155         }
 156
 157         r = _rua_util_open_db(&db, SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE,
 158                         uid, RUA_STAT_DB_NAME);
 159         if (r == -1) {
 160                 LOGE("open rua stat db failed");
 161                 return -1;
 162         }
 163
 164         r = __create_table(db);
 165         if (r == -1) {
 166                 LOGE("create rua stat tabale failed");
 167                 return -1;
 168         }
 169
 170         r = __rua_stat_lose_score_update(db, caller, rua_stat_tag);
 171         if (r != SQLITE_DONE) {
 172                 LOGE("__rua_stat_lose_score_insert failed");
 173                 return -1;
 174         }
 175
 176         r = __rua_stat_win_score_update(db, caller, rua_stat_tag);
 177         affected_rows = sqlite3_changes(db);
 178         if ((r != SQLITE_DONE) || (affected_rows == 0)) {
 179                 r = __rua_stat_insert(db, caller, rua_stat_tag);
 180
 181                 if (r != SQLITE_DONE) {
 182                         LOGE("__rua_stat_insert failed");
 183                         return -1;
 184                 }
 185         }
 186
 187         sqlite3_close_v2(db);
 188         LOGD("rua_stat_update done");
 189
 190         return r;
 191 }
 192
 193 API int rua_stat_db_update(char *caller, char *rua_stat_tag)
 194 {
 195         return rua_stat_usr_db_update(caller, rua_stat_tag, getuid());
 196 }