4 * Copyright (c) 2012 - 2015 Samsung Electronics Co., Ltd. All rights reserved.
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
10 * http://www.apache.org/licenses/LICENSE-2.0
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.
22 #include "cal_internal.h"
23 #include "cal_typedef.h"
25 #include "cal_record.h"
27 #include "cal_db_util.h"
29 #include "cal_db_query.h"
30 #include "cal_access_control.h"
31 #include "cal_utils.h"
33 static int _cal_db_instance_allday_extended_get_all_records(int offset, int limit, calendar_list_h* out_list);
34 static int _cal_db_instance_allday_extended_get_records_with_query(calendar_query_h query, int offset, int limit, calendar_list_h* out_list);
35 static int _cal_db_instance_allday_extended_get_count(int *out_count);
36 static int _cal_db_instance_allday_extended_get_count_with_query(calendar_query_h query, int *out_count);
41 static void _cal_db_instance_allday_extended_get_stmt(sqlite3_stmt *stmt, calendar_record_h record);
42 static void _cal_db_instance_allday_extended_get_property_stmt(sqlite3_stmt *stmt,
43 unsigned int property, int *stmt_count, calendar_record_h record);
44 static void _cal_db_instance_allday_extended_get_projection_stmt(sqlite3_stmt *stmt,
45 const unsigned int *projection, const int projection_count,
46 calendar_record_h record);
48 cal_db_plugin_cb_s cal_db_instance_allday_extended_plugin_cb = {
49 .is_query_only = false,
50 .insert_record = NULL,
52 .update_record = NULL,
53 .delete_record = NULL,
54 .get_all_records = _cal_db_instance_allday_extended_get_all_records,
55 .get_records_with_query = _cal_db_instance_allday_extended_get_records_with_query,
56 .insert_records = NULL,
57 .update_records = NULL,
58 .delete_records = NULL,
59 .get_count = _cal_db_instance_allday_extended_get_count,
60 .get_count_with_query = _cal_db_instance_allday_extended_get_count_with_query,
61 .replace_record = NULL,
62 .replace_records = NULL
65 static int _cal_db_instance_allday_extended_get_all_records(int offset, int limit, calendar_list_h* out_list)
68 char offsetquery[CAL_DB_SQL_MAX_LEN] = {0};
69 char limitquery[CAL_DB_SQL_MAX_LEN] = {0};
70 sqlite3_stmt *stmt = NULL;
72 RETV_IF(NULL == out_list, CALENDAR_ERROR_INVALID_PARAMETER);
74 ret = calendar_list_create(out_list);
75 RETVM_IF(CALENDAR_ERROR_NONE != ret, ret, "calendar_list_create() Fail(%d)", ret);
78 snprintf(offsetquery, sizeof(offsetquery), "OFFSET %d", offset);
80 snprintf(limitquery, sizeof(limitquery), "LIMIT %d", limit);
82 char *query_str = NULL;
83 cal_db_append_string(&query_str, "SELECT * FROM");
84 cal_db_append_string(&query_str, CAL_VIEW_TABLE_ALLDAY_INSTANCE_EXTENDED);
85 cal_db_append_string(&query_str, limitquery);
86 cal_db_append_string(&query_str, offsetquery);
88 ret = cal_db_util_query_prepare(query_str, &stmt);
89 if (CALENDAR_ERROR_NONE != ret) {
91 ERR("cal_db_util_query_prepare() Fail(%d)", ret);
92 SECURE("query[%s]", query_str);
93 calendar_list_destroy(*out_list, true);
100 while (CAL_SQLITE_ROW == cal_db_util_stmt_step(stmt)) {
101 calendar_record_h record;
102 ret = calendar_record_create(_calendar_instance_localtime_calendar_book_extended._uri, &record);
103 if (CALENDAR_ERROR_NONE != ret) {
104 /* LCOV_EXCL_START */
105 calendar_list_destroy(*out_list, true);
107 sqlite3_finalize(stmt);
112 _cal_db_instance_allday_extended_get_stmt(stmt, record);
114 ret = calendar_list_add(*out_list, record);
115 if (CALENDAR_ERROR_NONE != ret) {
116 /* LCOV_EXCL_START */
117 calendar_list_destroy(*out_list, true);
119 calendar_record_destroy(record, true);
120 sqlite3_finalize(stmt);
126 sqlite3_finalize(stmt);
129 return CALENDAR_ERROR_NONE;
132 static int _cal_db_instance_allday_extended_get_records_with_query(calendar_query_h query, int offset, int limit, calendar_list_h* out_list)
134 cal_query_s *que = NULL;
135 int ret = CALENDAR_ERROR_NONE;
136 char *condition = NULL;
137 char *projection = NULL;
138 GSList *bind_text = NULL, *cursor = NULL;
139 sqlite3_stmt *stmt = NULL;
143 que = (cal_query_s *)query;
145 table_name = cal_strdup(CAL_VIEW_TABLE_ALLDAY_INSTANCE_EXTENDED);
149 ret = cal_db_query_create_condition(query, &condition, &bind_text);
150 if (CALENDAR_ERROR_NONE != ret) {
151 /* LCOV_EXCL_START */
152 ERR("cal_db_query_create_condition() Fail(%d), ret");
153 CAL_FREE(table_name);
159 /* make: projection */
160 ret = cal_db_query_create_projection(query, &projection);
162 char *query_str = NULL;
163 /* query: projection */
165 cal_db_append_string(&query_str, "SELECT");
166 cal_db_append_string(&query_str, projection);
167 cal_db_append_string(&query_str, "FROM");
168 cal_db_append_string(&query_str, table_name);
169 CAL_FREE(projection);
171 cal_db_append_string(&query_str, "SELECT * FROM");
172 cal_db_append_string(&query_str, table_name);
174 CAL_FREE(table_name);
176 /* query: condition */
178 cal_db_append_string(&query_str, "WHERE (");
179 cal_db_append_string(&query_str, condition);
180 cal_db_append_string(&query_str, ")");
185 ret = cal_db_query_create_order(query, condition, &order);
187 cal_db_append_string(&query_str, order);
193 char buf[CAL_STR_SHORT_LEN32] = {0};
195 snprintf(buf, sizeof(buf), "LIMIT %d", limit);
196 cal_db_append_string(&query_str, buf);
199 snprintf(buf, sizeof(buf), "OFFSET %d", offset);
200 cal_db_append_string(&query_str, buf);
205 ret = cal_db_util_query_prepare(query_str, &stmt);
206 if (CALENDAR_ERROR_NONE != ret) {
207 /* LCOV_EXCL_START */
208 ERR("cal_db_util_query_prepare() Fail(%d)", ret);
209 SECURE("query[%s]", query_str);
211 g_slist_free_full(bind_text, free);
221 g_slist_length(bind_text);
222 for (cursor = bind_text, i = 1; cursor; cursor = cursor->next, i++)
223 cal_db_util_stmt_bind_text(stmt, i, cursor->data);
226 ret = calendar_list_create(out_list);
227 if (CALENDAR_ERROR_NONE != ret) {
229 g_slist_free_full(bind_text, free);
232 /* LCOV_EXCL_START */
233 ERR("calendar_list_create() Fail");
234 sqlite3_finalize(stmt);
240 while (CAL_SQLITE_ROW == cal_db_util_stmt_step(stmt)) {
241 calendar_record_h record;
242 ret = calendar_record_create(que->view_uri, &record);
243 if (CALENDAR_ERROR_NONE != ret) {
244 /* LCOV_EXCL_START */
245 calendar_list_destroy(*out_list, true);
249 g_slist_free_full(bind_text, free);
252 sqlite3_finalize(stmt);
257 if (0 < que->projection_count) {
258 cal_record_set_projection(record, que->projection, que->projection_count, que->property_count);
259 _cal_db_instance_allday_extended_get_projection_stmt(stmt, que->projection, que->projection_count, record);
261 _cal_db_instance_allday_extended_get_stmt(stmt, record);
264 ret = calendar_list_add(*out_list, record);
265 if (CALENDAR_ERROR_NONE != ret) {
266 /* LCOV_EXCL_START */
267 calendar_list_destroy(*out_list, true);
269 calendar_record_destroy(record, true);
272 g_slist_free_full(bind_text, free);
275 sqlite3_finalize(stmt);
283 g_slist_free_full(bind_text, free);
287 sqlite3_finalize(stmt);
290 return CALENDAR_ERROR_NONE;
293 static int _cal_db_instance_allday_extended_get_count(int *out_count)
295 RETV_IF(NULL == out_count, CALENDAR_ERROR_INVALID_PARAMETER);
297 char *query_str = NULL;
298 cal_db_append_string(&query_str, "SELECT count(*) FROM");
299 cal_db_append_string(&query_str, CAL_VIEW_TABLE_ALLDAY_INSTANCE_EXTENDED);
303 ret = cal_db_util_query_get_first_int_result(query_str, NULL, &count);
304 if (CALENDAR_ERROR_NONE != ret) {
305 /* LCOV_EXCL_START */
306 ERR("cal_db_util_query_get_first_int_result() Fail");
311 DBG("count(%d) str[%s]", count, query_str);
315 return CALENDAR_ERROR_NONE;
318 static int _cal_db_instance_allday_extended_get_count_with_query(calendar_query_h query, int *out_count)
320 cal_query_s *que = NULL;
321 int ret = CALENDAR_ERROR_NONE;
322 char *condition = NULL;
325 GSList *bind_text = NULL;
327 que = (cal_query_s *)query;
329 table_name = cal_strdup(CAL_VIEW_TABLE_ALLDAY_INSTANCE_EXTENDED);
333 ret = cal_db_query_create_condition(query, &condition, &bind_text);
334 if (CALENDAR_ERROR_NONE != ret) {
335 /* LCOV_EXCL_START */
336 ERR("cal_db_query_create_condition() Fail(%d), ret");
337 CAL_FREE(table_name);
343 char *query_str = NULL;
345 cal_db_append_string(&query_str, "SELECT count(*) FROM");
346 cal_db_append_string(&query_str, table_name);
347 CAL_FREE(table_name);
349 /* query: condition */
351 cal_db_append_string(&query_str, "WHERE (");
352 cal_db_append_string(&query_str, condition);
353 cal_db_append_string(&query_str, ")");
358 ret = cal_db_util_query_get_first_int_result(query_str, bind_text, &count);
359 if (CALENDAR_ERROR_NONE != ret) {
360 /* LCOV_EXCL_START */
361 ERR("cal_db_util_query_get_first_int_result() Fail");
363 g_slist_free_full(bind_text, free);
370 DBG("count(%d) str[%s]", count, query_str);
372 if (out_count) *out_count = count;
375 g_slist_free_full(bind_text, free);
379 return CALENDAR_ERROR_NONE;
382 static void _cal_db_instance_allday_extended_get_stmt(sqlite3_stmt *stmt, calendar_record_h record)
384 cal_instance_allday_extended_s* instance = (cal_instance_allday_extended_s*)(record);
385 const unsigned char *temp;
388 instance->event_id = sqlite3_column_int(stmt, count++);
389 instance->start.type = sqlite3_column_int(stmt, count++);
391 temp = sqlite3_column_text(stmt, count++);
393 sscanf((const char *)temp, CAL_FORMAT_LOCAL_DATETIME, &(instance->start.time.date.year),
394 &(instance->start.time.date.month), &(instance->start.time.date.mday),
395 &(instance->start.time.date.hour), &(instance->start.time.date.minute),
396 &(instance->start.time.date.second));
399 instance->end.type = sqlite3_column_int(stmt, count++);
401 temp = sqlite3_column_text(stmt, count++);
403 sscanf((const char *)temp, CAL_FORMAT_LOCAL_DATETIME, &(instance->end.time.date.year),
404 &(instance->end.time.date.month), &(instance->end.time.date.mday),
405 &(instance->end.time.date.hour), &(instance->end.time.date.minute),
406 &(instance->end.time.date.second));
409 temp = sqlite3_column_text(stmt, count++);
410 instance->summary = cal_strdup((const char*)temp);
412 temp = sqlite3_column_text(stmt, count++);
413 instance->description = cal_strdup((const char*)temp);
415 temp = sqlite3_column_text(stmt, count++);
416 instance->location = cal_strdup((const char*)temp);
418 instance->busy_status = sqlite3_column_int(stmt, count++);
420 instance->event_status = sqlite3_column_int(stmt, count++);
422 instance->priority = sqlite3_column_int(stmt, count++);
424 instance->sensitivity = sqlite3_column_int(stmt, count++);
426 instance->has_rrule = sqlite3_column_int(stmt, count++);
427 if (0 < instance->has_rrule)
428 instance->has_rrule = 1;
430 instance->latitude = sqlite3_column_double(stmt, count++);
431 instance->longitude = sqlite3_column_double(stmt, count++);
432 instance->has_alarm = sqlite3_column_int(stmt, count++);
433 instance->original_event_id = sqlite3_column_int(stmt, count++);
434 instance->calendar_id = sqlite3_column_int(stmt, count++);
436 instance->last_mod = sqlite3_column_int64(stmt, count++);
438 temp = sqlite3_column_text(stmt, count++);
439 instance->sync_data1 = cal_strdup((const char*)temp);
441 temp = sqlite3_column_text(stmt, count++);
442 instance->organizer_name = cal_strdup((const char*)temp);
444 temp = sqlite3_column_text(stmt, count++);
445 instance->categories = cal_strdup((const char*)temp);
447 instance->has_attendee = sqlite3_column_int(stmt, count++);
449 temp = sqlite3_column_text(stmt, count++);
450 instance->sync_data2 = cal_strdup((const char*)temp);
452 temp = sqlite3_column_text(stmt, count++);
453 instance->sync_data3 = cal_strdup((const char*)temp);
455 temp = sqlite3_column_text(stmt, count++);
456 instance->sync_data4 = cal_strdup((const char*)temp);
458 instance->is_allday = sqlite3_column_int(stmt, count++);
463 static void _cal_db_instance_allday_extended_get_property_stmt(sqlite3_stmt *stmt,
464 unsigned int property, int *stmt_count, calendar_record_h record)
466 cal_instance_allday_extended_s* instance = (cal_instance_allday_extended_s*)(record);
467 const unsigned char *temp;
470 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_START:
471 instance->start.type = CALENDAR_TIME_LOCALTIME;
472 *stmt_count = *stmt_count+1; /* utime */
473 *stmt_count = *stmt_count+1;
474 temp = sqlite3_column_text(stmt, *stmt_count);
476 sscanf((const char *)temp, CAL_FORMAT_LOCAL_DATETIME, &(instance->start.time.date.year),
477 &(instance->start.time.date.month), &(instance->start.time.date.mday),
478 &(instance->start.time.date.hour), &(instance->start.time.date.minute),
479 &(instance->start.time.date.second));
482 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_END:
483 instance->end.type = CALENDAR_TIME_LOCALTIME;
484 *stmt_count = *stmt_count+1; /* utime */
485 *stmt_count = *stmt_count+1;
486 temp = sqlite3_column_text(stmt, *stmt_count);
488 sscanf((const char *)temp, CAL_FORMAT_LOCAL_DATETIME, &(instance->end.time.date.year),
489 &(instance->end.time.date.month), &(instance->end.time.date.mday),
490 &(instance->end.time.date.hour), &(instance->end.time.date.minute),
491 &(instance->end.time.date.second));
494 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_SUMMARY:
495 temp = sqlite3_column_text(stmt, *stmt_count);
496 instance->summary = cal_strdup((const char*)temp);
498 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_LOCATION:
499 temp = sqlite3_column_text(stmt, *stmt_count);
500 instance->location = cal_strdup((const char*)temp);
502 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_CALENDAR_ID:
503 instance->calendar_id = sqlite3_column_int(stmt, *stmt_count);
505 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_DESCRIPTION:
506 temp = sqlite3_column_text(stmt, *stmt_count);
507 instance->description = cal_strdup((const char*)temp);
509 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_BUSY_STATUS:
510 instance->busy_status = sqlite3_column_int(stmt, *stmt_count);
512 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_EVENT_STATUS:
513 instance->event_status = sqlite3_column_int(stmt, *stmt_count);
515 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_PRIORITY:
516 instance->priority = sqlite3_column_int(stmt, *stmt_count);
518 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_SENSITIVITY:
519 instance->sensitivity = sqlite3_column_int(stmt, *stmt_count);
521 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_HAS_RRULE:
522 instance->has_rrule = sqlite3_column_int(stmt, *stmt_count);
523 if (0 < instance->has_rrule)
524 instance->has_rrule = 1;
527 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_LATITUDE:
528 instance->latitude = sqlite3_column_double(stmt, *stmt_count);
530 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_LONGITUDE:
531 instance->longitude = sqlite3_column_double(stmt, *stmt_count);
533 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_EVENT_ID:
534 instance->event_id = sqlite3_column_int(stmt, *stmt_count);
536 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_HAS_ALARM:
537 instance->has_alarm = sqlite3_column_int(stmt, *stmt_count);
539 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_ORIGINAL_EVENT_ID:
540 instance->original_event_id = sqlite3_column_int(stmt, *stmt_count);
542 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_LAST_MODIFIED_TIME:
543 instance->last_mod = sqlite3_column_int64(stmt, *stmt_count);
545 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_SYNC_DATA1:
546 temp = sqlite3_column_text(stmt, *stmt_count);
547 instance->sync_data1 = cal_strdup((const char*)temp);
549 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_ORGANIZER_NAME:
550 temp = sqlite3_column_text(stmt, *stmt_count);
551 instance->organizer_name = cal_strdup((const char*)temp);
553 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_CATEGORIES:
554 temp = sqlite3_column_text(stmt, *stmt_count);
555 instance->categories = cal_strdup((const char*)temp);
557 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_HAS_ATTENDEE:
558 instance->has_attendee = sqlite3_column_int(stmt, *stmt_count);
560 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_SYNC_DATA2:
561 temp = sqlite3_column_text(stmt, *stmt_count);
562 instance->sync_data2 = cal_strdup((const char*)temp);
564 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_SYNC_DATA3:
565 temp = sqlite3_column_text(stmt, *stmt_count);
566 instance->sync_data3 = cal_strdup((const char*)temp);
568 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_SYNC_DATA4:
569 temp = sqlite3_column_text(stmt, *stmt_count);
570 instance->sync_data4 = cal_strdup((const char*)temp);
572 case CAL_PROPERTY_INSTANCE_ALLDAY_EXTENDED_IS_ALLDAY:
573 instance->is_allday = sqlite3_column_int(stmt, *stmt_count);
577 sqlite3_column_int(stmt, *stmt_count);
581 *stmt_count = *stmt_count+1;
586 static void _cal_db_instance_allday_extended_get_projection_stmt(sqlite3_stmt *stmt,
587 const unsigned int *projection, const int projection_count,
588 calendar_record_h record)
593 for (i = 0; i < projection_count; i++)
594 _cal_db_instance_allday_extended_get_property_stmt(stmt, projection[i], &stmt_count, record);