server/db/cal_db_plugin_attendee_helper.c

   1 /*
   2  * Calendar Service
   3  *
   4  * Copyright (c) 2012 - 2015 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <stdlib.h>
  21
  22 #include "cal_internal.h"
  23 #include "cal_typedef.h"
  24 #include "cal_view.h"
  25 #include "cal_record.h"
  26 #include "cal_list.h"
  27
  28 #include "cal_db_util.h"
  29 #include "cal_db_query.h"
  30 #include "cal_db_plugin_attendee_helper.h"
  31 #include "cal_db.h"
  32 #include "cal_utils.h"
  33
  34 static int _cal_db_attendee_insert_record(calendar_record_h record, int parent_id)
  35 {
  36         int index;
  37         int ret = 0;
  38         char query[CAL_DB_SQL_MAX_LEN];
  39         sqlite3_stmt *stmt;
  40         cal_attendee_s *attendee = NULL;
  41
  42         attendee = (cal_attendee_s *)(record);
  43         RETVM_IF(NULL == attendee, CALENDAR_ERROR_INVALID_PARAMETER,
  44                         "Invalid argument: cal_alarm_s is NULL");
  45
  46         snprintf(query, sizeof(query),
  47                         "INSERT INTO %s ("
  48                         "event_id, "
  49                         "attendee_name, attendee_email, attendee_number, "
  50                         "attendee_status, attendee_cutype, attendee_ct_index, "
  51                         "attendee_role, attendee_rsvp, attendee_group, "
  52                         "attendee_delegator_uri, attendee_delegatee_uri, "
  53                         "attendee_member, attendee_uid "
  54                         ") VALUES ("
  55                         "%d, "
  56                         "?, ?, ?, "
  57                         "%d, %d, %d, "
  58                         "%d, %d, ?, "
  59                         "?, ?, "
  60                         "?, ?)",
  61                         CAL_TABLE_ATTENDEE,
  62                         parent_id,
  63                         attendee->attendee_status,
  64                         attendee->attendee_cutype,
  65                         attendee->attendee_ct_index,
  66                         attendee->attendee_role,
  67                         attendee->attendee_rsvp);
  68
  69         ret = cal_db_util_query_prepare(query, &stmt);
  70         if (CALENDAR_ERROR_NONE != ret) {
  71                 ERR("cal_db_util_query_prepare() Fail(%d)", ret);
  72                 SECURE("query[%s]", query);
  73                 return ret;
  74         }
  75
  76         index = 1;
  77         if (attendee->attendee_name)
  78                 cal_db_util_stmt_bind_text(stmt, index, attendee->attendee_name);
  79         index++;
  80
  81         if (attendee->attendee_email)
  82                 cal_db_util_stmt_bind_text(stmt, index, attendee->attendee_email);
  83         index++;
  84
  85         if (attendee->attendee_number)
  86                 cal_db_util_stmt_bind_text(stmt, index, attendee->attendee_number);
  87         index++;
  88
  89         if (attendee->attendee_group)
  90                 cal_db_util_stmt_bind_text(stmt, index, attendee->attendee_group);
  91         index++;
  92
  93         if (attendee->attendee_delegator_uri)
  94                 cal_db_util_stmt_bind_text(stmt, index, attendee->attendee_delegator_uri);
  95         index++;
  96
  97         if (attendee->attendee_delegatee_uri)
  98                 cal_db_util_stmt_bind_text(stmt, index, attendee->attendee_delegatee_uri);
  99         index++;
 100
 101         if (attendee->attendee_member)
 102                 cal_db_util_stmt_bind_text(stmt, index, attendee->attendee_member);
 103         index++;
 104
 105         if (attendee->attendee_uid)
 106                 cal_db_util_stmt_bind_text(stmt, index, attendee->attendee_uid);
 107         index++;
 108
 109         ret = cal_db_util_stmt_step(stmt);
 110         sqlite3_finalize(stmt);
 111         if (CALENDAR_ERROR_NONE != ret) {
 112                 ERR("cal_db_util_stmt_step() Fail(%d)", ret);
 113                 return ret;
 114         }
 115
 116         attendee->parent_id = parent_id;
 117         return CALENDAR_ERROR_NONE;
 118 }
 119
 120 int cal_db_attendee_insert_records(cal_list_s *list_s, int parent_id)
 121 {
 122         int ret;
 123         int count = 0;
 124         calendar_record_h record = NULL;
 125         calendar_list_h list = (calendar_list_h)list_s;
 126
 127         RETV_IF(NULL == list, CALENDAR_ERROR_INVALID_PARAMETER);
 128
 129         calendar_list_get_count(list, &count);
 130         if (0 == count)
 131                 return CALENDAR_ERROR_NONE;
 132
 133         calendar_list_first(list);
 134         while (CALENDAR_ERROR_NONE == calendar_list_get_current_record_p(list, &record)) {
 135                 ret = _cal_db_attendee_insert_record(record, parent_id);
 136                 RETVM_IF(CALENDAR_ERROR_NONE != ret, ret, "cal_db_extended_insert_record() Fail(%d)", ret);
 137                 calendar_list_next(list);
 138         }
 139         return CALENDAR_ERROR_NONE;
 140
 141 }
 142
 143 int cal_db_attendee_get_records(int parent_id, cal_list_s *list)
 144 {
 145         int ret;
 146         char query[CAL_DB_SQL_MAX_LEN] = {0};
 147         sqlite3_stmt *stmt = NULL;
 148
 149         RETVM_IF(NULL == list, CALENDAR_ERROR_INVALID_PARAMETER,
 150                         "Invalid parameter: list is NULL");
 151
 152         snprintf(query, sizeof(query),
 153                         "SELECT rowid, "
 154                         "attendee_name, "
 155                         "attendee_email, "
 156                         "attendee_number, "
 157                         "attendee_status, "
 158                         "attendee_ct_index, "
 159                         "attendee_role, "
 160                         "attendee_rsvp, "
 161                         "attendee_group, "
 162                         "attendee_delegator_uri, "
 163                         "attendee_uid, "
 164                         "attendee_cutype, "
 165                         "attendee_delegatee_uri, "
 166                         "attendee_member "
 167                         "FROM %s WHERE event_id = %d ",
 168                         CAL_TABLE_ATTENDEE, parent_id);
 169
 170         ret = cal_db_util_query_prepare(query, &stmt);
 171         if (CALENDAR_ERROR_NONE != ret) {
 172                 ERR("cal_db_util_query_prepare() Fail(%d)", ret);
 173                 SECURE("query[%s]", query);
 174                 return ret;
 175         }
 176
 177         int index;
 178         const unsigned char *temp;
 179         calendar_record_h record = NULL;
 180         cal_attendee_s *attendee = NULL;
 181
 182         while (CAL_SQLITE_ROW == cal_db_util_stmt_step(stmt)) {
 183                 ret = calendar_record_create(_calendar_attendee._uri, &record);
 184                 if (CALENDAR_ERROR_NONE != ret) {
 185                         sqlite3_finalize(stmt);
 186                         cal_list_clear(list);
 187                         return ret;
 188                 }
 189
 190                 index = 0;
 191                 attendee = (cal_attendee_s *)(record);
 192
 193                 attendee->parent_id = parent_id;
 194                 attendee->id = sqlite3_column_int(stmt, index++);
 195
 196                 temp = sqlite3_column_text(stmt, index++);
 197                 attendee->attendee_name = cal_strdup((const char*)temp);
 198
 199                 temp = sqlite3_column_text(stmt, index++);
 200                 attendee->attendee_email = cal_strdup((const char*)temp);
 201
 202                 temp = sqlite3_column_text(stmt, index++);
 203                 attendee->attendee_number = cal_strdup((const char*)temp);
 204
 205                 attendee->attendee_status = sqlite3_column_int(stmt, index++);
 206                 attendee->attendee_ct_index = sqlite3_column_int(stmt, index++);
 207                 attendee->attendee_role = sqlite3_column_int(stmt, index++);
 208                 attendee->attendee_rsvp = sqlite3_column_int(stmt, index++);
 209
 210                 temp = sqlite3_column_text(stmt, index++);
 211                 attendee->attendee_group = cal_strdup((const char*)temp);
 212
 213                 temp = sqlite3_column_text(stmt, index++);
 214                 attendee->attendee_delegator_uri = cal_strdup((const char*)temp);
 215
 216                 temp = sqlite3_column_text(stmt, index++);
 217                 attendee->attendee_uid = cal_strdup((const char*)temp);
 218
 219                 attendee->attendee_cutype = sqlite3_column_int(stmt, index++);
 220
 221                 temp = sqlite3_column_text(stmt, index++);
 222                 attendee->attendee_delegatee_uri = cal_strdup((const char*)temp);
 223
 224                 temp = sqlite3_column_text(stmt, index++);
 225                 attendee->attendee_member = cal_strdup((const char*)temp);
 226
 227                 calendar_list_add((calendar_list_h)list, record);
 228         }
 229
 230         sqlite3_finalize(stmt);
 231         return CALENDAR_ERROR_NONE;
 232 }
 233
 234 int cal_db_attendee_delete_with_id(int parent_id)
 235 {
 236         int ret = 0;
 237         char query[CAL_DB_SQL_MAX_LEN] = {0};
 238
 239         snprintf(query, sizeof(query), "DELETE FROM %s WHERE event_id=%d ",
 240                         CAL_TABLE_ATTENDEE, parent_id);
 241
 242         ret = cal_db_util_query_exec(query);
 243         if (CALENDAR_ERROR_NONE != ret) {
 244                 ERR("cal_db_util_query_exec() Fail(%d)", ret);
 245                 SECURE("[%s]", query);
 246                 return ret;
 247         }
 248
 249         return CALENDAR_ERROR_NONE;
 250 }
 251