common/cal_record_todo.c

   1 /*
   2  * Calendar Service
   3  *
   4  * Copyright (c) 2012 - 2013 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 #include <stdlib.h>             //calloc
  20 #include <stdbool.h>            //bool
  21 #include <string.h>
  22
  23 #include "calendar_list.h"
  24
  25 #include "cal_internal.h"
  26 #include "cal_typedef.h"
  27 #include "cal_view.h"
  28
  29 #include "cal_record.h"
  30
  31 static int __cal_record_todo_create( calendar_record_h* out_record );
  32 static int __cal_record_todo_destroy( calendar_record_h record, bool delete_child );
  33 static int __cal_record_todo_clone( calendar_record_h record, calendar_record_h* out_record );
  34 static int __cal_record_todo_get_str( calendar_record_h record, unsigned int property_id, char** out_str );
  35 static int __cal_record_todo_get_str_p( calendar_record_h record, unsigned int property_id, char** out_str );
  36 static int __cal_record_todo_get_int( calendar_record_h record, unsigned int property_id, int* out_value );
  37 static int __cal_record_todo_get_double( calendar_record_h record, unsigned int property_id, double* out_value );
  38 static int __cal_record_todo_get_lli( calendar_record_h record, unsigned int property_id, long long int* out_value );
  39 static int __cal_record_todo_get_caltime( calendar_record_h record, unsigned int property_id, calendar_time_s* out_value );
  40 static int __cal_record_todo_set_str( calendar_record_h record, unsigned int property_id, const char* value );
  41 static int __cal_record_todo_set_int( calendar_record_h record, unsigned int property_id, int value );
  42 static int __cal_record_todo_set_double( calendar_record_h record, unsigned int property_id, double value );
  43 static int __cal_record_todo_set_lli( calendar_record_h record, unsigned int property_id, long long int value );
  44 static int __cal_record_todo_set_caltime( calendar_record_h record, unsigned int property_id, calendar_time_s value );
  45 static int __cal_record_todo_add_child_record( calendar_record_h record, unsigned int property_id, calendar_record_h child_record );
  46 static int __cal_record_todo_remove_child_record( calendar_record_h record, unsigned int property_id, calendar_record_h child_record );
  47 static int __cal_record_todo_get_child_record_count( calendar_record_h record, unsigned int property_id, unsigned int* count  );
  48 static int __cal_record_todo_get_child_record_at_p( calendar_record_h record, unsigned int property_id, int index, calendar_record_h* child_record );
  49 static int __cal_record_todo_clone_child_record_list( calendar_record_h record, unsigned int property_id, calendar_list_h* out_list );
  50
  51 cal_record_plugin_cb_s _cal_record_todo_plugin_cb = {
  52     .create = __cal_record_todo_create,
  53     .destroy = __cal_record_todo_destroy,
  54     .clone = __cal_record_todo_clone,
  55     .get_str = __cal_record_todo_get_str,
  56     .get_str_p = __cal_record_todo_get_str_p,
  57     .get_int = __cal_record_todo_get_int,
  58     .get_double = __cal_record_todo_get_double,
  59     .get_lli = __cal_record_todo_get_lli,
  60     .get_caltime = __cal_record_todo_get_caltime,
  61     .set_str = __cal_record_todo_set_str,
  62     .set_int = __cal_record_todo_set_int,
  63     .set_double = __cal_record_todo_set_double,
  64     .set_lli = __cal_record_todo_set_lli,
  65     .set_caltime = __cal_record_todo_set_caltime,
  66     .add_child_record = __cal_record_todo_add_child_record,
  67     .remove_child_record = __cal_record_todo_remove_child_record,
  68     .get_child_record_count = __cal_record_todo_get_child_record_count,
  69     .get_child_record_at_p = __cal_record_todo_get_child_record_at_p,
  70     .clone_child_record_list = __cal_record_todo_clone_child_record_list
  71 };
  72
  73 static void __cal_record_todo_struct_init(cal_todo_s *record)
  74 {
  75     memset(record,0,sizeof(cal_todo_s));
  76
  77     record->todo_status = CALENDAR_TODO_STATUS_NONE;
  78     record->calendar_id = DEFAULT_TODO_CALENDAR_BOOK_ID;
  79
  80     record->index = CAL_INVALID_ID;
  81     record->summary = NULL;
  82     record->description = NULL;
  83     record->location= NULL;
  84     record->categories = NULL;
  85     record->uid= NULL;
  86     record->is_deleted = 0;
  87     record->latitude = 1000; // set default 1000 out of range(-180 ~ 180)
  88     record->longitude = 1000; // set default 1000 out of range(-180 ~ 180)
  89     record->freq = CALENDAR_RECURRENCE_NONE;
  90     record->until_utime = CALENDAR_RECORD_NO_UNTIL;
  91     record->start.time.utime = CALENDAR_TODO_NO_START_DATE;
  92     record->due.time.utime = CALENDAR_TODO_NO_DUE_DATE;
  93
  94     return ;
  95 }
  96
  97 static int __cal_record_todo_create( calendar_record_h* out_record )
  98 {
  99     cal_todo_s *temp = NULL;
 100     int ret= CALENDAR_ERROR_NONE, type = 0;
 101
 102     type = CAL_RECORD_TYPE_TODO;
 103
 104     temp = (cal_todo_s*)calloc(1,sizeof(cal_todo_s));
 105     retvm_if(NULL == temp, CALENDAR_ERROR_OUT_OF_MEMORY, "malloc(cal_todo_s) Failed(%d)", CALENDAR_ERROR_OUT_OF_MEMORY);
 106
 107     __cal_record_todo_struct_init(temp);
 108
 109     *out_record = (calendar_record_h)temp;
 110
 111     return ret;
 112 }
 113
 114 static void __cal_record_todo_struct_free(cal_todo_s *record, bool delete_child)
 115 {
 116     CAL_FREE(record->summary);
 117     CAL_FREE(record->description);
 118     CAL_FREE(record->location);
 119     CAL_FREE(record->categories);
 120     CAL_FREE(record->uid);
 121     CAL_FREE(record->start_tzid);
 122     CAL_FREE(record->due_tzid);
 123
 124     CAL_FREE(record->bysecond);
 125     CAL_FREE(record->byminute);
 126     CAL_FREE(record->byhour);
 127     CAL_FREE(record->byday);
 128     CAL_FREE(record->bymonthday);
 129     CAL_FREE(record->byyearday);
 130     CAL_FREE(record->byweekno);
 131     CAL_FREE(record->bymonth);
 132     CAL_FREE(record->bysetpos);
 133
 134     CAL_FREE(record->sync_data1);
 135     CAL_FREE(record->sync_data2);
 136     CAL_FREE(record->sync_data3);
 137     CAL_FREE(record->sync_data4);
 138
 139     CAL_FREE(record->organizer_name);
 140     CAL_FREE(record->organizer_email);
 141
 142     if (delete_child == true)
 143     {
 144         if( record->alarm_list )
 145         {
 146             GList *alarm_list = record->alarm_list;
 147             calendar_record_h alarm_child_record = NULL;
 148             while (alarm_list)
 149             {
 150                 alarm_child_record = (calendar_record_h)alarm_list->data;
 151                 if (alarm_child_record == NULL)
 152                 {
 153                     alarm_list = g_list_next(alarm_list);
 154                     continue;
 155                 }
 156
 157                 calendar_record_destroy(alarm_child_record, true);
 158
 159                 alarm_list = g_list_next(alarm_list);
 160             }
 161             g_list_free(record->alarm_list);
 162             record->alarm_list = NULL;
 163         }
 164
 165         if( record->attendee_list )
 166         {
 167             GList * attendee_list = g_list_first(record->attendee_list);
 168             calendar_record_h attendee = NULL;
 169
 170             while (attendee_list)
 171             {
 172                 attendee = (calendar_record_h)attendee_list->data;
 173                 if (attendee == NULL)
 174                 {
 175                     attendee_list = g_list_next(attendee_list);
 176                     continue;
 177                 }
 178
 179                 calendar_record_destroy(attendee, true);
 180
 181                 attendee_list = g_list_next(attendee_list);
 182             }
 183             g_list_free(record->attendee_list);
 184             record->attendee_list = NULL;
 185         }
 186         if( record->extended_list )
 187         {
 188             GList * extended_list = g_list_first(record->extended_list);
 189             calendar_record_h extended = NULL;
 190
 191             while (extended_list)
 192             {
 193                 extended = (calendar_record_h)extended_list->data;
 194                 if (extended == NULL)
 195                 {
 196                     extended_list = g_list_next(extended_list);
 197                     continue;
 198                 }
 199
 200                 calendar_record_destroy(extended, true);
 201
 202                 extended_list = g_list_next(extended_list);
 203             }
 204             g_list_free(record->extended_list);
 205             record->extended_list = NULL;
 206         }
 207     }
 208
 209     CAL_FREE(record);
 210 }
 211
 212 static int __cal_record_todo_destroy( calendar_record_h record, bool delete_child )
 213 {
 214     int ret = CALENDAR_ERROR_NONE;
 215
 216     cal_todo_s *temp = (cal_todo_s*)(record);
 217
 218     __cal_record_todo_struct_free(temp, delete_child);
 219
 220     return ret;
 221 }
 222
 223 static int __cal_record_todo_clone( calendar_record_h record, calendar_record_h* out_record )
 224 {
 225     cal_todo_s *out_data = NULL;
 226     cal_todo_s *src_data = NULL;
 227
 228     src_data = (cal_todo_s*)(record);
 229
 230     out_data = calloc(1, sizeof(cal_todo_s));
 231     retvm_if(NULL == out_data, CALENDAR_ERROR_OUT_OF_MEMORY, "calloc(cal_todo_s) Failed(%d)", CALENDAR_ERROR_OUT_OF_MEMORY);
 232
 233
 234     CAL_RECORD_COPY_COMMON(&(out_data->common), &(src_data->common));
 235
 236     out_data->index = src_data->index;
 237     out_data->summary = SAFE_STRDUP(src_data->summary);
 238     out_data->description = SAFE_STRDUP(src_data->description);
 239     out_data->location = SAFE_STRDUP(src_data->location);
 240     out_data->categories = SAFE_STRDUP(src_data->categories);
 241
 242     out_data->todo_status = src_data->todo_status;
 243     out_data->priority = src_data->priority;
 244     out_data->sensitivity = src_data->sensitivity;
 245
 246     out_data->uid = SAFE_STRDUP(src_data->uid);
 247
 248     out_data->calendar_id = src_data->calendar_id;
 249     out_data->latitude = src_data->latitude;
 250     out_data->longitude = src_data->longitude;
 251
 252     out_data->created_time = src_data->created_time;
 253     out_data->completed_time = src_data->completed_time;
 254     out_data->progress = src_data->progress;
 255     out_data->is_deleted = src_data->is_deleted;
 256     out_data->last_mod = src_data->last_mod;
 257
 258     out_data->freq = src_data->freq;
 259     out_data->range_type = src_data->range_type;
 260     out_data->until_type = src_data->until_type;
 261     out_data->until_utime = src_data->until_utime;
 262     out_data->until_year = src_data->until_year;
 263     out_data->until_month = src_data->until_month;
 264     out_data->until_mday = src_data->until_mday;
 265     out_data->count = src_data->count;
 266     out_data->interval = src_data->interval;
 267     out_data->bysecond = SAFE_STRDUP(src_data->bysecond);
 268     out_data->byminute = SAFE_STRDUP(src_data->byminute);
 269     out_data->byhour = SAFE_STRDUP(src_data->byhour);
 270     out_data->byday = SAFE_STRDUP(src_data->byday);
 271     out_data->bymonthday = SAFE_STRDUP(src_data->bymonthday);
 272     out_data->byyearday = SAFE_STRDUP(src_data->byyearday);
 273     out_data->byweekno = SAFE_STRDUP(src_data->byweekno);
 274     out_data->bymonth = SAFE_STRDUP(src_data->bymonth);
 275     out_data->bysetpos = SAFE_STRDUP(src_data->bysetpos);
 276     out_data->wkst = src_data->wkst;
 277     out_data->has_alarm = src_data->has_alarm;
 278     out_data->updated = src_data->updated;
 279
 280     out_data->sync_data1 = SAFE_STRDUP(src_data->sync_data1);
 281     out_data->sync_data2 = SAFE_STRDUP(src_data->sync_data2);
 282     out_data->sync_data3 = SAFE_STRDUP(src_data->sync_data3);
 283     out_data->sync_data4 = SAFE_STRDUP(src_data->sync_data4);
 284
 285     out_data->start = src_data->start;
 286     out_data->start_tzid = SAFE_STRDUP(src_data->start_tzid);
 287     out_data->due = src_data->due;
 288     out_data->due_tzid = SAFE_STRDUP(src_data->due_tzid);
 289
 290     out_data->organizer_name = SAFE_STRDUP(src_data->organizer_name);
 291     out_data->organizer_email = SAFE_STRDUP(src_data->organizer_email);
 292     out_data->has_attendee = src_data->has_attendee;
 293
 294     if( src_data->alarm_list )
 295     {
 296         GList *alarm_list = src_data->alarm_list;
 297         calendar_record_h alarm_child_record;
 298
 299         while (alarm_list)
 300         {
 301             calendar_record_h child_clone = NULL;
 302             alarm_child_record = (calendar_record_h)alarm_list->data;
 303             if (alarm_child_record == NULL)
 304             {
 305                 alarm_list = g_list_next(alarm_list);
 306                 continue;
 307             }
 308             if (calendar_record_clone(alarm_child_record, &child_clone) == CALENDAR_ERROR_NONE)
 309             {
 310                 calendar_record_add_child_record((calendar_record_h)out_data,
 311                                                 CAL_PROPERTY_TODO_CALENDAR_ALARM,child_clone);
 312
 313             }
 314                         alarm_list = g_list_next(alarm_list);
 315         }
 316
 317     }
 318
 319     if( src_data->attendee_list )
 320     {
 321         GList * attendee_list = src_data->attendee_list;
 322         calendar_record_h attendee_child = NULL;
 323
 324         while (attendee_list)
 325         {
 326             calendar_record_h child_clone = NULL;
 327             attendee_child = (calendar_record_h)attendee_list->data;
 328             if (attendee_child == NULL)
 329             {
 330                 attendee_list = g_list_next(attendee_list);
 331                 continue;
 332             }
 333             if (calendar_record_clone(attendee_child, &child_clone) == CALENDAR_ERROR_NONE)
 334             {
 335
 336                 calendar_record_add_child_record((calendar_record_h)out_data,
 337                         CAL_PROPERTY_TODO_CALENDAR_ATTENDEE,child_clone);
 338
 339             }
 340                         attendee_list = g_list_next(attendee_list);
 341         }
 342
 343     }
 344
 345     if( src_data->extended_list )
 346     {
 347         GList * extended_list = src_data->extended_list;
 348         calendar_record_h extended = NULL;
 349
 350         while (extended_list)
 351         {
 352             calendar_record_h child_clone = NULL;
 353             extended = (calendar_record_h)extended_list->data;
 354             if (extended == NULL)
 355             {
 356                 extended_list = g_list_next(extended_list);
 357                 continue;
 358             }
 359             if (calendar_record_clone(extended, &child_clone) == CALENDAR_ERROR_NONE)
 360             {
 361
 362                 calendar_record_add_child_record((calendar_record_h)out_data,
 363                         CAL_PROPERTY_TODO_EXTENDED,child_clone);
 364
 365             }
 366             extended_list = g_list_next(extended_list);
 367         }
 368
 369     }
 370
 371     *out_record = (calendar_record_h)out_data;
 372
 373     return CALENDAR_ERROR_NONE;
 374 }
 375
 376 static int __cal_record_todo_get_str( calendar_record_h record, unsigned int property_id, char** out_str )
 377 {
 378     cal_todo_s *rec = (cal_todo_s*)(record);
 379     switch( property_id )
 380     {
 381     case CAL_PROPERTY_TODO_SUMMARY:
 382         *out_str = SAFE_STRDUP(rec->summary);
 383         break;
 384     case CAL_PROPERTY_TODO_DESCRIPTION:
 385         *out_str = SAFE_STRDUP(rec->description);
 386         break;
 387     case CAL_PROPERTY_TODO_LOCATION:
 388         *out_str = SAFE_STRDUP(rec->location);
 389         break;
 390     case CAL_PROPERTY_TODO_CATEGORIES:
 391         *out_str = SAFE_STRDUP(rec->categories);
 392         break;
 393
 394     case CAL_PROPERTY_TODO_UID:
 395         *out_str = SAFE_STRDUP(rec->uid);
 396         break;
 397
 398     case CAL_PROPERTY_TODO_BYSECOND:
 399         *out_str = SAFE_STRDUP(rec->bysecond);
 400         break;
 401     case CAL_PROPERTY_TODO_BYMINUTE:
 402         *out_str = SAFE_STRDUP(rec->byminute);
 403         break;
 404     case CAL_PROPERTY_TODO_BYHOUR:
 405         *out_str = SAFE_STRDUP(rec->byhour);
 406         break;
 407     case CAL_PROPERTY_TODO_BYDAY:
 408         *out_str = SAFE_STRDUP(rec->byday);
 409         break;
 410     case CAL_PROPERTY_TODO_BYMONTHDAY:
 411         *out_str = SAFE_STRDUP(rec->bymonthday);
 412         break;
 413     case CAL_PROPERTY_TODO_BYYEARDAY:
 414         *out_str = SAFE_STRDUP(rec->byyearday);
 415         break;
 416     case CAL_PROPERTY_TODO_BYWEEKNO:
 417         *out_str = SAFE_STRDUP(rec->byweekno);
 418         break;
 419     case CAL_PROPERTY_TODO_BYMONTH:
 420         *out_str = SAFE_STRDUP(rec->bymonth);
 421         break;
 422     case CAL_PROPERTY_TODO_BYSETPOS:
 423         *out_str = SAFE_STRDUP(rec->bysetpos);
 424         break;
 425
 426     case CAL_PROPERTY_TODO_SYNC_DATA1:
 427         *out_str = SAFE_STRDUP(rec->sync_data1);
 428         break;
 429     case CAL_PROPERTY_TODO_SYNC_DATA2:
 430         *out_str = SAFE_STRDUP(rec->sync_data2);
 431         break;
 432     case CAL_PROPERTY_TODO_SYNC_DATA3:
 433         *out_str = SAFE_STRDUP(rec->sync_data3);
 434         break;
 435     case CAL_PROPERTY_TODO_SYNC_DATA4:
 436         *out_str = SAFE_STRDUP(rec->sync_data4);
 437         break;
 438     case CAL_PROPERTY_TODO_START_TZID:
 439         *out_str = SAFE_STRDUP(rec->start_tzid);
 440         break;
 441     case CAL_PROPERTY_TODO_DUE_TZID:
 442         *out_str = SAFE_STRDUP(rec->due_tzid);
 443         break;
 444     case CAL_PROPERTY_TODO_ORGANIZER_NAME:
 445         *out_str = SAFE_STRDUP(rec->organizer_name);
 446         break;
 447     case CAL_PROPERTY_TODO_ORGANIZER_EMAIL:
 448         *out_str = SAFE_STRDUP(rec->organizer_email);
 449         break;
 450     default:
 451         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
 452         return CALENDAR_ERROR_INVALID_PARAMETER;
 453     }
 454
 455     return CALENDAR_ERROR_NONE;
 456 }
 457
 458 static int __cal_record_todo_get_str_p( calendar_record_h record, unsigned int property_id, char** out_str )
 459 {
 460     cal_todo_s *rec = (cal_todo_s*)(record);
 461     switch( property_id )
 462     {
 463     case CAL_PROPERTY_TODO_SUMMARY:
 464         *out_str = (rec->summary);
 465         break;
 466     case CAL_PROPERTY_TODO_DESCRIPTION:
 467         *out_str = (rec->description);
 468         break;
 469     case CAL_PROPERTY_TODO_LOCATION:
 470         *out_str = (rec->location);
 471         break;
 472     case CAL_PROPERTY_TODO_CATEGORIES:
 473         *out_str = (rec->categories);
 474         break;
 475
 476     case CAL_PROPERTY_TODO_UID:
 477         *out_str = (rec->uid);
 478         break;
 479
 480     case CAL_PROPERTY_TODO_BYSECOND:
 481         *out_str = (rec->bysecond);
 482         break;
 483     case CAL_PROPERTY_TODO_BYMINUTE:
 484         *out_str = (rec->byminute);
 485         break;
 486     case CAL_PROPERTY_TODO_BYHOUR:
 487         *out_str = (rec->byhour);
 488         break;
 489     case CAL_PROPERTY_TODO_BYDAY:
 490         *out_str = (rec->byday);
 491         break;
 492     case CAL_PROPERTY_TODO_BYMONTHDAY:
 493         *out_str = (rec->bymonthday);
 494         break;
 495     case CAL_PROPERTY_TODO_BYYEARDAY:
 496         *out_str = (rec->byyearday);
 497         break;
 498     case CAL_PROPERTY_TODO_BYWEEKNO:
 499         *out_str = (rec->byweekno);
 500         break;
 501     case CAL_PROPERTY_TODO_BYMONTH:
 502         *out_str = (rec->bymonth);
 503         break;
 504     case CAL_PROPERTY_TODO_BYSETPOS:
 505         *out_str = (rec->bysetpos);
 506         break;
 507
 508     case CAL_PROPERTY_TODO_SYNC_DATA1:
 509         *out_str = (rec->sync_data1);
 510         break;
 511     case CAL_PROPERTY_TODO_SYNC_DATA2:
 512         *out_str = (rec->sync_data2);
 513         break;
 514     case CAL_PROPERTY_TODO_SYNC_DATA3:
 515         *out_str = (rec->sync_data3);
 516         break;
 517     case CAL_PROPERTY_TODO_SYNC_DATA4:
 518         *out_str = (rec->sync_data4);
 519         break;
 520     case CAL_PROPERTY_TODO_START_TZID:
 521         *out_str = (rec->start_tzid);
 522         break;
 523     case CAL_PROPERTY_TODO_DUE_TZID:
 524         *out_str = (rec->due_tzid);
 525         break;
 526     case CAL_PROPERTY_TODO_ORGANIZER_NAME:
 527         *out_str = (rec->organizer_name);
 528         break;
 529     case CAL_PROPERTY_TODO_ORGANIZER_EMAIL:
 530         *out_str = (rec->organizer_email);
 531         break;
 532     default:
 533         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
 534         return CALENDAR_ERROR_INVALID_PARAMETER;
 535     }
 536
 537     return CALENDAR_ERROR_NONE;
 538 }
 539
 540 static int __cal_record_todo_get_int( calendar_record_h record, unsigned int property_id, int* out_value )
 541 {
 542     cal_todo_s *rec = (cal_todo_s*)(record);
 543     switch( property_id )
 544     {
 545     case CAL_PROPERTY_TODO_ID:
 546         *out_value = (rec->index);
 547         break;
 548     case CAL_PROPERTY_TODO_CALENDAR_ID:
 549         *out_value = (rec->calendar_id);
 550         break;
 551     case CAL_PROPERTY_TODO_TODO_STATUS:
 552         *out_value = (rec->todo_status);
 553         break;
 554
 555     case CAL_PROPERTY_TODO_PRIORITY:
 556         *out_value = (rec->priority);
 557         break;
 558     //sensitivity
 559     case CAL_PROPERTY_TODO_SENSITIVITY:
 560         *out_value = (rec->sensitivity);
 561         break;
 562
 563     case CAL_PROPERTY_TODO_PROGRESS:
 564         *out_value = (rec->progress);
 565         break;
 566     //is_deleted
 567     case CAL_PROPERTY_TODO_IS_DELETED:
 568         *out_value = (rec->is_deleted);
 569         break;
 570     //freq
 571     case CAL_PROPERTY_TODO_FREQ:
 572         *out_value = (rec->freq);
 573         break;
 574     //range_type
 575     case CAL_PROPERTY_TODO_RANGE_TYPE:
 576         *out_value = (rec->range_type);
 577         break;
 578     //count
 579     case CAL_PROPERTY_TODO_COUNT:
 580         *out_value = (rec->count);
 581         break;
 582     //interval
 583     case CAL_PROPERTY_TODO_INTERVAL:
 584         *out_value = (rec->interval);
 585         break;
 586     //wkst
 587     case CAL_PROPERTY_TODO_WKST:
 588         *out_value = (rec->wkst);
 589         break;
 590
 591     //has_alarm
 592     case CAL_PROPERTY_TODO_HAS_ALARM:
 593         *out_value = (rec->has_alarm);
 594         break;
 595     case CAL_PROPERTY_TODO_HAS_ATTENDEE:
 596         *out_value = (rec->has_attendee);
 597         break;
 598     case CAL_PROPERTY_TODO_IS_ALLDAY:
 599         *out_value = (rec->due.type);
 600         break;
 601     default:
 602         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
 603         return CALENDAR_ERROR_INVALID_PARAMETER;
 604     }
 605
 606     return CALENDAR_ERROR_NONE;
 607 }
 608
 609 static int __cal_record_todo_get_double( calendar_record_h record, unsigned int property_id, double* out_value )
 610 {
 611     cal_todo_s *rec = (cal_todo_s*)(record);
 612     switch( property_id )
 613     {
 614     case CAL_PROPERTY_TODO_LATITUDE:
 615         *out_value = (rec->latitude);
 616         break;
 617     case CAL_PROPERTY_TODO_LONGITUDE:
 618         *out_value = (rec->longitude);
 619         break;
 620     default:
 621         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
 622         return CALENDAR_ERROR_INVALID_PARAMETER;
 623     }
 624
 625     return CALENDAR_ERROR_NONE;
 626 }
 627
 628 static int __cal_record_todo_get_lli( calendar_record_h record, unsigned int property_id, long long int* out_value )
 629 {
 630     cal_todo_s *rec = (cal_todo_s*)(record);
 631     switch( property_id )
 632     {
 633     case CAL_PROPERTY_TODO_CREATED_TIME:
 634         *out_value = (rec->created_time);
 635         break;
 636     case CAL_PROPERTY_TODO_LAST_MODIFIED_TIME:
 637         *out_value = (rec->last_mod);
 638         break;
 639     case CAL_PROPERTY_TODO_COMPLETED_TIME:
 640         *out_value = (rec->completed_time);
 641         break;
 642     default:
 643         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
 644         return CALENDAR_ERROR_INVALID_PARAMETER;
 645     }
 646
 647     return CALENDAR_ERROR_NONE;
 648 }
 649
 650 static int __cal_record_todo_get_caltime( calendar_record_h record, unsigned int property_id, calendar_time_s* out_value )
 651 {
 652     cal_todo_s *rec = (cal_todo_s*)(record);
 653     switch( property_id )
 654     {
 655     case CAL_PROPERTY_TODO_START:
 656         *out_value = rec->start;
 657         break;
 658     case CAL_PROPERTY_TODO_DUE:
 659         *out_value = rec->due;
 660         break;
 661     case CAL_PROPERTY_TODO_UNTIL:
 662         if (rec->until_type == CALENDAR_TIME_UTIME)
 663         {
 664             CAL_CALTIME_SET_UTIME(*out_value, rec->until_utime);
 665         }
 666         else
 667         {
 668             CAL_CALTIME_SET_DATE(*out_value, rec->until_year,rec->until_month,rec->until_mday);
 669         }
 670         break;
 671     default:
 672         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
 673         return CALENDAR_ERROR_INVALID_PARAMETER;
 674     }
 675
 676     return CALENDAR_ERROR_NONE;
 677 }
 678
 679 static int __cal_record_todo_set_str( calendar_record_h record, unsigned int property_id, const char* value )
 680 {
 681     cal_todo_s *rec = (cal_todo_s*)(record);
 682     switch( property_id )
 683     {
 684     case CAL_PROPERTY_TODO_SUMMARY:
 685         CAL_FREE(rec->summary);
 686         rec->summary = SAFE_STRDUP(value);
 687         break;
 688     case CAL_PROPERTY_TODO_DESCRIPTION:
 689         CAL_FREE(rec->description);
 690         rec->description = SAFE_STRDUP(value);
 691         break;
 692     case CAL_PROPERTY_TODO_LOCATION:
 693         CAL_FREE(rec->location);
 694         rec->location = SAFE_STRDUP(value);
 695         break;
 696     case CAL_PROPERTY_TODO_CATEGORIES:
 697         CAL_FREE(rec->categories);
 698         rec->categories = SAFE_STRDUP(value);
 699         break;
 700
 701     case CAL_PROPERTY_TODO_UID:
 702         CAL_FREE(rec->uid);
 703         rec->uid = SAFE_STRDUP(value);
 704         break;
 705
 706     case CAL_PROPERTY_TODO_BYSECOND:
 707         CAL_FREE(rec->bysecond);
 708         rec->bysecond = SAFE_STRDUP(value);
 709         break;
 710     case CAL_PROPERTY_TODO_BYMINUTE:
 711         CAL_FREE(rec->byminute);
 712         rec->byminute = SAFE_STRDUP(value);
 713         break;
 714     case CAL_PROPERTY_TODO_BYHOUR:
 715         CAL_FREE(rec->byhour);
 716         rec->byhour = SAFE_STRDUP(value);
 717         break;
 718     case CAL_PROPERTY_TODO_BYDAY:
 719         CAL_FREE(rec->byday);
 720         rec->byday = SAFE_STRDUP(value);
 721         break;
 722     case CAL_PROPERTY_TODO_BYMONTHDAY:
 723         CAL_FREE(rec->bymonthday);
 724         rec->bymonthday = SAFE_STRDUP(value);
 725         break;
 726     case CAL_PROPERTY_TODO_BYYEARDAY:
 727         CAL_FREE(rec->byyearday);
 728         rec->byyearday = SAFE_STRDUP(value);
 729         break;
 730     case CAL_PROPERTY_TODO_BYWEEKNO:
 731         CAL_FREE(rec->byweekno);
 732         rec->byweekno = SAFE_STRDUP(value);
 733         break;
 734     case CAL_PROPERTY_TODO_BYMONTH:
 735         CAL_FREE(rec->bymonth);
 736         rec->bymonth = SAFE_STRDUP(value);
 737         break;
 738     case CAL_PROPERTY_TODO_BYSETPOS:
 739         CAL_FREE(rec->bysetpos);
 740         rec->bysetpos = SAFE_STRDUP(value);
 741         break;
 742
 743     case CAL_PROPERTY_TODO_SYNC_DATA1:
 744         CAL_FREE(rec->sync_data1);
 745         rec->sync_data1 = SAFE_STRDUP(value);
 746         break;
 747     case CAL_PROPERTY_TODO_SYNC_DATA2:
 748         CAL_FREE(rec->sync_data2);
 749         rec->sync_data2 = SAFE_STRDUP(value);
 750         break;
 751     case CAL_PROPERTY_TODO_SYNC_DATA3:
 752         CAL_FREE(rec->sync_data3);
 753         rec->sync_data3 = SAFE_STRDUP(value);
 754         break;
 755     case CAL_PROPERTY_TODO_SYNC_DATA4:
 756         CAL_FREE(rec->sync_data4);
 757         rec->sync_data4 = SAFE_STRDUP(value);
 758         break;
 759     case CAL_PROPERTY_TODO_START_TZID:
 760         CAL_FREE(rec->start_tzid);
 761         rec->start_tzid = SAFE_STRDUP(value);
 762         break;
 763     case CAL_PROPERTY_TODO_DUE_TZID:
 764         CAL_FREE(rec->due_tzid);
 765         rec->due_tzid = SAFE_STRDUP(value);
 766         break;
 767     case CAL_PROPERTY_TODO_ORGANIZER_NAME:
 768         CAL_FREE(rec->organizer_name);
 769         rec->organizer_name = SAFE_STRDUP(value);
 770         break;
 771     case CAL_PROPERTY_TODO_ORGANIZER_EMAIL:
 772         CAL_FREE(rec->organizer_email);
 773         rec->organizer_email = SAFE_STRDUP(value);
 774         break;
 775     default:
 776         return CALENDAR_ERROR_INVALID_PARAMETER;
 777     }
 778
 779     return CALENDAR_ERROR_NONE;
 780 }
 781
 782 static int __cal_record_todo_set_int( calendar_record_h record, unsigned int property_id, int value )
 783 {
 784     cal_todo_s *rec = (cal_todo_s*)(record);
 785     switch( property_id )
 786     {
 787     case CAL_PROPERTY_TODO_ID:
 788         (rec->index) = value;
 789         break;
 790     case CAL_PROPERTY_TODO_CALENDAR_ID:
 791         (rec->calendar_id) = value;
 792         break;
 793     case CAL_PROPERTY_TODO_TODO_STATUS:
 794                 switch (value)
 795                 {
 796                 case CALENDAR_TODO_STATUS_NONE:
 797                 case CALENDAR_TODO_STATUS_NEEDS_ACTION:
 798                 case CALENDAR_TODO_STATUS_COMPLETED:
 799                 case CALENDAR_TODO_STATUS_IN_PROCESS:
 800                 case CALENDAR_TODO_STATUS_CANCELED:
 801                         (rec->todo_status) = value;
 802                         break;
 803                 default:
 804                         ERR("invalid parameter (value:%d)", value);
 805                         return CALENDAR_ERROR_INVALID_PARAMETER;
 806                 }
 807         break;
 808     //priority
 809     case CAL_PROPERTY_TODO_PRIORITY:
 810         (rec->priority) = value;
 811         break;
 812
 813     //sensitivity
 814     case CAL_PROPERTY_TODO_SENSITIVITY:
 815         (rec->sensitivity) = value;
 816         break;
 817     case CAL_PROPERTY_TODO_PROGRESS:
 818         (rec->progress) = value;
 819         break;
 820     //is_deleted
 821     case CAL_PROPERTY_TODO_IS_DELETED:
 822         (rec->is_deleted) = value;
 823         break;
 824     //freq
 825     case CAL_PROPERTY_TODO_FREQ:
 826                 switch (value)
 827                 {
 828                 case CALENDAR_RECURRENCE_NONE:
 829                 case CALENDAR_RECURRENCE_DAILY:
 830                 case CALENDAR_RECURRENCE_WEEKLY:
 831                 case CALENDAR_RECURRENCE_MONTHLY:
 832                 case CALENDAR_RECURRENCE_YEARLY:
 833                 (rec->freq) = value;
 834                         break;
 835                 default:
 836                         ERR("invalid parameter (value:%d)", value);
 837                         return CALENDAR_ERROR_INVALID_PARAMETER;
 838                 }
 839         break;
 840     //range_type
 841     case CAL_PROPERTY_TODO_RANGE_TYPE:
 842                 switch (value)
 843                 {
 844                 case CALENDAR_RANGE_UNTIL:
 845                 case CALENDAR_RANGE_COUNT:
 846                 case CALENDAR_RANGE_NONE:
 847                 (rec->range_type) = value;
 848                         break;
 849                 default:
 850                         ERR("invalid parameter (value:%d)", value);
 851                         return CALENDAR_ERROR_INVALID_PARAMETER;
 852                 }
 853         break;
 854     //count
 855     case CAL_PROPERTY_TODO_COUNT:
 856         (rec->count) = value;
 857         break;
 858     //interval
 859     case CAL_PROPERTY_TODO_INTERVAL:
 860         (rec->interval) = value;
 861         break;
 862     //wkst
 863     case CAL_PROPERTY_TODO_WKST:
 864                 switch (value)
 865                 {
 866                 case CALENDAR_SUNDAY:
 867                 case CALENDAR_MONDAY:
 868                 case CALENDAR_TUESDAY:
 869                 case CALENDAR_WEDNESDAY:
 870                 case CALENDAR_THURSDAY:
 871                 case CALENDAR_FRIDAY:
 872                 case CALENDAR_SATURDAY:
 873                 (rec->wkst) = value;
 874                         break;
 875                 default:
 876                         ERR("invalid parameter (value:%d)", value);
 877                         return CALENDAR_ERROR_INVALID_PARAMETER;
 878                 }
 879         break;
 880     //has_alarm
 881     case CAL_PROPERTY_TODO_HAS_ALARM:
 882         (rec->has_alarm) = value;
 883         break;
 884     case CAL_PROPERTY_TODO_HAS_ATTENDEE:
 885         (rec->has_attendee) = value;
 886         break;
 887     case CAL_PROPERTY_TODO_IS_ALLDAY:
 888         (rec->due.type) = value;
 889         break;
 890     default:
 891         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
 892         return CALENDAR_ERROR_INVALID_PARAMETER;
 893     }
 894
 895     return CALENDAR_ERROR_NONE;
 896 }
 897
 898 static int __cal_record_todo_set_double( calendar_record_h record, unsigned int property_id, double value )
 899 {
 900     cal_todo_s *rec = (cal_todo_s*)(record);
 901     switch( property_id )
 902     {
 903     case CAL_PROPERTY_TODO_LATITUDE:
 904         (rec->latitude) = value;
 905         break;
 906     case CAL_PROPERTY_TODO_LONGITUDE:
 907         (rec->longitude) = value;
 908         break;
 909     default:
 910         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
 911         return CALENDAR_ERROR_INVALID_PARAMETER;
 912     }
 913
 914     return CALENDAR_ERROR_NONE;
 915 }
 916
 917 static int __cal_record_todo_set_lli( calendar_record_h record, unsigned int property_id, long long int value )
 918 {
 919     cal_todo_s *rec = (cal_todo_s*)(record);
 920     switch( property_id )
 921     {
 922     case CAL_PROPERTY_TODO_CREATED_TIME:
 923         (rec->created_time) = value;
 924         break;
 925     case CAL_PROPERTY_TODO_LAST_MODIFIED_TIME:
 926         (rec->last_mod) = value;
 927         break;
 928     case CAL_PROPERTY_TODO_COMPLETED_TIME:
 929         (rec->completed_time) = value;
 930         break;
 931     default:
 932         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
 933         return CALENDAR_ERROR_INVALID_PARAMETER;
 934     }
 935
 936     return CALENDAR_ERROR_NONE;
 937 }
 938
 939 static int __cal_record_todo_set_caltime( calendar_record_h record, unsigned int property_id, calendar_time_s value )
 940 {
 941     cal_todo_s *rec = (cal_todo_s*)(record);
 942     switch( property_id )
 943     {
 944     case CAL_PROPERTY_TODO_START:
 945         (rec->start) = value;
 946         break;
 947     case CAL_PROPERTY_TODO_DUE:
 948         (rec->due) = value;
 949         break;
 950     case CAL_PROPERTY_TODO_UNTIL:
 951         (rec->until_type) = value.type;;
 952         if(value.type == CALENDAR_TIME_UTIME)
 953         {
 954             (rec->until_utime) = value.time.utime;
 955             (rec->until_year) = 0;
 956             (rec->until_month) = 0;
 957             (rec->until_mday) = 0;
 958         }
 959         else
 960         {
 961             (rec->until_utime) = 0;
 962             (rec->until_year) = value.time.date.year;
 963             (rec->until_month) = value.time.date.month;
 964             (rec->until_mday) = value.time.date.mday ;
 965         }
 966         break;
 967     default:
 968         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
 969         return CALENDAR_ERROR_INVALID_PARAMETER;
 970     }
 971
 972     return CALENDAR_ERROR_NONE;
 973 }
 974
 975 static int __cal_record_todo_add_child_record( calendar_record_h record, unsigned int property_id, calendar_record_h child_record )
 976 {
 977     cal_todo_s *rec = (cal_todo_s*)(record);
 978
 979     switch( property_id )
 980     {
 981     case CAL_PROPERTY_TODO_CALENDAR_ALARM:
 982         rec->alarm_list = g_list_append(rec->alarm_list,child_record);
 983         rec->has_alarm = 1;
 984         break;
 985     case CAL_PROPERTY_TODO_CALENDAR_ATTENDEE:
 986         rec->attendee_list = g_list_append(rec->attendee_list,child_record);
 987         rec->has_attendee = 1;
 988         break;
 989     case CAL_PROPERTY_TODO_EXTENDED:
 990         rec->extended_list = g_list_append(rec->extended_list,child_record);
 991         break;
 992     default:
 993         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
 994         return CALENDAR_ERROR_INVALID_PARAMETER;
 995     }
 996
 997     return CALENDAR_ERROR_NONE;
 998 }
 999
1000 static int __cal_record_todo_remove_child_record( calendar_record_h record, unsigned int property_id, calendar_record_h child_record )
1001 {
1002     cal_todo_s *rec = (cal_todo_s*)(record);
1003     //GList* node = NULL;
1004
1005     switch( property_id )
1006     {
1007     case CAL_PROPERTY_TODO_CALENDAR_ALARM:
1008         //node = g_list_find(rec->alarm_list,child_record);
1009         rec->alarm_list = g_list_remove(rec->alarm_list,child_record);
1010         if (g_list_length(rec->alarm_list) == 0)
1011         {
1012             rec->has_alarm = 0;
1013         }
1014         break;
1015     case CAL_PROPERTY_TODO_CALENDAR_ATTENDEE:
1016         rec->attendee_list = g_list_remove(rec->attendee_list,child_record);
1017         if (g_list_length(rec->attendee_list) == 0)
1018         {
1019             rec->has_attendee = 0;
1020         }
1021         break;
1022     case CAL_PROPERTY_TODO_EXTENDED:
1023         rec->extended_list = g_list_remove(rec->extended_list,child_record);
1024         break;
1025     default:
1026         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
1027         return CALENDAR_ERROR_INVALID_PARAMETER;
1028     }
1029
1030     return CALENDAR_ERROR_NONE;
1031 }
1032
1033 static int __cal_record_todo_get_child_record_count( calendar_record_h record, unsigned int property_id , unsigned int* count )
1034 {
1035     cal_todo_s *rec = (cal_todo_s*)(record);
1036     *count = 0;
1037
1038     switch( property_id )
1039     {
1040     case CAL_PROPERTY_TODO_CALENDAR_ALARM:
1041                 if (rec->alarm_list)
1042                 {
1043                     *count = g_list_length(rec->alarm_list);
1044                 }
1045         break;
1046     case CAL_PROPERTY_TODO_CALENDAR_ATTENDEE:
1047         if (rec->attendee_list)
1048         {
1049             *count = g_list_length(rec->attendee_list);
1050         }
1051         break;
1052     case CAL_PROPERTY_TODO_EXTENDED:
1053         if (rec->extended_list)
1054         {
1055             *count = g_list_length(rec->extended_list);
1056         }
1057         break;
1058     default:
1059         *count = 0;
1060         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
1061         return CALENDAR_ERROR_INVALID_PARAMETER;
1062     }
1063
1064     return CALENDAR_ERROR_NONE;
1065 }
1066
1067 static int __cal_record_todo_get_child_record_at_p( calendar_record_h record, unsigned int property_id, int index, calendar_record_h* child_record )
1068 {
1069     cal_todo_s *rec = (cal_todo_s*)(record);
1070
1071     switch( property_id )
1072     {
1073     case CAL_PROPERTY_TODO_CALENDAR_ALARM:
1074         *child_record = g_list_nth_data(rec->alarm_list,index);
1075         break;
1076     case CAL_PROPERTY_TODO_CALENDAR_ATTENDEE:
1077         *child_record = g_list_nth_data(rec->attendee_list,index);
1078         break;
1079     case CAL_PROPERTY_TODO_EXTENDED:
1080         *child_record = g_list_nth_data(rec->extended_list,index);
1081         break;
1082     default:
1083         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
1084         return CALENDAR_ERROR_INVALID_PARAMETER;
1085     }
1086
1087     return CALENDAR_ERROR_NONE;
1088 }
1089
1090 static int __cal_record_todo_clone_child_record_list( calendar_record_h record, unsigned int property_id, calendar_list_h* out_list )
1091 {
1092     cal_todo_s *rec = (cal_todo_s*)(record);
1093     int ret = CALENDAR_ERROR_NONE;
1094     calendar_list_h list;
1095     int count = 0;
1096
1097     ret = calendar_list_create(&list);
1098     if (ret != CALENDAR_ERROR_NONE)
1099     {
1100         ERR("calendar_list_create fail");
1101         return ret;
1102     }
1103
1104     switch( property_id )
1105     {
1106     case CAL_PROPERTY_TODO_CALENDAR_ALARM:
1107     {
1108         count = g_list_length(rec->alarm_list);
1109         if (count <=0 )
1110         {
1111             calendar_list_destroy(list, true);
1112             return CALENDAR_ERROR_NO_DATA;
1113         }
1114         GList *alarm_list = rec->alarm_list;
1115         calendar_record_h alarm_child_record;
1116         calendar_record_h alarm_record = NULL;
1117         while (alarm_list)
1118         {
1119             alarm_child_record = (calendar_record_h)alarm_list->data;
1120             if (alarm_child_record == NULL)
1121             {
1122                 alarm_list = g_list_next(alarm_list);
1123                 continue;
1124             }
1125
1126             if ( calendar_record_clone(alarm_child_record,&alarm_record) == CALENDAR_ERROR_NONE )
1127             {
1128                 calendar_list_add(list,alarm_record);
1129             }
1130             alarm_record = NULL;
1131
1132             alarm_list = g_list_next(alarm_list);
1133         }
1134         *out_list = (calendar_list_h)list;
1135     }
1136     break;
1137     case CAL_PROPERTY_TODO_CALENDAR_ATTENDEE:
1138     {
1139         count = g_list_length(rec->attendee_list);
1140         if (count <=0 )
1141         {
1142             calendar_list_destroy(list, true);
1143             return CALENDAR_ERROR_NO_DATA;
1144         }
1145         GList *attendee_list = rec->attendee_list;
1146         calendar_record_h attendee_child_record;
1147         calendar_record_h attendee_record = NULL;
1148         while (attendee_list)
1149         {
1150             attendee_child_record = (calendar_record_h)attendee_list->data;
1151             if (attendee_child_record == NULL)
1152             {
1153                 attendee_list = g_list_next(attendee_list);
1154                 continue;
1155             }
1156
1157             if ( calendar_record_clone(attendee_child_record,&attendee_record) == CALENDAR_ERROR_NONE )
1158             {
1159                 calendar_list_add(list,attendee_record);
1160             }
1161             attendee_record = NULL;
1162
1163             attendee_list = g_list_next(attendee_list);
1164         }
1165         *out_list = (calendar_list_h)list;
1166     }
1167     break;
1168     case CAL_PROPERTY_TODO_EXTENDED:
1169     {
1170         count = g_list_length(rec->extended_list);
1171         if (count <=0 )
1172         {
1173             calendar_list_destroy(list, true);
1174             return CALENDAR_ERROR_NO_DATA;
1175         }
1176         GList *extended_list = rec->extended_list;
1177         calendar_record_h child_record;
1178         calendar_record_h record = NULL;
1179         while (extended_list)
1180         {
1181             child_record = (calendar_record_h)extended_list->data;
1182             if (child_record == NULL)
1183             {
1184                 extended_list = g_list_next(extended_list);
1185                 continue;
1186             }
1187
1188             if ( calendar_record_clone(child_record,&record) == CALENDAR_ERROR_NONE )
1189             {
1190                 calendar_list_add(list,record);
1191             }
1192             record = NULL;
1193
1194             extended_list = g_list_next(extended_list);
1195         }
1196         *out_list = (calendar_list_h)list;
1197     }
1198     break;
1199     default:
1200         ASSERT_NOT_REACHED("invalid parameter (property:%d)",property_id);
1201         return CALENDAR_ERROR_INVALID_PARAMETER;
1202     }
1203
1204     return CALENDAR_ERROR_NONE;
1205 }