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         case CAL_PROPERTY_EVENT_LINK_COUNT:
 505                 *out_value = (rec->link_count);
 506                 break;
 507         case CAL_PROPERTY_EVENT_LINK_BASE_ID:
 508                 *out_value = (rec->link_base_id);
 509                 break;
 510         default:
 511                 return CALENDAR_ERROR_INVALID_PARAMETER;
 512         }
 513
 514         return CALENDAR_ERROR_NONE;
 515 }
 516
 517 static int _cal_record_event_get_double(calendar_record_h record, unsigned int property_id, double* out_value)
 518 {
 519         cal_event_s *rec = (cal_event_s*)(record);
 520         switch (property_id) {
 521         case CAL_PROPERTY_EVENT_LATITUDE:
 522                 *out_value = (rec->latitude);
 523                 break;
 524         case CAL_PROPERTY_EVENT_LONGITUDE:
 525                 *out_value = (rec->longitude);
 526                 break;
 527         default:
 528                 /* LCOV_EXCL_START */
 529                 ERR("invalid parameter (property:0x%x)", property_id);
 530                 return CALENDAR_ERROR_INVALID_PARAMETER;
 531                 /* LCOV_EXCL_STOP */
 532         }
 533
 534         return CALENDAR_ERROR_NONE;
 535 }
 536
 537 static int _cal_record_event_get_lli(calendar_record_h record, unsigned int property_id, long long int* out_value)
 538 {
 539         cal_event_s *rec = (cal_event_s*)(record);
 540         switch (property_id) {
 541         case CAL_PROPERTY_EVENT_CREATED_TIME:
 542                 *out_value = (rec->created_time);
 543                 break;
 544         case CAL_PROPERTY_EVENT_LAST_MODIFIED_TIME:
 545                 *out_value = (rec->last_mod);
 546                 break;
 547         default:
 548                 return CALENDAR_ERROR_INVALID_PARAMETER;
 549         }
 550
 551         return CALENDAR_ERROR_NONE;
 552 }
 553
 554 static int _cal_record_event_get_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s* out_value)
 555 {
 556         cal_event_s *rec = (cal_event_s*)(record);
 557         switch (property_id) {
 558         case CAL_PROPERTY_EVENT_START:
 559                 *out_value = rec->start;
 560                 break;
 561         case CAL_PROPERTY_EVENT_END:
 562                 *out_value = rec->end;
 563                 break;
 564         case CAL_PROPERTY_EVENT_UNTIL:
 565                 *out_value = rec->until;
 566                 break;
 567         default:
 568                 /* LCOV_EXCL_START */
 569                 ERR("invalid parameter (property:0x%x)", property_id);
 570                 return CALENDAR_ERROR_INVALID_PARAMETER;
 571                 /* LCOV_EXCL_STOP */
 572         }
 573
 574         return CALENDAR_ERROR_NONE;
 575 }
 576
 577 static int _cal_record_event_set_str(calendar_record_h record, unsigned int property_id, const char* value)
 578 {
 579         cal_event_s *rec = (cal_event_s*)(record);
 580         switch (property_id) {
 581         case CAL_PROPERTY_EVENT_SUMMARY:
 582                 CAL_FREE(rec->summary);
 583                 rec->summary = cal_strdup(value);
 584                 break;
 585         case CAL_PROPERTY_EVENT_DESCRIPTION:
 586                 CAL_FREE(rec->description);
 587                 rec->description = cal_strdup(value);
 588                 break;
 589         case CAL_PROPERTY_EVENT_LOCATION:
 590                 CAL_FREE(rec->location);
 591                 rec->location = cal_strdup(value);
 592                 break;
 593         case CAL_PROPERTY_EVENT_CATEGORIES:
 594                 CAL_FREE(rec->categories);
 595                 rec->categories = cal_strdup(value);
 596                 break;
 597         case CAL_PROPERTY_EVENT_EXDATE:
 598                 CAL_FREE(rec->exdate);
 599                 rec->exdate = cal_strdup(value);
 600                 break;
 601         case CAL_PROPERTY_EVENT_UID:
 602                 CAL_FREE(rec->uid);
 603                 rec->uid = cal_strdup(value);
 604                 break;
 605         case CAL_PROPERTY_EVENT_ORGANIZER_NAME:
 606                 CAL_FREE(rec->organizer_name);
 607                 rec->organizer_name = cal_strdup(value);
 608                 break;
 609         case CAL_PROPERTY_EVENT_ORGANIZER_EMAIL:
 610                 CAL_FREE(rec->organizer_email);
 611                 rec->organizer_email = cal_strdup(value);
 612                 break;
 613         case CAL_PROPERTY_EVENT_BYSECOND:
 614                 CAL_FREE(rec->bysecond);
 615                 rec->bysecond = cal_strdup_with_sort(value);
 616                 break;
 617         case CAL_PROPERTY_EVENT_BYMINUTE:
 618                 CAL_FREE(rec->byminute);
 619                 rec->byminute = cal_strdup_with_sort(value);
 620                 break;
 621         case CAL_PROPERTY_EVENT_BYHOUR:
 622                 CAL_FREE(rec->byhour);
 623                 rec->byhour = cal_strdup_with_sort(value);
 624                 break;
 625         case CAL_PROPERTY_EVENT_BYDAY:
 626                 CAL_FREE(rec->byday);
 627                 rec->byday = cal_strdup(value);
 628                 break;
 629         case CAL_PROPERTY_EVENT_BYMONTHDAY:
 630                 CAL_FREE(rec->bymonthday);
 631                 rec->bymonthday = cal_strdup_with_sort(value);
 632                 break;
 633         case CAL_PROPERTY_EVENT_BYYEARDAY:
 634                 CAL_FREE(rec->byyearday);
 635                 rec->byyearday = cal_strdup_with_sort(value);
 636                 break;
 637         case CAL_PROPERTY_EVENT_BYWEEKNO:
 638                 CAL_FREE(rec->byweekno);
 639                 rec->byweekno = cal_strdup_with_sort(value);
 640                 break;
 641         case CAL_PROPERTY_EVENT_BYMONTH:
 642                 CAL_FREE(rec->bymonth);
 643                 rec->bymonth = cal_strdup_with_sort(value);
 644                 break;
 645         case CAL_PROPERTY_EVENT_BYSETPOS:
 646                 CAL_FREE(rec->bysetpos);
 647                 rec->bysetpos = cal_strdup_with_sort(value);
 648                 break;
 649         case CAL_PROPERTY_EVENT_RECURRENCE_ID:
 650                 CAL_FREE(rec->recurrence_id);
 651                 rec->recurrence_id = cal_strdup(value);
 652                 break;
 653         case CAL_PROPERTY_EVENT_RDATE:
 654                 CAL_FREE(rec->rdate);
 655                 rec->rdate = cal_strdup(value);
 656                 break;
 657         case CAL_PROPERTY_EVENT_SYNC_DATA1:
 658                 CAL_FREE(rec->sync_data1);
 659                 rec->sync_data1 = cal_strdup(value);
 660                 break;
 661         case CAL_PROPERTY_EVENT_SYNC_DATA2:
 662                 CAL_FREE(rec->sync_data2);
 663                 rec->sync_data2 = cal_strdup(value);
 664                 break;
 665         case CAL_PROPERTY_EVENT_SYNC_DATA3:
 666                 CAL_FREE(rec->sync_data3);
 667                 rec->sync_data3 = cal_strdup(value);
 668                 break;
 669         case CAL_PROPERTY_EVENT_SYNC_DATA4:
 670                 CAL_FREE(rec->sync_data4);
 671                 rec->sync_data4 = cal_strdup(value);
 672                 break;
 673         case CAL_PROPERTY_EVENT_START_TZID:
 674                 CAL_FREE(rec->start_tzid);
 675                 rec->start_tzid = cal_strdup(value);
 676                 break;
 677         case CAL_PROPERTY_EVENT_END_TZID:
 678                 CAL_FREE(rec->end_tzid);
 679                 rec->end_tzid = cal_strdup(value);
 680                 break;
 681         default:
 682                 /* LCOV_EXCL_START */
 683                 ERR("invalid parameter (property:0x%x)", property_id);
 684                 return CALENDAR_ERROR_INVALID_PARAMETER;
 685                 /* LCOV_EXCL_STOP */
 686         }
 687
 688         return CALENDAR_ERROR_NONE;
 689 }
 690
 691 static int _cal_record_event_set_int(calendar_record_h record, unsigned int property_id, int value)
 692 {
 693         cal_event_s *rec = (cal_event_s*)(record);
 694         switch (property_id) {
 695         case CAL_PROPERTY_EVENT_ID:
 696                 (rec->index) = value;
 697                 break;
 698         case CAL_PROPERTY_EVENT_BOOK_ID:
 699                 (rec->calendar_id) = value;
 700                 break;
 701         case CAL_PROPERTY_EVENT_EVENT_STATUS:
 702                 switch (value) {
 703                 case CALENDAR_EVENT_STATUS_NONE:
 704                 case CALENDAR_EVENT_STATUS_TENTATIVE:
 705                 case CALENDAR_EVENT_STATUS_CONFIRMED:
 706                 case CALENDAR_EVENT_STATUS_CANCELLED:
 707                         (rec->event_status) = value;
 708                         break;
 709                 default:
 710                         /* LCOV_EXCL_START */
 711                         ERR("invalid parameter (value:%d)", value);
 712                         return CALENDAR_ERROR_INVALID_PARAMETER;
 713                         /* LCOV_EXCL_STOP */
 714                 }
 715                 break;
 716         case CAL_PROPERTY_EVENT_PRIORITY:
 717                 switch (value) {
 718                 case CALENDAR_EVENT_PRIORITY_NONE:
 719                 case CALENDAR_EVENT_PRIORITY_LOW:
 720                 case CALENDAR_EVENT_PRIORITY_NORMAL:
 721                 case CALENDAR_EVENT_PRIORITY_HIGH:
 722                         (rec->priority) = value;
 723                         break;
 724                 default:
 725                         /* LCOV_EXCL_START */
 726                         ERR("invalid parameter (value:%d)", value);
 727                         return CALENDAR_ERROR_INVALID_PARAMETER;
 728                         /* LCOV_EXCL_STOP */
 729                 }
 730                 break;
 731         case CAL_PROPERTY_EVENT_TIMEZONE:
 732                 (rec->timezone) = value;
 733                 break;
 734         case CAL_PROPERTY_EVENT_CONTACT_ID:
 735                 (rec->contact_id) = value;
 736                 break;
 737         case CAL_PROPERTY_EVENT_BUSY_STATUS:
 738                 switch (value) {
 739                 case CALENDAR_EVENT_BUSY_STATUS_FREE:
 740                 case CALENDAR_EVENT_BUSY_STATUS_BUSY:
 741                 case CALENDAR_EVENT_BUSY_STATUS_UNAVAILABLE:
 742                 case CALENDAR_EVENT_BUSY_STATUS_TENTATIVE:
 743                         (rec->busy_status) = value;
 744                         break;
 745                 default:
 746                         /* LCOV_EXCL_START */
 747                         ERR("invalid parameter (value:%d)", value);
 748                         return CALENDAR_ERROR_INVALID_PARAMETER;
 749                         /* LCOV_EXCL_STOP */
 750                 }
 751                 break;
 752         case CAL_PROPERTY_EVENT_SENSITIVITY:
 753                 switch (value) {
 754                 case CALENDAR_SENSITIVITY_PUBLIC:
 755                 case CALENDAR_SENSITIVITY_PRIVATE:
 756                 case CALENDAR_SENSITIVITY_CONFIDENTIAL:
 757                         (rec->sensitivity) = value;
 758                         break;
 759                 default:
 760                         /* LCOV_EXCL_START */
 761                         ERR("invalid parameter (value:%d)", value);
 762                         return CALENDAR_ERROR_INVALID_PARAMETER;
 763                         /* LCOV_EXCL_STOP */
 764                 }
 765                 break;
 766         case CAL_PROPERTY_EVENT_MEETING_STATUS:
 767                 switch (value) {
 768                 case CALENDAR_MEETING_STATUS_NOTMEETING:
 769                 case CALENDAR_MEETING_STATUS_MEETING:
 770                 case CALENDAR_MEETING_STATUS_RECEIVED:
 771                 case CALENDAR_MEETING_STATUS_CANCELED:
 772                         (rec->meeting_status) = value;
 773                         break;
 774                 default:
 775                         /* LCOV_EXCL_START */
 776                         ERR("invalid parameter (value:%d)", value);
 777                         return CALENDAR_ERROR_INVALID_PARAMETER;
 778                         /* LCOV_EXCL_STOP */
 779                 }
 780                 break;
 781         case CAL_PROPERTY_EVENT_ORIGINAL_EVENT_ID:
 782                 (rec->original_event_id) = value;
 783                 break;
 784         case CAL_PROPERTY_EVENT_EMAIL_ID:
 785                 (rec->email_id) = value;
 786                 break;
 787         case CAL_PROPERTY_EVENT_IS_DELETED:
 788                 (rec->is_deleted) = value;
 789                 break;
 790         case CAL_PROPERTY_EVENT_FREQ:
 791                 switch (value) {
 792                 case CALENDAR_RECURRENCE_NONE:
 793                 case CALENDAR_RECURRENCE_DAILY:
 794                 case CALENDAR_RECURRENCE_WEEKLY:
 795                 case CALENDAR_RECURRENCE_MONTHLY:
 796                 case CALENDAR_RECURRENCE_YEARLY:
 797                         (rec->freq) = value;
 798                         break;
 799                 default:
 800                         /* LCOV_EXCL_START */
 801                         ERR("invalid parameter (value:%d)", value);
 802                         return CALENDAR_ERROR_INVALID_PARAMETER;
 803                         /* LCOV_EXCL_STOP */
 804                 }
 805                 break;
 806         case CAL_PROPERTY_EVENT_RANGE_TYPE:
 807                 switch (value) {
 808                 case CALENDAR_RANGE_UNTIL:
 809                 case CALENDAR_RANGE_COUNT:
 810                 case CALENDAR_RANGE_NONE:
 811                         (rec->range_type) = value;
 812                         break;
 813                 default:
 814                         /* LCOV_EXCL_START */
 815                         ERR("invalid parameter (value:%d)", value);
 816                         return CALENDAR_ERROR_INVALID_PARAMETER;
 817                         /* LCOV_EXCL_STOP */
 818                 }
 819                 break;
 820         case CAL_PROPERTY_EVENT_COUNT:
 821                 (rec->count) = value;
 822                 break;
 823         case CAL_PROPERTY_EVENT_INTERVAL:
 824                 (rec->interval) = value;
 825                 break;
 826         case CAL_PROPERTY_EVENT_WKST:
 827                 switch (value) {
 828                 case 0:
 829                         DBG("set wkst as default");
 830                 case CALENDAR_SUNDAY:
 831                 case CALENDAR_MONDAY:
 832                 case CALENDAR_TUESDAY:
 833                 case CALENDAR_WEDNESDAY:
 834                 case CALENDAR_THURSDAY:
 835                 case CALENDAR_FRIDAY:
 836                 case CALENDAR_SATURDAY:
 837                         (rec->wkst) = value;
 838                         break;
 839                 default:
 840                         /* LCOV_EXCL_START */
 841                         ERR("invalid parameter (value:%d)", value);
 842                         return CALENDAR_ERROR_INVALID_PARAMETER;
 843                         /* LCOV_EXCL_STOP */
 844                 }
 845                 break;
 846         case CAL_PROPERTY_EVENT_HAS_ATTENDEE:
 847                 (rec->has_attendee) = value;
 848                 break;
 849         case CAL_PROPERTY_EVENT_HAS_ALARM:
 850                 (rec->has_alarm) = value;
 851                 break;
 852         case CAL_PROPERTY_EVENT_CALENDAR_SYSTEM_TYPE:
 853                 switch (value) {
 854                 case CALENDAR_SYSTEM_NONE:
 855                 case CALENDAR_SYSTEM_GREGORIAN:
 856                 case CALENDAR_SYSTEM_EAST_ASIAN_LUNISOLAR:
 857                         (rec->system_type) = value;
 858                         break;
 859                 default:
 860                         /* LCOV_EXCL_START */
 861                         ERR("invalid parameter (value:%d)", value);
 862                         return CALENDAR_ERROR_INVALID_PARAMETER;
 863                         /* LCOV_EXCL_STOP */
 864                 }
 865                 break;
 866         case CAL_PROPERTY_EVENT_IS_ALLDAY:
 867                 (rec->is_allday) = value;
 868                 break;
 869         default:
 870                 /* LCOV_EXCL_START */
 871                 ERR("invalid parameter (property:0x%x)", property_id);
 872                 return CALENDAR_ERROR_INVALID_PARAMETER;
 873                 /* LCOV_EXCL_STOP */
 874         }
 875
 876         return CALENDAR_ERROR_NONE;
 877 }
 878
 879 static int _cal_record_event_set_double(calendar_record_h record, unsigned int property_id, double value)
 880 {
 881         cal_event_s *rec = (cal_event_s*)(record);
 882         switch (property_id) {
 883         case CAL_PROPERTY_EVENT_LATITUDE:
 884                 (rec->latitude) = value;
 885                 break;
 886         case CAL_PROPERTY_EVENT_LONGITUDE:
 887                 (rec->longitude) = value;
 888                 break;
 889         default:
 890                 /* LCOV_EXCL_START */
 891                 ERR("invalid parameter (property:0x%x)", property_id);
 892                 return CALENDAR_ERROR_INVALID_PARAMETER;
 893                 /* LCOV_EXCL_STOP */
 894         }
 895
 896         return CALENDAR_ERROR_NONE;
 897 }
 898
 899 static int _cal_record_event_set_lli(calendar_record_h record, unsigned int property_id, long long int value)
 900 {
 901         cal_event_s *rec = (cal_event_s*)(record);
 902         switch (property_id) {
 903         case CAL_PROPERTY_EVENT_CREATED_TIME:
 904                 (rec->created_time) = value;
 905                 break;
 906         default:
 907                 /* LCOV_EXCL_START */
 908                 ERR("invalid parameter (property:0x%x)", property_id);
 909                 return CALENDAR_ERROR_INVALID_PARAMETER;
 910                 /* LCOV_EXCL_STOP */
 911         }
 912         return CALENDAR_ERROR_NONE;
 913 }
 914
 915 static int _cal_record_event_set_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s value)
 916 {
 917         cal_event_s *rec = (cal_event_s*)(record);
 918         switch (property_id) {
 919         case CAL_PROPERTY_EVENT_START:
 920                 rec->start = value;
 921                 break;
 922
 923         case CAL_PROPERTY_EVENT_END:
 924                 rec->end = value;
 925                 break;
 926
 927         case CAL_PROPERTY_EVENT_UNTIL:
 928                 rec->until = value;
 929                 break;
 930         default:
 931                 /* LCOV_EXCL_START */
 932                 ERR("invalid parameter (property:0x%x)", property_id);
 933                 return CALENDAR_ERROR_INVALID_PARAMETER;
 934                 /* LCOV_EXCL_STOP */
 935         }
 936
 937         return CALENDAR_ERROR_NONE;
 938 }
 939
 940 static int _cal_record_event_reset_child_record_id(calendar_record_h child_record)
 941 {
 942         cal_record_s *record = (cal_record_s*)child_record;
 943         RETV_IF(NULL == record, CALENDAR_ERROR_INVALID_PARAMETER);
 944
 945         switch (record->type) {
 946         case CAL_RECORD_TYPE_ALARM:
 947                 ((cal_alarm_s *)record)->id = 0;
 948                 break;
 949         case CAL_RECORD_TYPE_ATTENDEE:
 950                 ((cal_attendee_s *)record)->id = 0;
 951                 break;
 952         case CAL_RECORD_TYPE_EXTENDED:
 953                 ((cal_extended_s *)record)->id = 0;
 954                 break;
 955         case CAL_RECORD_TYPE_EVENT:
 956                 ((cal_event_s *)record)->index = 0;
 957                 break;
 958         default:
 959                 /* LCOV_EXCL_START */
 960                 ERR("Invalid child record type (%d)", record->type);
 961                 return CALENDAR_ERROR_INVALID_PARAMETER;
 962                 /* LCOV_EXCL_STOP */
 963         }
 964         return CALENDAR_ERROR_NONE;
 965 }
 966
 967 static int _cal_record_event_add_child_record(calendar_record_h record, unsigned int property_id, calendar_record_h child_record)
 968 {
 969         int ret = CALENDAR_ERROR_NONE;
 970         cal_event_s *rec = (cal_event_s*)(record);
 971         _cal_record_event_reset_child_record_id(child_record);
 972
 973         switch (property_id) {
 974         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
 975                 ret = calendar_list_add((calendar_list_h)rec->alarm_list, child_record);
 976                 rec->has_alarm = 1;
 977                 break;
 978         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
 979                 ret = calendar_list_add((calendar_list_h)rec->attendee_list, child_record);
 980                 rec->has_attendee = 1;
 981                 break;
 982         case CAL_PROPERTY_EVENT_EXCEPTION:
 983                 calendar_list_destroy((calendar_list_h)((cal_event_s *)child_record)->exception_list, true);
 984                 ((cal_event_s *)child_record)->exception_list = calloc(1, sizeof(cal_list_s));
 985                 ret = calendar_list_add((calendar_list_h)rec->exception_list, child_record);
 986                 break;
 987         case CAL_PROPERTY_EVENT_EXTENDED:
 988                 ret = calendar_list_add((calendar_list_h)rec->extended_list, child_record);
 989                 break;
 990         default:
 991                 /* LCOV_EXCL_START */
 992                 ERR("invalid parameter (property:0x%x)", property_id);
 993                 return CALENDAR_ERROR_INVALID_PARAMETER;
 994                 /* LCOV_EXCL_STOP */
 995         }
 996
 997         return ret;
 998 }
 999
