common/cal_record_event.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 #include <stdbool.h>
  22 #include <string.h>
  23
  24 #include "calendar_list.h"
  25
  26 #include "cal_internal.h"
  27 #include "cal_typedef.h"
  28 #include "cal_view.h"
  29 #include "cal_list.h"
  30 #include "cal_record.h"
  31 #include "cal_utils.h"
  32
  33 static int _cal_record_event_create(calendar_record_h* out_record);
  34 static int _cal_record_event_destroy(calendar_record_h record, bool delete_child);
  35 static int _cal_record_event_clone(calendar_record_h record, calendar_record_h* out_record);
  36 static int _cal_record_event_get_str(calendar_record_h record, unsigned int property_id, char** out_str);
  37 static int _cal_record_event_get_str_p(calendar_record_h record, unsigned int property_id, char** out_str);
  38 static int _cal_record_event_get_int(calendar_record_h record, unsigned int property_id, int* out_value);
  39 static int _cal_record_event_get_double(calendar_record_h record, unsigned int property_id, double* out_value);
  40 static int _cal_record_event_get_lli(calendar_record_h record, unsigned int property_id, long long int* out_value);
  41 static int _cal_record_event_get_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s* out_value);
  42 static int _cal_record_event_set_str(calendar_record_h record, unsigned int property_id, const char* value);
  43 static int _cal_record_event_set_int(calendar_record_h record, unsigned int property_id, int value);
  44 static int _cal_record_event_set_double(calendar_record_h record, unsigned int property_id, double value);
  45 static int _cal_record_event_set_lli(calendar_record_h record, unsigned int property_id, long long int value);
  46 static int _cal_record_event_set_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s value);
  47 static int _cal_record_event_add_child_record(calendar_record_h record, unsigned int property_id, calendar_record_h child_record);
  48 static int _cal_record_event_remove_child_record(calendar_record_h record, unsigned int property_id, calendar_record_h child_record);
  49 static int _cal_record_event_get_child_record_count(calendar_record_h record, unsigned int property_id, unsigned int* count);
  50 static int _cal_record_event_get_child_record_at_p(calendar_record_h record, unsigned int property_id, int index, calendar_record_h* child_record);
  51 static int _cal_record_event_clone_child_record_list(calendar_record_h record, unsigned int property_id, calendar_list_h* out_list);
  52
  53 cal_record_plugin_cb_s cal_record_event_plugin_cb = {
  54         .create = _cal_record_event_create,
  55         .destroy = _cal_record_event_destroy,
  56         .clone = _cal_record_event_clone,
  57         .get_str = _cal_record_event_get_str,
  58         .get_str_p = _cal_record_event_get_str_p,
  59         .get_int = _cal_record_event_get_int,
  60         .get_double = _cal_record_event_get_double,
  61         .get_lli = _cal_record_event_get_lli,
  62         .get_caltime = _cal_record_event_get_caltime,
  63         .set_str = _cal_record_event_set_str,
  64         .set_int = _cal_record_event_set_int,
  65         .set_double = _cal_record_event_set_double,
  66         .set_lli = _cal_record_event_set_lli,
  67         .set_caltime = _cal_record_event_set_caltime,
  68         .add_child_record = _cal_record_event_add_child_record,
  69         .remove_child_record = _cal_record_event_remove_child_record,
  70         .get_child_record_count = _cal_record_event_get_child_record_count,
  71         .get_child_record_at_p = _cal_record_event_get_child_record_at_p,
  72         .clone_child_record_list = _cal_record_event_clone_child_record_list
  73 };
  74
  75 static void _cal_record_event_struct_init(cal_event_s *record)
  76 {
  77         memset(record, 0, sizeof(cal_event_s));
  78
  79         record->meeting_status = CALENDAR_MEETING_STATUS_NOTMEETING;
  80         record->calendar_id = DEFAULT_EVENT_CALENDAR_BOOK_ID;
  81
  82         record->index = CAL_INVALID_ID;
  83         record->timezone = 0;
  84         record->contact_id = CAL_INVALID_ID;
  85         record->busy_status = 2;
  86         record->summary = NULL;
  87         record->description = NULL;
  88         record->location = NULL;
  89         record->categories = NULL;
  90         record->exdate = NULL;
  91         record->organizer_email = NULL;
  92         record->organizer_name = NULL;
  93         record->uid = NULL;
  94         record->original_event_id = CAL_INVALID_ID;
  95         record->event_status = CALENDAR_EVENT_STATUS_NONE;
  96
  97         record->is_deleted = 0;
  98         record->priority = CALENDAR_EVENT_PRIORITY_NONE;
  99         record->latitude = CALENDAR_RECORD_NO_COORDINATE; /* set default 1000 out of range(-180 ~ 180) */
 100         record->longitude = CALENDAR_RECORD_NO_COORDINATE; /* set default 1000 out of range(-180 ~ 180) */
 101         record->freq = CALENDAR_RECURRENCE_NONE;
 102         record->until.time.utime = CALENDAR_RECORD_NO_UNTIL;
 103
 104         record->alarm_list = calloc(1, sizeof(cal_list_s));
 105         record->attendee_list = calloc(1, sizeof(cal_list_s));
 106         record->exception_list = calloc(1, sizeof(cal_list_s));
 107         record->extended_list = calloc(1, sizeof(cal_list_s));
 108
 109         return ;
 110 }
 111
 112 static int _cal_record_event_create(calendar_record_h* out_record)
 113 {
 114         cal_event_s *temp = NULL;
 115         int ret = CALENDAR_ERROR_NONE;
 116
 117         temp = calloc(1, sizeof(cal_event_s));
 118         RETVM_IF(NULL == temp, CALENDAR_ERROR_OUT_OF_MEMORY, "calloc() Fail");
 119
 120         _cal_record_event_struct_init(temp);
 121
 122         *out_record = (calendar_record_h)temp;
 123
 124         return ret;
 125 }
 126
 127 static void _cal_record_event_struct_free(cal_event_s *record, bool delete_child)
 128 {
 129         CAL_FREE(record->summary);
 130         CAL_FREE(record->description);
 131         CAL_FREE(record->location);
 132         CAL_FREE(record->categories);
 133         CAL_FREE(record->exdate);
 134         CAL_FREE(record->uid);
 135         CAL_FREE(record->organizer_name);
 136         CAL_FREE(record->organizer_email);
 137         CAL_FREE(record->start_tzid);
 138         CAL_FREE(record->end_tzid);
 139
 140         CAL_FREE(record->bysecond);
 141         CAL_FREE(record->byminute);
 142         CAL_FREE(record->byhour);
 143         CAL_FREE(record->byday);
 144         CAL_FREE(record->bymonthday);
 145         CAL_FREE(record->byyearday);
 146         CAL_FREE(record->byweekno);
 147         CAL_FREE(record->bymonth);
 148         CAL_FREE(record->bysetpos);
 149
 150         CAL_FREE(record->recurrence_id);
 151         CAL_FREE(record->rdate);
 152         CAL_FREE(record->sync_data1);
 153         CAL_FREE(record->sync_data2);
 154         CAL_FREE(record->sync_data3);
 155         CAL_FREE(record->sync_data4);
 156
 157         calendar_list_destroy((calendar_list_h)record->alarm_list, delete_child);
 158         calendar_list_destroy((calendar_list_h)record->attendee_list, delete_child);
 159         calendar_list_destroy((calendar_list_h)record->exception_list, delete_child);
 160         calendar_list_destroy((calendar_list_h)record->extended_list, delete_child);
 161
 162         CAL_FREE(record);
 163 }
 164
 165 static int _cal_record_event_destroy(calendar_record_h record, bool delete_child)
 166 {
 167         int ret = CALENDAR_ERROR_NONE;
 168
 169         cal_event_s *temp = (cal_event_s*)(record);
 170
 171         _cal_record_event_struct_free(temp, delete_child);
 172
 173         return ret;
 174 }
 175
 176 static int _cal_record_event_clone(calendar_record_h record, calendar_record_h* out_record)
 177 {
 178         cal_event_s *out_data = NULL;
 179         cal_event_s *src_data = NULL;
 180
 181         src_data = (cal_event_s*)(record);
 182
 183         out_data = calloc(1, sizeof(cal_event_s));
 184         RETVM_IF(NULL == out_data, CALENDAR_ERROR_OUT_OF_MEMORY, "calloc() Fail");
 185
 186         CAL_RECORD_COPY_COMMON(&(out_data->common), &(src_data->common));
 187
 188         out_data->index = src_data->index;
 189         out_data->calendar_id = src_data->calendar_id;
 190
 191         out_data->summary = cal_strdup(src_data->summary);
 192         out_data->description = cal_strdup(src_data->description);
 193         out_data->location = cal_strdup(src_data->location);
 194         out_data->categories = cal_strdup(src_data->categories);
 195         out_data->exdate = cal_strdup(src_data->exdate);
 196
 197         out_data->event_status = src_data->event_status;
 198         out_data->priority = src_data->priority;
 199         out_data->timezone = src_data->timezone;
 200         out_data->contact_id = src_data->contact_id;
 201         out_data->busy_status = src_data->busy_status;
 202         out_data->sensitivity = src_data->sensitivity;
 203         out_data->meeting_status = src_data->meeting_status;
 204
 205         out_data->uid = cal_strdup(src_data->uid);
 206         out_data->organizer_name = cal_strdup(src_data->organizer_name);
 207         out_data->organizer_email = cal_strdup(src_data->organizer_email);
 208
 209         out_data->original_event_id = src_data->original_event_id;
 210         out_data->latitude = src_data->latitude;
 211         out_data->longitude = src_data->longitude;
 212         out_data->email_id = src_data->email_id;
 213         out_data->created_time = src_data->created_time;
 214         out_data->is_deleted = src_data->is_deleted;
 215         out_data->last_mod = src_data->last_mod;
 216         out_data->freq = src_data->freq;
 217         out_data->range_type = src_data->range_type;
 218         out_data->until = src_data->until;
 219
 220         out_data->count = src_data->count;
 221         out_data->interval = src_data->interval;
 222         out_data->bysecond = cal_strdup(src_data->bysecond);
 223         out_data->byminute = cal_strdup(src_data->byminute);
 224         out_data->byhour = cal_strdup(src_data->byhour);
 225         out_data->byday = cal_strdup(src_data->byday);
 226         out_data->bymonthday = cal_strdup(src_data->bymonthday);
 227         out_data->byyearday = cal_strdup(src_data->byyearday);
 228         out_data->byweekno = cal_strdup(src_data->byweekno);
 229         out_data->bymonth = cal_strdup(src_data->bymonth);
 230         out_data->bysetpos = cal_strdup(src_data->bysetpos);
 231         out_data->wkst = src_data->wkst;
 232         out_data->recurrence_id = cal_strdup(src_data->recurrence_id);
 233         out_data->rdate = cal_strdup(src_data->rdate);
 234         out_data->has_attendee = src_data->has_attendee;
 235         out_data->has_alarm = src_data->has_alarm;
 236         out_data->system_type = src_data->system_type;
 237         out_data->updated = src_data->updated;
 238
 239         out_data->sync_data1 = cal_strdup(src_data->sync_data1);
 240         out_data->sync_data2 = cal_strdup(src_data->sync_data2);
 241         out_data->sync_data3 = cal_strdup(src_data->sync_data3);
 242         out_data->sync_data4 = cal_strdup(src_data->sync_data4);
 243
 244         out_data->start = src_data->start;
 245         out_data->start_tzid = cal_strdup(src_data->start_tzid);
 246         out_data->end = src_data->end;
 247         out_data->end_tzid = cal_strdup(src_data->end_tzid);
 248
 249         cal_list_clone((calendar_list_h)src_data->alarm_list, (calendar_list_h *)&out_data->alarm_list);
 250         cal_list_clone((calendar_list_h)src_data->attendee_list, (calendar_list_h *)&out_data->attendee_list);
 251         cal_list_clone((calendar_list_h)src_data->exception_list, (calendar_list_h *)&out_data->exception_list);
 252         cal_list_clone((calendar_list_h)src_data->extended_list, (calendar_list_h *)&out_data->extended_list);
 253
 254         *out_record = (calendar_record_h)out_data;
 255
 256         return CALENDAR_ERROR_NONE;
 257 }
 258
 259 static int _cal_record_event_get_str(calendar_record_h record, unsigned int property_id, char** out_str)
 260 {
 261         cal_event_s *rec = (cal_event_s*)(record);
 262         switch (property_id) {
 263         case CAL_PROPERTY_EVENT_SUMMARY:
 264                 *out_str = cal_strdup(rec->summary);
 265                 break;
 266         case CAL_PROPERTY_EVENT_DESCRIPTION:
 267                 *out_str = cal_strdup(rec->description);
 268                 break;
 269         case CAL_PROPERTY_EVENT_LOCATION:
 270                 *out_str = cal_strdup(rec->location);
 271                 break;
 272         case CAL_PROPERTY_EVENT_CATEGORIES:
 273                 *out_str = cal_strdup(rec->categories);
 274                 break;
 275         case CAL_PROPERTY_EVENT_EXDATE:
 276                 *out_str = cal_strdup(rec->exdate);
 277                 break;
 278         case CAL_PROPERTY_EVENT_UID:
 279                 *out_str = cal_strdup(rec->uid);
 280                 break;
 281         case CAL_PROPERTY_EVENT_ORGANIZER_NAME:
 282                 *out_str = cal_strdup(rec->organizer_name);
 283                 break;
 284         case CAL_PROPERTY_EVENT_ORGANIZER_EMAIL:
 285                 *out_str = cal_strdup(rec->organizer_email);
 286                 break;
 287         case CAL_PROPERTY_EVENT_BYSECOND:
 288                 *out_str = cal_strdup(rec->bysecond);
 289                 break;
 290         case CAL_PROPERTY_EVENT_BYMINUTE:
 291                 *out_str = cal_strdup(rec->byminute);
 292                 break;
 293         case CAL_PROPERTY_EVENT_BYHOUR:
 294                 *out_str = cal_strdup(rec->byhour);
 295                 break;
 296         case CAL_PROPERTY_EVENT_BYDAY:
 297                 *out_str = cal_strdup(rec->byday);
 298                 break;
 299         case CAL_PROPERTY_EVENT_BYMONTHDAY:
 300                 *out_str = cal_strdup(rec->bymonthday);
 301                 break;
 302         case CAL_PROPERTY_EVENT_BYYEARDAY:
 303                 *out_str = cal_strdup(rec->byyearday);
 304                 break;
 305         case CAL_PROPERTY_EVENT_BYWEEKNO:
 306                 *out_str = cal_strdup(rec->byweekno);
 307                 break;
 308         case CAL_PROPERTY_EVENT_BYMONTH:
 309                 *out_str = cal_strdup(rec->bymonth);
 310                 break;
 311         case CAL_PROPERTY_EVENT_BYSETPOS:
 312                 *out_str = cal_strdup(rec->bysetpos);
 313                 break;
 314         case CAL_PROPERTY_EVENT_RECURRENCE_ID:
 315                 *out_str = cal_strdup(rec->recurrence_id);
 316                 break;
 317         case CAL_PROPERTY_EVENT_RDATE:
 318                 *out_str = cal_strdup(rec->rdate);
 319                 break;
 320         case CAL_PROPERTY_EVENT_SYNC_DATA1:
 321                 *out_str = cal_strdup(rec->sync_data1);
 322                 break;
 323         case CAL_PROPERTY_EVENT_SYNC_DATA2:
 324                 *out_str = cal_strdup(rec->sync_data2);
 325                 break;
 326         case CAL_PROPERTY_EVENT_SYNC_DATA3:
 327                 *out_str = cal_strdup(rec->sync_data3);
 328                 break;
 329         case CAL_PROPERTY_EVENT_SYNC_DATA4:
 330                 *out_str = cal_strdup(rec->sync_data4);
 331                 break;
 332         case CAL_PROPERTY_EVENT_START_TZID:
 333                 *out_str = cal_strdup(rec->start_tzid);
 334                 break;
 335         case CAL_PROPERTY_EVENT_END_TZID:
 336                 *out_str = cal_strdup(rec->end_tzid);
 337                 break;
 338         default:
 339                 /* LCOV_EXCL_START */
 340                 ERR("invalid parameter (property:0x%x)", property_id);
 341                 return CALENDAR_ERROR_INVALID_PARAMETER;
 342                 /* LCOV_EXCL_STOP */
 343         }
 344
 345         return CALENDAR_ERROR_NONE;
 346 }
 347
 348 static int _cal_record_event_get_str_p(calendar_record_h record, unsigned int property_id, char** out_str)
 349 {
 350         cal_event_s *rec = (cal_event_s*)(record);
 351         switch (property_id) {
 352         case CAL_PROPERTY_EVENT_SUMMARY:
 353                 *out_str = (rec->summary);
 354                 break;
 355         case CAL_PROPERTY_EVENT_DESCRIPTION:
 356                 *out_str = (rec->description);
 357                 break;
 358         case CAL_PROPERTY_EVENT_LOCATION:
 359                 *out_str = (rec->location);
 360                 break;
 361         case CAL_PROPERTY_EVENT_CATEGORIES:
 362                 *out_str = (rec->categories);
 363                 break;
 364         case CAL_PROPERTY_EVENT_EXDATE:
 365                 *out_str = (rec->exdate);
 366                 break;
 367         case CAL_PROPERTY_EVENT_UID:
 368                 *out_str = (rec->uid);
 369                 break;
 370         case CAL_PROPERTY_EVENT_ORGANIZER_NAME:
 371                 *out_str = (rec->organizer_name);
 372                 break;
 373         case CAL_PROPERTY_EVENT_ORGANIZER_EMAIL:
 374                 *out_str = (rec->organizer_email);
 375                 break;
 376         case CAL_PROPERTY_EVENT_BYSECOND:
 377                 *out_str = (rec->bysecond);
 378                 break;
 379         case CAL_PROPERTY_EVENT_BYMINUTE:
 380                 *out_str = (rec->byminute);
 381                 break;
 382         case CAL_PROPERTY_EVENT_BYHOUR:
 383                 *out_str = (rec->byhour);
 384                 break;
 385         case CAL_PROPERTY_EVENT_BYDAY:
 386                 *out_str = (rec->byday);
 387                 break;
 388         case CAL_PROPERTY_EVENT_BYMONTHDAY:
 389                 *out_str = (rec->bymonthday);
 390                 break;
 391         case CAL_PROPERTY_EVENT_BYYEARDAY:
 392                 *out_str = (rec->byyearday);
 393                 break;
 394         case CAL_PROPERTY_EVENT_BYWEEKNO:
 395                 *out_str = (rec->byweekno);
 396                 break;
 397         case CAL_PROPERTY_EVENT_BYMONTH:
 398                 *out_str = (rec->bymonth);
 399                 break;
 400         case CAL_PROPERTY_EVENT_BYSETPOS:
 401                 *out_str = (rec->bysetpos);
 402                 break;
 403         case CAL_PROPERTY_EVENT_RECURRENCE_ID:
 404                 *out_str = (rec->recurrence_id);
 405                 break;
 406         case CAL_PROPERTY_EVENT_RDATE:
 407                 *out_str = (rec->rdate);
 408                 break;
 409         case CAL_PROPERTY_EVENT_SYNC_DATA1:
 410                 *out_str = (rec->sync_data1);
 411                 break;
 412         case CAL_PROPERTY_EVENT_SYNC_DATA2:
 413                 *out_str = (rec->sync_data2);
 414                 break;
 415         case CAL_PROPERTY_EVENT_SYNC_DATA3:
 416                 *out_str = (rec->sync_data3);
 417                 break;
 418         case CAL_PROPERTY_EVENT_SYNC_DATA4:
 419                 *out_str = (rec->sync_data4);
 420                 break;
 421         case CAL_PROPERTY_EVENT_START_TZID:
 422                 *out_str = (rec->start_tzid);
 423                 break;
 424         case CAL_PROPERTY_EVENT_END_TZID:
 425                 *out_str = (rec->end_tzid);
 426                 break;
 427         default:
 428                 /* LCOV_EXCL_START */
 429                 ERR("invalid parameter (property:0x%x)", property_id);
 430                 return CALENDAR_ERROR_INVALID_PARAMETER;
 431                 /* LCOV_EXCL_STOP */
 432         }
 433
 434         return CALENDAR_ERROR_NONE;
 435 }
 436
 437 static int _cal_record_event_get_int(calendar_record_h record, unsigned int property_id, int* out_value)
 438 {
 439         cal_event_s *rec = (cal_event_s*)(record);
 440         switch (property_id) {
 441         case CAL_PROPERTY_EVENT_ID:
 442                 *out_value = (rec->index);
 443                 break;
 444         case CAL_PROPERTY_EVENT_BOOK_ID:
 445                 *out_value = (rec->calendar_id);
 446                 break;
 447         case CAL_PROPERTY_EVENT_EVENT_STATUS:
 448                 *out_value = (rec->event_status);
 449                 break;
 450         case CAL_PROPERTY_EVENT_PRIORITY:
 451                 *out_value = (rec->priority);
 452                 break;
 453         case CAL_PROPERTY_EVENT_TIMEZONE:
 454                 *out_value = (rec->timezone);
 455                 break;
 456         case CAL_PROPERTY_EVENT_CONTACT_ID:
 457                 *out_value = (rec->contact_id);
 458                 break;
 459         case CAL_PROPERTY_EVENT_BUSY_STATUS:
 460                 *out_value = (rec->busy_status);
 461                 break;
 462         case CAL_PROPERTY_EVENT_SENSITIVITY:
 463                 *out_value = (rec->sensitivity);
 464                 break;
 465         case CAL_PROPERTY_EVENT_MEETING_STATUS:
 466                 *out_value = (rec->meeting_status);
 467                 break;
 468         case CAL_PROPERTY_EVENT_ORIGINAL_EVENT_ID:
 469                 *out_value = (rec->original_event_id);
 470                 break;
 471         case CAL_PROPERTY_EVENT_EMAIL_ID:
 472                 *out_value = (rec->email_id);
 473                 break;
 474         case CAL_PROPERTY_EVENT_IS_DELETED:
 475                 *out_value = (rec->is_deleted);
 476                 break;
 477         case CAL_PROPERTY_EVENT_FREQ:
 478                 *out_value = (rec->freq);
 479                 break;
 480         case CAL_PROPERTY_EVENT_RANGE_TYPE:
 481                 *out_value = (rec->range_type);
 482                 break;
 483         case CAL_PROPERTY_EVENT_COUNT:
 484                 *out_value = (rec->count);
 485                 break;
 486         case CAL_PROPERTY_EVENT_INTERVAL:
 487                 *out_value = (rec->interval);
 488                 break;
 489         case CAL_PROPERTY_EVENT_WKST:
 490                 *out_value = (rec->wkst);
 491                 break;
 492         case CAL_PROPERTY_EVENT_HAS_ATTENDEE:
 493                 *out_value = (rec->has_attendee);
 494                 break;
 495         case CAL_PROPERTY_EVENT_HAS_ALARM:
 496                 *out_value = (rec->has_alarm);
 497                 break;
 498         case CAL_PROPERTY_EVENT_CALENDAR_SYSTEM_TYPE:
 499                 *out_value = (rec->system_type);
 500                 break;
 501         case CAL_PROPERTY_EVENT_IS_ALLDAY:
 502                 *out_value = (rec->is_allday);
 503                 break;
 504         default:
 505                 return CALENDAR_ERROR_INVALID_PARAMETER;
 506         }
 507
 508         return CALENDAR_ERROR_NONE;
 509 }
 510
 511 static int _cal_record_event_get_double(calendar_record_h record, unsigned int property_id, double* out_value)
 512 {
 513         cal_event_s *rec = (cal_event_s*)(record);
 514         switch (property_id) {
 515         case CAL_PROPERTY_EVENT_LATITUDE:
 516                 *out_value = (rec->latitude);
 517                 break;
 518         case CAL_PROPERTY_EVENT_LONGITUDE:
 519                 *out_value = (rec->longitude);
 520                 break;
 521         default:
 522                 /* LCOV_EXCL_START */
 523                 ERR("invalid parameter (property:0x%x)", property_id);
 524                 return CALENDAR_ERROR_INVALID_PARAMETER;
 525                 /* LCOV_EXCL_STOP */
 526         }
 527
 528         return CALENDAR_ERROR_NONE;
 529 }
 530
 531 static int _cal_record_event_get_lli(calendar_record_h record, unsigned int property_id, long long int* out_value)
 532 {
 533         cal_event_s *rec = (cal_event_s*)(record);
 534         switch (property_id) {
 535         case CAL_PROPERTY_EVENT_CREATED_TIME:
 536                 *out_value = (rec->created_time);
 537                 break;
 538         case CAL_PROPERTY_EVENT_LAST_MODIFIED_TIME:
 539                 *out_value = (rec->last_mod);
 540                 break;
 541         default:
 542                 return CALENDAR_ERROR_INVALID_PARAMETER;
 543         }
 544
 545         return CALENDAR_ERROR_NONE;
 546 }
 547
 548 static int _cal_record_event_get_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s* out_value)
 549 {
 550         cal_event_s *rec = (cal_event_s*)(record);
 551         switch (property_id) {
 552         case CAL_PROPERTY_EVENT_START:
 553                 *out_value = rec->start;
 554                 break;
 555         case CAL_PROPERTY_EVENT_END:
 556                 *out_value = rec->end;
 557                 break;
 558         case CAL_PROPERTY_EVENT_UNTIL:
 559                 *out_value = rec->until;
 560                 break;
 561         default:
 562                 /* LCOV_EXCL_START */
 563                 ERR("invalid parameter (property:0x%x)", property_id);
 564                 return CALENDAR_ERROR_INVALID_PARAMETER;
 565                 /* LCOV_EXCL_STOP */
 566         }
 567
 568         return CALENDAR_ERROR_NONE;
 569 }
 570
 571 static int _cal_record_event_set_str(calendar_record_h record, unsigned int property_id, const char* value)
 572 {
 573         cal_event_s *rec = (cal_event_s*)(record);
 574         switch (property_id) {
 575         case CAL_PROPERTY_EVENT_SUMMARY:
 576                 CAL_FREE(rec->summary);
 577                 rec->summary = cal_strdup(value);
 578                 break;
 579         case CAL_PROPERTY_EVENT_DESCRIPTION:
 580                 CAL_FREE(rec->description);
 581                 rec->description = cal_strdup(value);
 582                 break;
 583         case CAL_PROPERTY_EVENT_LOCATION:
 584                 CAL_FREE(rec->location);
 585                 rec->location = cal_strdup(value);
 586                 break;
 587         case CAL_PROPERTY_EVENT_CATEGORIES:
 588                 CAL_FREE(rec->categories);
 589                 rec->categories = cal_strdup(value);
 590                 break;
 591         case CAL_PROPERTY_EVENT_EXDATE:
 592                 CAL_FREE(rec->exdate);
 593                 rec->exdate = cal_strdup(value);
 594                 break;
 595         case CAL_PROPERTY_EVENT_UID:
 596                 CAL_FREE(rec->uid);
 597                 rec->uid = cal_strdup(value);
 598                 break;
 599         case CAL_PROPERTY_EVENT_ORGANIZER_NAME:
 600                 CAL_FREE(rec->organizer_name);
 601                 rec->organizer_name = cal_strdup(value);
 602                 break;
 603         case CAL_PROPERTY_EVENT_ORGANIZER_EMAIL:
 604                 CAL_FREE(rec->organizer_email);
 605                 rec->organizer_email = cal_strdup(value);
 606                 break;
 607         case CAL_PROPERTY_EVENT_BYSECOND:
 608                 CAL_FREE(rec->bysecond);
 609                 rec->bysecond = cal_strdup_with_sort(value);
 610                 break;
 611         case CAL_PROPERTY_EVENT_BYMINUTE:
 612                 CAL_FREE(rec->byminute);
 613                 rec->byminute = cal_strdup_with_sort(value);
 614                 break;
 615         case CAL_PROPERTY_EVENT_BYHOUR:
 616                 CAL_FREE(rec->byhour);
 617                 rec->byhour = cal_strdup_with_sort(value);
 618                 break;
 619         case CAL_PROPERTY_EVENT_BYDAY:
 620                 CAL_FREE(rec->byday);
 621                 rec->byday = cal_strdup(value);
 622                 break;
 623         case CAL_PROPERTY_EVENT_BYMONTHDAY:
 624                 CAL_FREE(rec->bymonthday);
 625                 rec->bymonthday = cal_strdup_with_sort(value);
 626                 break;
 627         case CAL_PROPERTY_EVENT_BYYEARDAY:
 628                 CAL_FREE(rec->byyearday);
 629                 rec->byyearday = cal_strdup_with_sort(value);
 630                 break;
 631         case CAL_PROPERTY_EVENT_BYWEEKNO:
 632                 CAL_FREE(rec->byweekno);
 633                 rec->byweekno = cal_strdup_with_sort(value);
 634                 break;
 635         case CAL_PROPERTY_EVENT_BYMONTH:
 636                 CAL_FREE(rec->bymonth);
 637                 rec->bymonth = cal_strdup_with_sort(value);
 638                 break;
 639         case CAL_PROPERTY_EVENT_BYSETPOS:
 640                 CAL_FREE(rec->bysetpos);
 641                 rec->bysetpos = cal_strdup_with_sort(value);
 642                 break;
 643         case CAL_PROPERTY_EVENT_RECURRENCE_ID:
 644                 CAL_FREE(rec->recurrence_id);
 645                 rec->recurrence_id = cal_strdup(value);
 646                 break;
 647         case CAL_PROPERTY_EVENT_RDATE:
 648                 CAL_FREE(rec->rdate);
 649                 rec->rdate = cal_strdup(value);
 650                 break;
 651         case CAL_PROPERTY_EVENT_SYNC_DATA1:
 652                 CAL_FREE(rec->sync_data1);
 653                 rec->sync_data1 = cal_strdup(value);
 654                 break;
 655         case CAL_PROPERTY_EVENT_SYNC_DATA2:
 656                 CAL_FREE(rec->sync_data2);
 657                 rec->sync_data2 = cal_strdup(value);
 658                 break;
 659         case CAL_PROPERTY_EVENT_SYNC_DATA3:
 660                 CAL_FREE(rec->sync_data3);
 661                 rec->sync_data3 = cal_strdup(value);
 662                 break;
 663         case CAL_PROPERTY_EVENT_SYNC_DATA4:
 664                 CAL_FREE(rec->sync_data4);
 665                 rec->sync_data4 = cal_strdup(value);
 666                 break;
 667         case CAL_PROPERTY_EVENT_START_TZID:
 668                 CAL_FREE(rec->start_tzid);
 669                 rec->start_tzid = cal_strdup(value);
 670                 break;
 671         case CAL_PROPERTY_EVENT_END_TZID:
 672                 CAL_FREE(rec->end_tzid);
 673                 rec->end_tzid = cal_strdup(value);
 674                 break;
 675         default:
 676                 /* LCOV_EXCL_START */
 677                 ERR("invalid parameter (property:0x%x)", property_id);
 678                 return CALENDAR_ERROR_INVALID_PARAMETER;
 679                 /* LCOV_EXCL_STOP */
 680         }
 681
 682         return CALENDAR_ERROR_NONE;
 683 }
 684
 685 static int _cal_record_event_set_int(calendar_record_h record, unsigned int property_id, int value)
 686 {
 687         cal_event_s *rec = (cal_event_s*)(record);
 688         switch (property_id) {
 689         case CAL_PROPERTY_EVENT_ID:
 690                 (rec->index) = value;
 691                 break;
 692         case CAL_PROPERTY_EVENT_BOOK_ID:
 693                 (rec->calendar_id) = value;
 694                 break;
 695         case CAL_PROPERTY_EVENT_EVENT_STATUS:
 696                 switch (value) {
 697                 case CALENDAR_EVENT_STATUS_NONE:
 698                 case CALENDAR_EVENT_STATUS_TENTATIVE:
 699                 case CALENDAR_EVENT_STATUS_CONFIRMED:
 700                 case CALENDAR_EVENT_STATUS_CANCELLED:
 701                         (rec->event_status) = value;
 702                         break;
 703                 default:
 704                         /* LCOV_EXCL_START */
 705                         ERR("invalid parameter (value:%d)", value);
 706                         return CALENDAR_ERROR_INVALID_PARAMETER;
 707                         /* LCOV_EXCL_STOP */
 708                 }
 709                 break;
 710         case CAL_PROPERTY_EVENT_PRIORITY:
 711                 switch (value) {
 712                 case CALENDAR_EVENT_PRIORITY_NONE:
 713                 case CALENDAR_EVENT_PRIORITY_LOW:
 714                 case CALENDAR_EVENT_PRIORITY_NORMAL:
 715                 case CALENDAR_EVENT_PRIORITY_HIGH:
 716                         (rec->priority) = value;
 717                         break;
 718                 default:
 719                         /* LCOV_EXCL_START */
 720                         ERR("invalid parameter (value:%d)", value);
 721                         return CALENDAR_ERROR_INVALID_PARAMETER;
 722                         /* LCOV_EXCL_STOP */
 723                 }
 724                 break;
 725         case CAL_PROPERTY_EVENT_TIMEZONE:
 726                 (rec->timezone) = value;
 727                 break;
 728         case CAL_PROPERTY_EVENT_CONTACT_ID:
 729                 (rec->contact_id) = value;
 730                 break;
 731         case CAL_PROPERTY_EVENT_BUSY_STATUS:
 732                 switch (value) {
 733                 case CALENDAR_EVENT_BUSY_STATUS_FREE:
 734                 case CALENDAR_EVENT_BUSY_STATUS_BUSY:
 735                 case CALENDAR_EVENT_BUSY_STATUS_UNAVAILABLE:
 736                 case CALENDAR_EVENT_BUSY_STATUS_TENTATIVE:
 737                         (rec->busy_status) = value;
 738                         break;
 739                 default:
 740                         /* LCOV_EXCL_START */
 741                         ERR("invalid parameter (value:%d)", value);
 742                         return CALENDAR_ERROR_INVALID_PARAMETER;
 743                         /* LCOV_EXCL_STOP */
 744                 }
 745                 break;
 746         case CAL_PROPERTY_EVENT_SENSITIVITY:
 747                 switch (value) {
 748                 case CALENDAR_SENSITIVITY_PUBLIC:
 749                 case CALENDAR_SENSITIVITY_PRIVATE:
 750                 case CALENDAR_SENSITIVITY_CONFIDENTIAL:
 751                         (rec->sensitivity) = value;
 752                         break;
 753                 default:
 754                         /* LCOV_EXCL_START */
 755                         ERR("invalid parameter (value:%d)", value);
 756                         return CALENDAR_ERROR_INVALID_PARAMETER;
 757                         /* LCOV_EXCL_STOP */
 758                 }
 759                 break;
 760         case CAL_PROPERTY_EVENT_MEETING_STATUS:
 761                 switch (value) {
 762                 case CALENDAR_MEETING_STATUS_NOTMEETING:
 763                 case CALENDAR_MEETING_STATUS_MEETING:
 764                 case CALENDAR_MEETING_STATUS_RECEIVED:
 765                 case CALENDAR_MEETING_STATUS_CANCELED:
 766                         (rec->meeting_status) = value;
 767                         break;
 768                 default:
 769                         /* LCOV_EXCL_START */
 770                         ERR("invalid parameter (value:%d)", value);
 771                         return CALENDAR_ERROR_INVALID_PARAMETER;
 772                         /* LCOV_EXCL_STOP */
 773                 }
 774                 break;
 775         case CAL_PROPERTY_EVENT_ORIGINAL_EVENT_ID:
 776                 (rec->original_event_id) = value;
 777                 break;
 778         case CAL_PROPERTY_EVENT_EMAIL_ID:
 779                 (rec->email_id) = value;
 780                 break;
 781         case CAL_PROPERTY_EVENT_IS_DELETED:
 782                 (rec->is_deleted) = value;
 783                 break;
 784         case CAL_PROPERTY_EVENT_FREQ:
 785                 switch (value) {
 786                 case CALENDAR_RECURRENCE_NONE:
 787                 case CALENDAR_RECURRENCE_DAILY:
 788                 case CALENDAR_RECURRENCE_WEEKLY:
 789                 case CALENDAR_RECURRENCE_MONTHLY:
 790                 case CALENDAR_RECURRENCE_YEARLY:
 791                         (rec->freq) = value;
 792                         break;
 793                 default:
 794                         /* LCOV_EXCL_START */
 795                         ERR("invalid parameter (value:%d)", value);
 796                         return CALENDAR_ERROR_INVALID_PARAMETER;
 797                         /* LCOV_EXCL_STOP */
 798                 }
 799                 break;
 800         case CAL_PROPERTY_EVENT_RANGE_TYPE:
 801                 switch (value) {
 802                 case CALENDAR_RANGE_UNTIL:
 803                 case CALENDAR_RANGE_COUNT:
 804                 case CALENDAR_RANGE_NONE:
 805                         (rec->range_type) = value;
 806                         break;
 807                 default:
 808                         /* LCOV_EXCL_START */
 809                         ERR("invalid parameter (value:%d)", value);
 810                         return CALENDAR_ERROR_INVALID_PARAMETER;
 811                         /* LCOV_EXCL_STOP */
 812                 }
 813                 break;
 814         case CAL_PROPERTY_EVENT_COUNT:
 815                 (rec->count) = value;
 816                 break;
 817         case CAL_PROPERTY_EVENT_INTERVAL:
 818                 (rec->interval) = value;
 819                 break;
 820         case CAL_PROPERTY_EVENT_WKST:
 821                 switch (value) {
 822                 case 0:
 823                         DBG("set wkst as default");
 824                 case CALENDAR_SUNDAY:
 825                 case CALENDAR_MONDAY:
 826                 case CALENDAR_TUESDAY:
 827                 case CALENDAR_WEDNESDAY:
 828                 case CALENDAR_THURSDAY:
 829                 case CALENDAR_FRIDAY:
 830                 case CALENDAR_SATURDAY:
 831                         (rec->wkst) = value;
 832                         break;
 833                 default:
 834                         /* LCOV_EXCL_START */
 835                         ERR("invalid parameter (value:%d)", value);
 836                         return CALENDAR_ERROR_INVALID_PARAMETER;
 837                         /* LCOV_EXCL_STOP */
 838                 }
 839                 break;
 840         case CAL_PROPERTY_EVENT_HAS_ATTENDEE:
 841                 (rec->has_attendee) = value;
 842                 break;
 843         case CAL_PROPERTY_EVENT_HAS_ALARM:
 844                 (rec->has_alarm) = value;
 845                 break;
 846         case CAL_PROPERTY_EVENT_CALENDAR_SYSTEM_TYPE:
 847                 switch (value) {
 848                 case CALENDAR_SYSTEM_NONE:
 849                 case CALENDAR_SYSTEM_GREGORIAN:
 850                 case CALENDAR_SYSTEM_EAST_ASIAN_LUNISOLAR:
 851                         (rec->system_type) = value;
 852                         break;
 853                 default:
 854                         /* LCOV_EXCL_START */
 855                         ERR("invalid parameter (value:%d)", value);
 856                         return CALENDAR_ERROR_INVALID_PARAMETER;
 857                         /* LCOV_EXCL_STOP */
 858                 }
 859                 break;
 860         case CAL_PROPERTY_EVENT_IS_ALLDAY:
 861                 (rec->is_allday) = value;
 862                 break;
 863         default:
 864                 /* LCOV_EXCL_START */
 865                 ERR("invalid parameter (property:0x%x)", property_id);
 866                 return CALENDAR_ERROR_INVALID_PARAMETER;
 867                 /* LCOV_EXCL_STOP */
 868         }
 869
 870         return CALENDAR_ERROR_NONE;
 871 }
 872
 873 static int _cal_record_event_set_double(calendar_record_h record, unsigned int property_id, double value)
 874 {
 875         cal_event_s *rec = (cal_event_s*)(record);
 876         switch (property_id) {
 877         case CAL_PROPERTY_EVENT_LATITUDE:
 878                 (rec->latitude) = value;
 879                 break;
 880         case CAL_PROPERTY_EVENT_LONGITUDE:
 881                 (rec->longitude) = value;
 882                 break;
 883         default:
 884                 /* LCOV_EXCL_START */
 885                 ERR("invalid parameter (property:0x%x)", property_id);
 886                 return CALENDAR_ERROR_INVALID_PARAMETER;
 887                 /* LCOV_EXCL_STOP */
 888         }
 889
 890         return CALENDAR_ERROR_NONE;
 891 }
 892
 893 static int _cal_record_event_set_lli(calendar_record_h record, unsigned int property_id, long long int value)
 894 {
 895         cal_event_s *rec = (cal_event_s*)(record);
 896         switch (property_id) {
 897         case CAL_PROPERTY_EVENT_CREATED_TIME:
 898                 (rec->created_time) = value;
 899                 break;
 900         default:
 901                 /* LCOV_EXCL_START */
 902                 ERR("invalid parameter (property:0x%x)", property_id);
 903                 return CALENDAR_ERROR_INVALID_PARAMETER;
 904                 /* LCOV_EXCL_STOP */
 905         }
 906         return CALENDAR_ERROR_NONE;
 907 }
 908
 909 static int _cal_record_event_set_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s value)
 910 {
 911         cal_event_s *rec = (cal_event_s*)(record);
 912         switch (property_id) {
 913         case CAL_PROPERTY_EVENT_START:
 914                 rec->start = value;
 915                 break;
 916
 917         case CAL_PROPERTY_EVENT_END:
 918                 rec->end = value;
 919                 break;
 920
 921         case CAL_PROPERTY_EVENT_UNTIL:
 922                 rec->until = value;
 923                 break;
 924         default:
 925                 /* LCOV_EXCL_START */
 926                 ERR("invalid parameter (property:0x%x)", property_id);
 927                 return CALENDAR_ERROR_INVALID_PARAMETER;
 928                 /* LCOV_EXCL_STOP */
 929         }
 930
 931         return CALENDAR_ERROR_NONE;
 932 }
 933
 934 static int _cal_record_event_reset_child_record_id(calendar_record_h child_record)
 935 {
 936         cal_record_s *record = (cal_record_s*)child_record;
 937         RETV_IF(NULL == record, CALENDAR_ERROR_INVALID_PARAMETER);
 938
 939         switch (record->type) {
 940         case CAL_RECORD_TYPE_ALARM:
 941                 ((cal_alarm_s *)record)->id = 0;
 942                 break;
 943         case CAL_RECORD_TYPE_ATTENDEE:
 944                 ((cal_attendee_s *)record)->id = 0;
 945                 break;
 946         case CAL_RECORD_TYPE_EXTENDED:
 947                 ((cal_extended_s *)record)->id = 0;
 948                 break;
 949         case CAL_RECORD_TYPE_EVENT:
 950                 ((cal_event_s *)record)->index = 0;
 951                 break;
 952         default:
 953                 /* LCOV_EXCL_START */
 954                 ERR("Invalid child record type (%d)", record->type);
 955                 return CALENDAR_ERROR_INVALID_PARAMETER;
 956                 /* LCOV_EXCL_STOP */
 957         }
 958         return CALENDAR_ERROR_NONE;
 959 }
 960
 961 static int _cal_record_event_add_child_record(calendar_record_h record, unsigned int property_id, calendar_record_h child_record)
 962 {
 963         int ret = CALENDAR_ERROR_NONE;
 964         cal_event_s *rec = (cal_event_s*)(record);
 965         _cal_record_event_reset_child_record_id(child_record);
 966
 967         switch (property_id) {
 968         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
 969                 ret = calendar_list_add((calendar_list_h)rec->alarm_list, child_record);
 970                 rec->has_alarm = 1;
 971                 break;
 972         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
 973                 ret = calendar_list_add((calendar_list_h)rec->attendee_list, child_record);
 974                 rec->has_attendee = 1;
 975                 break;
 976         case CAL_PROPERTY_EVENT_EXCEPTION:
 977                 calendar_list_destroy((calendar_list_h)((cal_event_s *)child_record)->exception_list, true);
 978                 ((cal_event_s *)child_record)->exception_list = calloc(1, sizeof(cal_list_s));
 979                 ret = calendar_list_add((calendar_list_h)rec->exception_list, child_record);
 980                 break;
 981         case CAL_PROPERTY_EVENT_EXTENDED:
 982                 ret = calendar_list_add((calendar_list_h)rec->extended_list, child_record);
 983                 break;
 984         default:
 985                 /* LCOV_EXCL_START */
 986                 ERR("invalid parameter (property:0x%x)", property_id);
 987                 return CALENDAR_ERROR_INVALID_PARAMETER;
 988                 /* LCOV_EXCL_STOP */
 989         }
 990
 991         return ret;
 992 }
 993
 994 static int _cal_record_event_remove_child_record(calendar_record_h record, unsigned int property_id, calendar_record_h child_record)
 995 {
 996         int ret = CALENDAR_ERROR_NONE;
 997         cal_event_s *rec = (cal_event_s *)record;
 998         switch (property_id) {
 999         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
1000                 ret = calendar_list_remove((calendar_list_h)rec->alarm_list, child_record);
1001                 if (rec->alarm_list->count == 0)
1002                         rec->has_alarm = 0;
1003                 break;
1004         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
1005                 ret = calendar_list_remove((calendar_list_h)rec->attendee_list, child_record);
1006                 if (rec->attendee_list->count == 0)
1007                         rec->has_attendee = 0;
1008                 break;
1009         case CAL_PROPERTY_EVENT_EXCEPTION:
1010                 ret = calendar_list_remove((calendar_list_h)rec->exception_list, child_record);
1011                 break;
1012         case CAL_PROPERTY_EVENT_EXTENDED:
1013                 ret = calendar_list_remove((calendar_list_h)rec->extended_list, child_record);
1014                 break;
1015         default:
1016                 /* LCOV_EXCL_START */
1017                 ERR("invalid parameter (property:0x%x)", property_id);
1018                 return CALENDAR_ERROR_INVALID_PARAMETER;
1019                 /* LCOV_EXCL_STOP */
1020         }
1021         return ret;
1022 }
1023
1024 static int _cal_record_event_get_child_record_count(calendar_record_h record, unsigned int property_id, unsigned int* count)
1025 {
1026         int ret = CALENDAR_ERROR_NONE;
1027         cal_event_s *rec = (cal_event_s *)record;
1028
1029         RETV_IF(NULL == count, CALENDAR_ERROR_INVALID_PARAMETER);
1030         *count = 0;
1031
1032         switch (property_id) {
1033         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
1034                 ret = calendar_list_get_count((calendar_list_h)rec->alarm_list, (int *)count);
1035                 break;
1036         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
1037                 ret = calendar_list_get_count((calendar_list_h)rec->attendee_list, (int *)count);
1038                 break;
1039         case CAL_PROPERTY_EVENT_EXCEPTION:
1040                 ret = calendar_list_get_count((calendar_list_h)rec->exception_list, (int *)count);
1041                 break;
1042         case CAL_PROPERTY_EVENT_EXTENDED:
1043                 ret = calendar_list_get_count((calendar_list_h)rec->extended_list, (int *)count);
1044                 break;
1045         default:
1046                 /* LCOV_EXCL_START */
1047                 ERR("invalid parameter (property:0x%x)", property_id);
1048                 return CALENDAR_ERROR_INVALID_PARAMETER;
1049                 /* LCOV_EXCL_STOP */
1050         }
1051         return ret;
1052 }
1053
1054 static int _cal_record_event_get_child_record_at_p(calendar_record_h record, unsigned int property_id, int index, calendar_record_h* child_record)
1055 {
1056         int ret;
1057         cal_event_s *rec = (cal_event_s*)(record);
1058
1059         RETV_IF(NULL == child_record, CALENDAR_ERROR_INVALID_PARAMETER);
1060         *child_record = NULL;
1061
1062         switch (property_id) {
1063         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
1064                 ret = cal_list_get_nth_record_p(rec->alarm_list, index, child_record);
1065                 break;
1066         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
1067                 ret = cal_list_get_nth_record_p(rec->attendee_list, index, child_record);
1068                 break;
1069         case CAL_PROPERTY_EVENT_EXCEPTION:
1070                 ret = cal_list_get_nth_record_p(rec->exception_list, index, child_record);
1071                 break;
1072         case CAL_PROPERTY_EVENT_EXTENDED:
1073                 ret = cal_list_get_nth_record_p(rec->extended_list, index, child_record);
1074                 break;
1075         default:
1076                 /* LCOV_EXCL_START */
1077                 ERR("invalid parameter (property:0x%x)", property_id);
1078                 return CALENDAR_ERROR_INVALID_PARAMETER;
1079                 /* LCOV_EXCL_STOP */
1080         }
1081         return ret;
1082 }
1083
1084 static int _cal_record_event_clone_child_record_list(calendar_record_h record, unsigned int property_id, calendar_list_h* out_list)
1085 {
1086         int ret;
1087         cal_event_s *rec = (cal_event_s*)(record);
1088
1089         RETV_IF(NULL == out_list, CALENDAR_ERROR_INVALID_PARAMETER);
1090         *out_list = NULL;
1091
1092         switch (property_id) {
1093         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
1094                 ret = cal_list_clone((calendar_list_h)rec->alarm_list, out_list);
1095                 break;
1096         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
1097                 ret = cal_list_clone((calendar_list_h)rec->attendee_list, out_list);
1098                 break;
1099         case CAL_PROPERTY_EVENT_EXCEPTION:
1100                 ret = cal_list_clone((calendar_list_h)rec->exception_list, out_list);
1101                 break;
1102         case CAL_PROPERTY_EVENT_EXTENDED:
1103                 ret = cal_list_clone((calendar_list_h)rec->extended_list, out_list);
1104                 break;
1105         default:
1106                 /* LCOV_EXCL_START */
1107                 ERR("invalid parameter (property:0x%x)", property_id);
1108                 return CALENDAR_ERROR_INVALID_PARAMETER;
1109                 /* LCOV_EXCL_STOP */
1110         }
1111         return ret;
1112 }
1113