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                 ERR("invalid parameter (property:0x%x)", property_id);
 340                 return CALENDAR_ERROR_INVALID_PARAMETER;
 341         }
 342
 343         return CALENDAR_ERROR_NONE;
 344 }
 345
 346 static int _cal_record_event_get_str_p(calendar_record_h record, unsigned int property_id, char** out_str)
 347 {
 348         cal_event_s *rec = (cal_event_s*)(record);
 349         switch (property_id) {
 350         case CAL_PROPERTY_EVENT_SUMMARY:
 351                 *out_str = (rec->summary);
 352                 break;
 353         case CAL_PROPERTY_EVENT_DESCRIPTION:
 354                 *out_str = (rec->description);
 355                 break;
 356         case CAL_PROPERTY_EVENT_LOCATION:
 357                 *out_str = (rec->location);
 358                 break;
 359         case CAL_PROPERTY_EVENT_CATEGORIES:
 360                 *out_str = (rec->categories);
 361                 break;
 362         case CAL_PROPERTY_EVENT_EXDATE:
 363                 *out_str = (rec->exdate);
 364                 break;
 365         case CAL_PROPERTY_EVENT_UID:
 366                 *out_str = (rec->uid);
 367                 break;
 368         case CAL_PROPERTY_EVENT_ORGANIZER_NAME:
 369                 *out_str = (rec->organizer_name);
 370                 break;
 371         case CAL_PROPERTY_EVENT_ORGANIZER_EMAIL:
 372                 *out_str = (rec->organizer_email);
 373                 break;
 374         case CAL_PROPERTY_EVENT_BYSECOND:
 375                 *out_str = (rec->bysecond);
 376                 break;
 377         case CAL_PROPERTY_EVENT_BYMINUTE:
 378                 *out_str = (rec->byminute);
 379                 break;
 380         case CAL_PROPERTY_EVENT_BYHOUR:
 381                 *out_str = (rec->byhour);
 382                 break;
 383         case CAL_PROPERTY_EVENT_BYDAY:
 384                 *out_str = (rec->byday);
 385                 break;
 386         case CAL_PROPERTY_EVENT_BYMONTHDAY:
 387                 *out_str = (rec->bymonthday);
 388                 break;
 389         case CAL_PROPERTY_EVENT_BYYEARDAY:
 390                 *out_str = (rec->byyearday);
 391                 break;
 392         case CAL_PROPERTY_EVENT_BYWEEKNO:
 393                 *out_str = (rec->byweekno);
 394                 break;
 395         case CAL_PROPERTY_EVENT_BYMONTH:
 396                 *out_str = (rec->bymonth);
 397                 break;
 398         case CAL_PROPERTY_EVENT_BYSETPOS:
 399                 *out_str = (rec->bysetpos);
 400                 break;
 401         case CAL_PROPERTY_EVENT_RECURRENCE_ID:
 402                 *out_str = (rec->recurrence_id);
 403                 break;
 404         case CAL_PROPERTY_EVENT_RDATE:
 405                 *out_str = (rec->rdate);
 406                 break;
 407         case CAL_PROPERTY_EVENT_SYNC_DATA1:
 408                 *out_str = (rec->sync_data1);
 409                 break;
 410         case CAL_PROPERTY_EVENT_SYNC_DATA2:
 411                 *out_str = (rec->sync_data2);
 412                 break;
 413         case CAL_PROPERTY_EVENT_SYNC_DATA3:
 414                 *out_str = (rec->sync_data3);
 415                 break;
 416         case CAL_PROPERTY_EVENT_SYNC_DATA4:
 417                 *out_str = (rec->sync_data4);
 418                 break;
 419         case CAL_PROPERTY_EVENT_START_TZID:
 420                 *out_str = (rec->start_tzid);
 421                 break;
 422         case CAL_PROPERTY_EVENT_END_TZID:
 423                 *out_str = (rec->end_tzid);
 424                 break;
 425         default:
 426                 ERR("invalid parameter (property:0x%x)", property_id);
 427                 return CALENDAR_ERROR_INVALID_PARAMETER;
 428         }
 429
 430         return CALENDAR_ERROR_NONE;
 431 }
 432
 433 static int _cal_record_event_get_int(calendar_record_h record, unsigned int property_id, int* out_value)
 434 {
 435         cal_event_s *rec = (cal_event_s*)(record);
 436         switch (property_id) {
 437         case CAL_PROPERTY_EVENT_ID:
 438                 *out_value = (rec->index);
 439                 break;
 440         case CAL_PROPERTY_EVENT_CALENDAR_ID:
 441                 *out_value = (rec->calendar_id);
 442                 break;
 443         case CAL_PROPERTY_EVENT_EVENT_STATUS:
 444                 *out_value = (rec->event_status);
 445                 break;
 446         case CAL_PROPERTY_EVENT_PRIORITY:
 447                 *out_value = (rec->priority);
 448                 break;
 449         case CAL_PROPERTY_EVENT_TIMEZONE:
 450                 *out_value = (rec->timezone);
 451                 break;
 452         case CAL_PROPERTY_EVENT_CONTACT_ID:
 453                 *out_value = (rec->contact_id);
 454                 break;
 455         case CAL_PROPERTY_EVENT_BUSY_STATUS:
 456                 *out_value = (rec->busy_status);
 457                 break;
 458         case CAL_PROPERTY_EVENT_SENSITIVITY:
 459                 *out_value = (rec->sensitivity);
 460                 break;
 461         case CAL_PROPERTY_EVENT_MEETING_STATUS:
 462                 *out_value = (rec->meeting_status);
 463                 break;
 464         case CAL_PROPERTY_EVENT_ORIGINAL_EVENT_ID:
 465                 *out_value = (rec->original_event_id);
 466                 break;
 467         case CAL_PROPERTY_EVENT_EMAIL_ID:
 468                 *out_value = (rec->email_id);
 469                 break;
 470         case CAL_PROPERTY_EVENT_IS_DELETED:
 471                 *out_value = (rec->is_deleted);
 472                 break;
 473         case CAL_PROPERTY_EVENT_FREQ:
 474                 *out_value = (rec->freq);
 475                 break;
 476         case CAL_PROPERTY_EVENT_RANGE_TYPE:
 477                 *out_value = (rec->range_type);
 478                 break;
 479         case CAL_PROPERTY_EVENT_COUNT:
 480                 *out_value = (rec->count);
 481                 break;
 482         case CAL_PROPERTY_EVENT_INTERVAL:
 483                 *out_value = (rec->interval);
 484                 break;
 485         case CAL_PROPERTY_EVENT_WKST:
 486                 *out_value = (rec->wkst);
 487                 break;
 488         case CAL_PROPERTY_EVENT_HAS_ATTENDEE:
 489                 *out_value = (rec->has_attendee);
 490                 break;
 491         case CAL_PROPERTY_EVENT_HAS_ALARM:
 492                 *out_value = (rec->has_alarm);
 493                 break;
 494         case CAL_PROPERTY_EVENT_CALENDAR_SYSTEM_TYPE:
 495                 *out_value = (rec->system_type);
 496                 break;
 497         case CAL_PROPERTY_EVENT_IS_ALLDAY:
 498                 *out_value = (rec->is_allday);
 499                 break;
 500         default:
 501                 return CALENDAR_ERROR_INVALID_PARAMETER;
 502         }
 503
 504         return CALENDAR_ERROR_NONE;
 505 }
 506
 507 static int _cal_record_event_get_double(calendar_record_h record, unsigned int property_id, double* out_value)
 508 {
 509         cal_event_s *rec = (cal_event_s*)(record);
 510         switch (property_id) {
 511         case CAL_PROPERTY_EVENT_LATITUDE:
 512                 *out_value = (rec->latitude);
 513                 break;
 514         case CAL_PROPERTY_EVENT_LONGITUDE:
 515                 *out_value = (rec->longitude);
 516                 break;
 517         default:
 518                 ERR("invalid parameter (property:0x%x)", property_id);
 519                 return CALENDAR_ERROR_INVALID_PARAMETER;
 520         }
 521
 522         return CALENDAR_ERROR_NONE;
 523 }
 524
 525 static int _cal_record_event_get_lli(calendar_record_h record, unsigned int property_id, long long int* out_value)
 526 {
 527         cal_event_s *rec = (cal_event_s*)(record);
 528         switch (property_id) {
 529         case CAL_PROPERTY_EVENT_CREATED_TIME:
 530                 *out_value = (rec->created_time);
 531                 break;
 532         case CAL_PROPERTY_EVENT_LAST_MODIFIED_TIME:
 533                 *out_value = (rec->last_mod);
 534                 break;
 535         default:
 536                 return CALENDAR_ERROR_INVALID_PARAMETER;
 537         }
 538
 539         return CALENDAR_ERROR_NONE;
 540 }
 541
 542 static int _cal_record_event_get_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s* out_value)
 543 {
 544         cal_event_s *rec = (cal_event_s*)(record);
 545         switch (property_id) {
 546         case CAL_PROPERTY_EVENT_START:
 547                 *out_value = rec->start;
 548                 break;
 549         case CAL_PROPERTY_EVENT_END:
 550                 *out_value = rec->end;
 551                 break;
 552         case CAL_PROPERTY_EVENT_UNTIL:
 553                 *out_value = rec->until;
 554                 break;
 555         default:
 556                 ERR("invalid parameter (property:0x%x)", property_id);
 557                 return CALENDAR_ERROR_INVALID_PARAMETER;
 558         }
 559
 560         return CALENDAR_ERROR_NONE;
 561 }
 562
 563 static int _cal_record_event_set_str(calendar_record_h record, unsigned int property_id, const char* value)
 564 {
 565         cal_event_s *rec = (cal_event_s*)(record);
 566         switch (property_id) {
 567         case CAL_PROPERTY_EVENT_SUMMARY:
 568                 CAL_FREE(rec->summary);
 569                 rec->summary = cal_strdup(value);
 570                 break;
 571         case CAL_PROPERTY_EVENT_DESCRIPTION:
 572                 CAL_FREE(rec->description);
 573                 rec->description = cal_strdup(value);
 574                 break;
 575         case CAL_PROPERTY_EVENT_LOCATION:
 576                 CAL_FREE(rec->location);
 577                 rec->location = cal_strdup(value);
 578                 break;
 579         case CAL_PROPERTY_EVENT_CATEGORIES:
 580                 CAL_FREE(rec->categories);
 581                 rec->categories = cal_strdup(value);
 582                 break;
 583         case CAL_PROPERTY_EVENT_EXDATE:
 584                 CAL_FREE(rec->exdate);
 585                 rec->exdate = cal_strdup(value);
 586                 break;
 587         case CAL_PROPERTY_EVENT_UID:
 588                 CAL_FREE(rec->uid);
 589                 rec->uid = cal_strdup(value);
 590                 break;
 591         case CAL_PROPERTY_EVENT_ORGANIZER_NAME:
 592                 CAL_FREE(rec->organizer_name);
 593                 rec->organizer_name = cal_strdup(value);
 594                 break;
 595         case CAL_PROPERTY_EVENT_ORGANIZER_EMAIL:
 596                 CAL_FREE(rec->organizer_email);
 597                 rec->organizer_email = cal_strdup(value);
 598                 break;
 599         case CAL_PROPERTY_EVENT_BYSECOND:
 600                 CAL_FREE(rec->bysecond);
 601                 rec->bysecond = cal_strdup_with_sort(value);
 602                 break;
 603         case CAL_PROPERTY_EVENT_BYMINUTE:
 604                 CAL_FREE(rec->byminute);
 605                 rec->byminute = cal_strdup_with_sort(value);
 606                 break;
 607         case CAL_PROPERTY_EVENT_BYHOUR:
 608                 CAL_FREE(rec->byhour);
 609                 rec->byhour = cal_strdup_with_sort(value);
 610                 break;
 611         case CAL_PROPERTY_EVENT_BYDAY:
 612                 CAL_FREE(rec->byday);
 613                 rec->byday = cal_strdup(value);
 614                 break;
 615         case CAL_PROPERTY_EVENT_BYMONTHDAY:
 616                 CAL_FREE(rec->bymonthday);
 617                 rec->bymonthday = cal_strdup_with_sort(value);
 618                 break;
 619         case CAL_PROPERTY_EVENT_BYYEARDAY:
 620                 CAL_FREE(rec->byyearday);
 621                 rec->byyearday = cal_strdup_with_sort(value);
 622                 break;
 623         case CAL_PROPERTY_EVENT_BYWEEKNO:
 624                 CAL_FREE(rec->byweekno);
 625                 rec->byweekno = cal_strdup_with_sort(value);
 626                 break;
 627         case CAL_PROPERTY_EVENT_BYMONTH:
 628                 CAL_FREE(rec->bymonth);
 629                 rec->bymonth = cal_strdup_with_sort(value);
 630                 break;
 631         case CAL_PROPERTY_EVENT_BYSETPOS:
 632                 CAL_FREE(rec->bysetpos);
 633                 rec->bysetpos = cal_strdup_with_sort(value);
 634                 break;
 635         case CAL_PROPERTY_EVENT_RECURRENCE_ID:
 636                 CAL_FREE(rec->recurrence_id);
 637                 rec->recurrence_id = cal_strdup(value);
 638                 break;
 639         case CAL_PROPERTY_EVENT_RDATE:
 640                 CAL_FREE(rec->rdate);
 641                 rec->rdate = cal_strdup(value);
 642                 break;
 643         case CAL_PROPERTY_EVENT_SYNC_DATA1:
 644                 CAL_FREE(rec->sync_data1);
 645                 rec->sync_data1 = cal_strdup(value);
 646                 break;
 647         case CAL_PROPERTY_EVENT_SYNC_DATA2:
 648                 CAL_FREE(rec->sync_data2);
 649                 rec->sync_data2 = cal_strdup(value);
 650                 break;
 651         case CAL_PROPERTY_EVENT_SYNC_DATA3:
 652                 CAL_FREE(rec->sync_data3);
 653                 rec->sync_data3 = cal_strdup(value);
 654                 break;
 655         case CAL_PROPERTY_EVENT_SYNC_DATA4:
 656                 CAL_FREE(rec->sync_data4);
 657                 rec->sync_data4 = cal_strdup(value);
 658                 break;
 659         case CAL_PROPERTY_EVENT_START_TZID:
 660                 CAL_FREE(rec->start_tzid);
 661                 rec->start_tzid = cal_strdup(value);
 662                 break;
 663         case CAL_PROPERTY_EVENT_END_TZID:
 664                 CAL_FREE(rec->end_tzid);
 665                 rec->end_tzid = cal_strdup(value);
 666                 break;
 667         default:
 668                 ERR("invalid parameter (property:0x%x)", property_id);
 669                 return CALENDAR_ERROR_INVALID_PARAMETER;
 670         }
 671
 672         return CALENDAR_ERROR_NONE;
 673 }
 674
 675 static int _cal_record_event_set_int(calendar_record_h record, unsigned int property_id, int value)
 676 {
 677         cal_event_s *rec = (cal_event_s*)(record);
 678         switch (property_id) {
 679         case CAL_PROPERTY_EVENT_ID:
 680                 (rec->index) = value;
 681                 break;
 682         case CAL_PROPERTY_EVENT_CALENDAR_ID:
 683                 (rec->calendar_id) = value;
 684                 break;
 685         case CAL_PROPERTY_EVENT_EVENT_STATUS:
 686                 switch (value) {
 687                 case CALENDAR_EVENT_STATUS_NONE:
 688                 case CALENDAR_EVENT_STATUS_TENTATIVE:
 689                 case CALENDAR_EVENT_STATUS_CONFIRMED:
 690                 case CALENDAR_EVENT_STATUS_CANCELLED:
 691                         (rec->event_status) = value;
 692                         break;
 693                 default:
 694                         ERR("invalid parameter (value:%d)", value);
 695                         return CALENDAR_ERROR_INVALID_PARAMETER;
 696                 }
 697                 break;
 698         case CAL_PROPERTY_EVENT_PRIORITY:
 699                 switch (value) {
 700                 case CALENDAR_EVENT_PRIORITY_NONE:
 701                 case CALENDAR_EVENT_PRIORITY_LOW:
 702                 case CALENDAR_EVENT_PRIORITY_NORMAL:
 703                 case CALENDAR_EVENT_PRIORITY_HIGH:
 704                         (rec->priority) = value;
 705                         break;
 706                 default:
 707                         ERR("invalid parameter (value:%d)", value);
 708                         return CALENDAR_ERROR_INVALID_PARAMETER;
 709                 }
 710                 break;
 711         case CAL_PROPERTY_EVENT_TIMEZONE:
 712                 (rec->timezone) = value;
 713                 break;
 714         case CAL_PROPERTY_EVENT_CONTACT_ID:
 715                 (rec->contact_id) = value;
 716                 break;
 717         case CAL_PROPERTY_EVENT_BUSY_STATUS:
 718                 switch (value) {
 719                 case CALENDAR_EVENT_BUSY_STATUS_FREE:
 720                 case CALENDAR_EVENT_BUSY_STATUS_BUSY:
 721                 case CALENDAR_EVENT_BUSY_STATUS_UNAVAILABLE:
 722                 case CALENDAR_EVENT_BUSY_STATUS_TENTATIVE:
 723                         (rec->busy_status) = value;
 724                         break;
 725                 default:
 726                         ERR("invalid parameter (value:%d)", value);
 727                         return CALENDAR_ERROR_INVALID_PARAMETER;
 728                 }
 729                 break;
 730         case CAL_PROPERTY_EVENT_SENSITIVITY:
 731                 switch (value) {
 732                 case CALENDAR_SENSITIVITY_PUBLIC:
 733                 case CALENDAR_SENSITIVITY_PRIVATE:
 734                 case CALENDAR_SENSITIVITY_CONFIDENTIAL:
 735                         (rec->sensitivity) = value;
 736                         break;
 737                 default:
 738                         ERR("invalid parameter (value:%d)", value);
 739                         return CALENDAR_ERROR_INVALID_PARAMETER;
 740                 }
 741                 break;
 742         case CAL_PROPERTY_EVENT_MEETING_STATUS:
 743                 switch (value) {
 744                 case CALENDAR_MEETING_STATUS_NOTMEETING:
 745                 case CALENDAR_MEETING_STATUS_MEETING:
 746                 case CALENDAR_MEETING_STATUS_RECEIVED:
 747                 case CALENDAR_MEETING_STATUS_CANCELED:
 748                         (rec->meeting_status) = value;
 749                         break;
 750                 default:
 751                         ERR("invalid parameter (value:%d)", value);
 752                         return CALENDAR_ERROR_INVALID_PARAMETER;
 753                 }
 754                 break;
 755         case CAL_PROPERTY_EVENT_ORIGINAL_EVENT_ID:
 756                 (rec->original_event_id) = value;
 757                 break;
 758         case CAL_PROPERTY_EVENT_EMAIL_ID:
 759                 (rec->email_id) = value;
 760                 break;
 761         case CAL_PROPERTY_EVENT_IS_DELETED:
 762                 (rec->is_deleted) = value;
 763                 break;
 764         case CAL_PROPERTY_EVENT_FREQ:
 765                 switch (value) {
 766                 case CALENDAR_RECURRENCE_NONE:
 767                 case CALENDAR_RECURRENCE_DAILY:
 768                 case CALENDAR_RECURRENCE_WEEKLY:
 769                 case CALENDAR_RECURRENCE_MONTHLY:
 770                 case CALENDAR_RECURRENCE_YEARLY:
 771                         (rec->freq) = value;
 772                         break;
 773                 default:
 774                         ERR("invalid parameter (value:%d)", value);
 775                         return CALENDAR_ERROR_INVALID_PARAMETER;
 776                 }
 777                 break;
 778         case CAL_PROPERTY_EVENT_RANGE_TYPE:
 779                 switch (value) {
 780                 case CALENDAR_RANGE_UNTIL:
 781                 case CALENDAR_RANGE_COUNT:
 782                 case CALENDAR_RANGE_NONE:
 783                         (rec->range_type) = value;
 784                         break;
 785                 default:
 786                         ERR("invalid parameter (value:%d)", value);
 787                         return CALENDAR_ERROR_INVALID_PARAMETER;
 788                 }
 789                 break;
 790         case CAL_PROPERTY_EVENT_COUNT:
 791                 (rec->count) = value;
 792                 break;
 793         case CAL_PROPERTY_EVENT_INTERVAL:
 794                 (rec->interval) = value;
 795                 break;
 796         case CAL_PROPERTY_EVENT_WKST:
 797                 switch (value) {
 798                 case 0:
 799                         DBG("set wkst as default");
 800                 case CALENDAR_SUNDAY:
 801                 case CALENDAR_MONDAY:
 802                 case CALENDAR_TUESDAY:
 803                 case CALENDAR_WEDNESDAY:
 804                 case CALENDAR_THURSDAY:
 805                 case CALENDAR_FRIDAY:
 806                 case CALENDAR_SATURDAY:
 807                         (rec->wkst) = value;
 808                         break;
 809                 default:
 810                         ERR("invalid parameter (value:%d)", value);
 811                         return CALENDAR_ERROR_INVALID_PARAMETER;
 812                 }
 813                 break;
 814         case CAL_PROPERTY_EVENT_HAS_ATTENDEE:
 815                 (rec->has_attendee) = value;
 816                 break;
 817         case CAL_PROPERTY_EVENT_HAS_ALARM:
 818                 (rec->has_alarm) = value;
 819                 break;
 820         case CAL_PROPERTY_EVENT_CALENDAR_SYSTEM_TYPE:
 821                 switch (value) {
 822                 case CALENDAR_SYSTEM_NONE:
 823                 case CALENDAR_SYSTEM_GREGORIAN:
 824                 case CALENDAR_SYSTEM_EAST_ASIAN_LUNISOLAR:
 825                         (rec->system_type) = value;
 826                         break;
 827                 default:
 828                         ERR("invalid parameter (value:%d)", value);
 829                         return CALENDAR_ERROR_INVALID_PARAMETER;
 830                 }
 831                 break;
 832         case CAL_PROPERTY_EVENT_IS_ALLDAY:
 833                 (rec->is_allday) = value;
 834                 break;
 835         default:
 836                 ERR("invalid parameter (property:0x%x)", property_id);
 837                 return CALENDAR_ERROR_INVALID_PARAMETER;
 838         }
 839
 840         return CALENDAR_ERROR_NONE;
 841 }
 842
 843 static int _cal_record_event_set_double(calendar_record_h record, unsigned int property_id, double value)
 844 {
 845         cal_event_s *rec = (cal_event_s*)(record);
 846         switch (property_id) {
 847         case CAL_PROPERTY_EVENT_LATITUDE:
 848                 (rec->latitude) = value;
 849                 break;
 850         case CAL_PROPERTY_EVENT_LONGITUDE:
 851                 (rec->longitude) = value;
 852                 break;
 853         default:
 854                 ERR("invalid parameter (property:0x%x)", property_id);
 855                 return CALENDAR_ERROR_INVALID_PARAMETER;
 856         }
 857
 858         return CALENDAR_ERROR_NONE;
 859 }
 860
 861 static int _cal_record_event_set_lli(calendar_record_h record, unsigned int property_id, long long int value)
 862 {
 863         cal_event_s *rec = (cal_event_s*)(record);
 864         switch (property_id) {
 865         case CAL_PROPERTY_EVENT_CREATED_TIME:
 866                 (rec->created_time) = value;
 867                 break;
 868         default:
 869                 ERR("invalid parameter (property:0x%x)", property_id);
 870                 return CALENDAR_ERROR_INVALID_PARAMETER;
 871         }
 872         return CALENDAR_ERROR_NONE;
 873 }
 874
 875 static int _cal_record_event_set_caltime(calendar_record_h record, unsigned int property_id, calendar_time_s value)
 876 {
 877         cal_event_s *rec = (cal_event_s*)(record);
 878         switch (property_id) {
 879         case CAL_PROPERTY_EVENT_START:
 880                 rec->start = value;
 881                 break;
 882
 883         case CAL_PROPERTY_EVENT_END:
 884                 rec->end = value;
 885                 break;
 886
 887         case CAL_PROPERTY_EVENT_UNTIL:
 888                 rec->until = value;
 889                 break;
 890         default:
 891                 ERR("invalid parameter (property:0x%x)", property_id);
 892                 return CALENDAR_ERROR_INVALID_PARAMETER;
 893         }
 894
 895         return CALENDAR_ERROR_NONE;
 896 }
 897
 898 static int _cal_record_event_reset_child_record_id(calendar_record_h child_record)
 899 {
 900         cal_record_s *record = (cal_record_s*)child_record;
 901         RETV_IF(NULL == record, CALENDAR_ERROR_INVALID_PARAMETER);
 902
 903         switch (record->type) {
 904         case CAL_RECORD_TYPE_ALARM:
 905                 ((cal_alarm_s *)record)->id = 0;
 906                 break;
 907         case CAL_RECORD_TYPE_ATTENDEE:
 908                 ((cal_attendee_s *)record)->id = 0;
 909                 break;
 910         case CAL_RECORD_TYPE_EXTENDED:
 911                 ((cal_extended_s *)record)->id = 0;
 912                 break;
 913         case CAL_RECORD_TYPE_EVENT:
 914                 ((cal_event_s *)record)->index = 0;
 915                 break;
 916         default:
 917                 ERR("Invalid child record type (%d)", record->type);
 918                 return CALENDAR_ERROR_INVALID_PARAMETER;
 919         }
 920         return CALENDAR_ERROR_NONE;
 921 }
 922
 923 static int _cal_record_event_add_child_record(calendar_record_h record, unsigned int property_id, calendar_record_h child_record)
 924 {
 925         int ret = CALENDAR_ERROR_NONE;
 926         cal_event_s *rec = (cal_event_s*)(record);
 927         _cal_record_event_reset_child_record_id(child_record);
 928
 929         switch (property_id) {
 930         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
 931                 ret = calendar_list_add((calendar_list_h)rec->alarm_list, child_record);
 932                 rec->has_alarm = 1;
 933                 break;
 934         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
 935                 ret = calendar_list_add((calendar_list_h)rec->attendee_list, child_record);
 936                 rec->has_attendee = 1;
 937                 break;
 938         case CAL_PROPERTY_EVENT_EXCEPTION:
 939                 calendar_list_destroy((calendar_list_h)((cal_event_s *)child_record)->exception_list, true);
 940                 ((cal_event_s *)child_record)->exception_list = calloc(1, sizeof(cal_list_s));
 941                 ret = calendar_list_add((calendar_list_h)rec->exception_list, child_record);
 942                 break;
 943         case CAL_PROPERTY_EVENT_EXTENDED:
 944                 ret = calendar_list_add((calendar_list_h)rec->extended_list, child_record);
 945                 break;
 946         default:
 947                 ERR("invalid parameter (property:0x%x)", property_id);
 948                 return CALENDAR_ERROR_INVALID_PARAMETER;
 949         }
 950
 951         return ret;
 952 }
 953
 954 static int _cal_record_event_remove_child_record(calendar_record_h record, unsigned int property_id, calendar_record_h child_record)
 955 {
 956         int ret = CALENDAR_ERROR_NONE;
 957         cal_event_s *rec = (cal_event_s *)record;
 958         switch (property_id) {
 959         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
 960                 ret = calendar_list_remove((calendar_list_h)rec->alarm_list, child_record);
 961                 if (rec->alarm_list->count == 0)
 962                         rec->has_alarm = 0;
 963                 break;
 964         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
 965                 ret = calendar_list_remove((calendar_list_h)rec->attendee_list, child_record);
 966                 if (rec->attendee_list->count == 0)
 967                         rec->has_attendee = 0;
 968                 break;
 969         case CAL_PROPERTY_EVENT_EXCEPTION:
 970                 ret = calendar_list_remove((calendar_list_h)rec->exception_list, child_record);
 971                 break;
 972         case CAL_PROPERTY_EVENT_EXTENDED:
 973                 ret = calendar_list_remove((calendar_list_h)rec->extended_list, child_record);
 974                 break;
 975         default:
 976                 ERR("invalid parameter (property:0x%x)", property_id);
 977                 return CALENDAR_ERROR_INVALID_PARAMETER;
 978         }
 979         return ret;
 980 }
 981
 982 static int _cal_record_event_get_child_record_count(calendar_record_h record, unsigned int property_id, unsigned int* count)
 983 {
 984         int ret = CALENDAR_ERROR_NONE;
 985         cal_event_s *rec = (cal_event_s *)record;
 986
 987         RETV_IF(NULL == count, CALENDAR_ERROR_INVALID_PARAMETER);
 988         *count = 0;
 989
 990         switch (property_id) {
 991         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
 992                 ret = calendar_list_get_count((calendar_list_h)rec->alarm_list, (int *)count);
 993                 break;
 994         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
 995                 ret = calendar_list_get_count((calendar_list_h)rec->attendee_list, (int *)count);
 996                 break;
 997         case CAL_PROPERTY_EVENT_EXCEPTION:
 998                 ret = calendar_list_get_count((calendar_list_h)rec->exception_list, (int *)count);
 999                 break;
1000         case CAL_PROPERTY_EVENT_EXTENDED:
1001                 ret = calendar_list_get_count((calendar_list_h)rec->extended_list, (int *)count);
1002                 break;
1003         default:
1004                 ERR("invalid parameter (property:0x%x)", property_id);
1005                 return CALENDAR_ERROR_INVALID_PARAMETER;
1006         }
1007         return ret;
1008 }
1009
1010 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)
1011 {
1012         int ret;
1013         cal_event_s *rec = (cal_event_s*)(record);
1014
1015         RETV_IF(NULL == child_record, CALENDAR_ERROR_INVALID_PARAMETER);
1016         *child_record = NULL;
1017
1018         switch (property_id) {
1019         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
1020                 ret = cal_list_get_nth_record_p(rec->alarm_list, index, child_record);
1021                 break;
1022         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
1023                 ret = cal_list_get_nth_record_p(rec->attendee_list, index, child_record);
1024                 break;
1025         case CAL_PROPERTY_EVENT_EXCEPTION:
1026                 ret = cal_list_get_nth_record_p(rec->exception_list, index, child_record);
1027                 break;
1028         case CAL_PROPERTY_EVENT_EXTENDED:
1029                 ret = cal_list_get_nth_record_p(rec->extended_list, index, child_record);
1030                 break;
1031         default:
1032                 ERR("invalid parameter (property:0x%x)", property_id);
1033                 return CALENDAR_ERROR_INVALID_PARAMETER;
1034         }
1035         return ret;
1036 }
1037
1038 static int _cal_record_event_clone_child_record_list(calendar_record_h record, unsigned int property_id, calendar_list_h* out_list)
1039 {
1040         int ret;
1041         cal_event_s *rec = (cal_event_s*)(record);
1042
1043         RETV_IF(NULL == out_list, CALENDAR_ERROR_INVALID_PARAMETER);
1044         *out_list = NULL;
1045
1046         switch (property_id) {
1047         case CAL_PROPERTY_EVENT_CALENDAR_ALARM:
1048                 ret = cal_list_clone((calendar_list_h)rec->alarm_list, out_list);
1049                 break;
1050         case CAL_PROPERTY_EVENT_CALENDAR_ATTENDEE:
1051                 ret = cal_list_clone((calendar_list_h)rec->attendee_list, out_list);
1052                 break;
1053         case CAL_PROPERTY_EVENT_EXCEPTION:
1054                 ret = cal_list_clone((calendar_list_h)rec->exception_list, out_list);
1055                 break;
1056         case CAL_PROPERTY_EVENT_EXTENDED:
1057                 ret = cal_list_clone((calendar_list_h)rec->extended_list, out_list);
1058                 break;
1059         default:
1060                 ERR("invalid parameter (property:0x%x)", property_id);
1061                 return CALENDAR_ERROR_INVALID_PARAMETER;
1062         }
1063         return ret;
1064 }
1065