1000 static int _cal_record_event_remove_child_record(calendar_record_h record, unsigned int property_id, calendar_record_h child_record)
1001 {
1002         int ret = CALENDAR_ERROR_NONE;
1003         cal_event_s *rec = (cal_event_s *)record;
1004         switch (property_id) {
1005         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
1006                 ret = calendar_list_remove((calendar_list_h)rec->alarm_list, child_record);
1007                 if (rec->alarm_list->count == 0)
1008                         rec->has_alarm = 0;
1009                 break;
1010         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
1011                 ret = calendar_list_remove((calendar_list_h)rec->attendee_list, child_record);
1012                 if (rec->attendee_list->count == 0)
1013                         rec->has_attendee = 0;
1014                 break;
1015         case CAL_PROPERTY_EVENT_EXCEPTION:
1016                 ret = calendar_list_remove((calendar_list_h)rec->exception_list, child_record);
1017                 break;
1018         case CAL_PROPERTY_EVENT_EXTENDED:
1019                 ret = calendar_list_remove((calendar_list_h)rec->extended_list, child_record);
1020                 break;
1021         default:
1022                 /* LCOV_EXCL_START */
1023                 ERR("invalid parameter (property:0x%x)", property_id);
1024                 return CALENDAR_ERROR_INVALID_PARAMETER;
1025                 /* LCOV_EXCL_STOP */
1026         }
1027         return ret;
1028 }
1029
1030 static int _cal_record_event_get_child_record_count(calendar_record_h record, unsigned int property_id, unsigned int* count)
1031 {
1032         int ret = CALENDAR_ERROR_NONE;
1033         cal_event_s *rec = (cal_event_s *)record;
1034
1035         RETV_IF(NULL == count, CALENDAR_ERROR_INVALID_PARAMETER);
1036         *count = 0;
1037
1038         switch (property_id) {
1039         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
1040                 ret = calendar_list_get_count((calendar_list_h)rec->alarm_list, (int *)count);
1041                 break;
1042         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
1043                 ret = calendar_list_get_count((calendar_list_h)rec->attendee_list, (int *)count);
1044                 break;
1045         case CAL_PROPERTY_EVENT_EXCEPTION:
1046                 ret = calendar_list_get_count((calendar_list_h)rec->exception_list, (int *)count);
1047                 break;
1048         case CAL_PROPERTY_EVENT_EXTENDED:
1049                 ret = calendar_list_get_count((calendar_list_h)rec->extended_list, (int *)count);
1050                 break;
1051         default:
1052                 /* LCOV_EXCL_START */
1053                 ERR("invalid parameter (property:0x%x)", property_id);
1054                 return CALENDAR_ERROR_INVALID_PARAMETER;
1055                 /* LCOV_EXCL_STOP */
1056         }
1057         return ret;
1058 }
1059
1060 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)
1061 {
1062         int ret;
1063         cal_event_s *rec = (cal_event_s*)(record);
1064
1065         RETV_IF(NULL == child_record, CALENDAR_ERROR_INVALID_PARAMETER);
1066         *child_record = NULL;
1067
1068         switch (property_id) {
1069         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
1070                 ret = cal_list_get_nth_record_p(rec->alarm_list, index, child_record);
1071                 break;
1072         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
1073                 ret = cal_list_get_nth_record_p(rec->attendee_list, index, child_record);
1074                 break;
1075         case CAL_PROPERTY_EVENT_EXCEPTION:
1076                 ret = cal_list_get_nth_record_p(rec->exception_list, index, child_record);
1077                 break;
1078         case CAL_PROPERTY_EVENT_EXTENDED:
1079                 ret = cal_list_get_nth_record_p(rec->extended_list, index, child_record);
1080                 break;
1081         default:
1082                 /* LCOV_EXCL_START */
1083                 ERR("invalid parameter (property:0x%x)", property_id);
1084                 return CALENDAR_ERROR_INVALID_PARAMETER;
1085                 /* LCOV_EXCL_STOP */
1086         }
1087         return ret;
1088 }
1089
1090 static int _cal_record_event_clone_child_record_list(calendar_record_h record, unsigned int property_id, calendar_list_h* out_list)
1091 {
1092         int ret;
1093         cal_event_s *rec = (cal_event_s*)(record);
1094
1095         RETV_IF(NULL == out_list, CALENDAR_ERROR_INVALID_PARAMETER);
1096         *out_list = NULL;
1097
1098         switch (property_id) {
1099         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
1100                 ret = cal_list_clone((calendar_list_h)rec->alarm_list, out_list);
1101                 break;
1102         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
1103                 ret = cal_list_clone((calendar_list_h)rec->attendee_list, out_list);
1104                 break;
1105         case CAL_PROPERTY_EVENT_EXCEPTION:
1106                 ret = cal_list_clone((calendar_list_h)rec->exception_list, out_list);
1107                 break;
1108         case CAL_PROPERTY_EVENT_EXTENDED:
1109                 ret = cal_list_clone((calendar_list_h)rec->extended_list, out_list);
1110                 break;
1111         default:
1112                 /* LCOV_EXCL_START */
1113                 ERR("invalid parameter (property:0x%x)", property_id);
1114                 return CALENDAR_ERROR_INVALID_PARAMETER;
1115                 /* LCOV_EXCL_STOP */
1116         }
1117         return ret;
1118 }
1119