src/Calendar/EventWrapper.cpp

   1 //
   2 // Tizen Web Device API
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 // http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <sstream>
  19 #include <algorithm>
  20 #include <time.h>
  21 #include <Commons/Exception.h>
  22 #include "EventWrapper.h"
  23 #include "Calendar.h"
  24 #include "CalendarUtility.h"
  25 #include <Logger.h>
  26
  27 using namespace WrtDeviceApis::Commons;
  28
  29 namespace DeviceAPI {
  30 namespace Calendar {
  31
  32 EventWrapper::EventWrapper(CalendarEvent::CalendarType type) :
  33     m_platformEvent(NULL),
  34     m_abstractEvent(NULL),
  35     m_calendarType(type)
  36 {
  37     m_abstractEvent = CalendarEventPtr(new CalendarEvent());
  38     if (!m_abstractEvent) {
  39         ThrowMsg(UnknownException, "Abstract object is not created.");
  40     }
  41 }
  42
  43 EventWrapper::EventWrapper(const CalendarEventPtr &event, CalendarEvent::CalendarType type) :
  44     m_platformEvent(NULL),
  45     m_abstractEvent(event),
  46     m_calendarType(type)
  47 {
  48 }
  49
  50 EventWrapper::EventWrapper(calendar_record_h event, CalendarEvent::CalendarType type) :
  51     m_platformEvent(event),
  52     m_abstractEvent(NULL),
  53     m_calendarType(type)
  54 {
  55     m_abstractEvent = CalendarEventPtr(new CalendarEvent());
  56     if (!m_abstractEvent) {
  57         ThrowMsg(UnknownException, "Abstract object is not created.");
  58     }
  59 }
  60
  61 EventWrapper::~EventWrapper()
  62 {
  63     freePlatformEvent();
  64 }
  65
  66 void EventWrapper::saveEvent()
  67 {
  68     if (m_platformEvent == NULL) {
  69         ThrowMsg(NullPointerException, "m_platformEvent is not set");
  70     }
  71
  72     int itemId = m_abstractEvent->getId();
  73     LoggerD("Before saving/update eventId: " << itemId);
  74
  75     //displayPlatformEvent();
  76
  77     int ret;
  78     if (itemId <= UNDEFINED_ITEM_ID) {
  79         ret = calendar_db_insert_record(m_platformEvent, &itemId);
  80         if (CALENDAR_ERROR_NONE!=ret) {
  81             ThrowMsg(PlatformException, "Can't insert new item: "<<ret);
  82         }
  83         m_abstractEvent->setId(itemId);
  84         LoggerD("New calendar item inserted with id: "<<itemId);
  85     } else {
  86         ret = calendar_db_update_record(m_platformEvent);
  87         if (CALENDAR_ERROR_NONE != ret) {
  88             ThrowMsg(PlatformException, "Can't update new item: "<<ret);
  89         }
  90         LoggerD("Calendar item updated.");
  91     }
  92 }
  93
  94 void EventWrapper::loadEvent(int id)
  95 {
  96     LoggerD("Item id to load: " << id);
  97     freePlatformEvent();
  98
  99     const char *dataType;
 100     if(getType() == CalendarEvent::TASK_TYPE) {
 101         dataType = _calendar_todo._uri;
 102     } else {
 103         dataType = _calendar_event._uri;
 104     }
 105
 106     int ret = calendar_db_get_record(dataType, id, &m_platformEvent);
 107     if (CALENDAR_ERROR_NONE!=ret) {
 108         m_platformEvent = NULL;
 109         ThrowMsg(NotFoundException, "Can't get item with id: "<<id<<", error code: "<<ret);
 110     }
 111
 112     int isDeleted;
 113     if(getType() == CalendarEvent::TASK_TYPE) {
 114         ret = calendar_record_get_int(m_platformEvent, _calendar_todo.is_deleted, &isDeleted);
 115     } else {
 116         ret = calendar_record_get_int(m_platformEvent, _calendar_event.is_deleted, &isDeleted);
 117     }
 118     if (CALENDAR_ERROR_NONE!=ret) {
 119         ThrowMsg(NotFoundException, "Item already deleted.");
 120     }
 121
 122     convertPlatformEventToAbstractEvent();
 123
 124     m_abstractEvent->setCalendarType(getType());
 125
 126     //displayAbstractEvent();
 127 }
 128
 129 void EventWrapper::deleteEvent()
 130 {
 131     if (m_platformEvent == NULL) {
 132         ThrowMsg(NullPointerException, "Platform event is null.");
 133     }
 134
 135     // If the recurrenceId is set, delete the instance of recurring event only.
 136     int itemId = m_abstractEvent->getId();
 137     long long int recurrenceId = m_abstractEvent->getRecurrenceId();
 138     LoggerD("itemId to delete: " << itemId << ", recurrenceId: " << recurrenceId << ", type: " << getType());
 139
 140     calendar_record_h item = NULL;
 141     const char *dataType;
 142     if(getType() == CalendarEvent::TASK_TYPE) {
 143         dataType = _calendar_todo._uri;
 144     } else {
 145         dataType = _calendar_event._uri;
 146     }
 147
 148     int ret = calendar_db_get_record(dataType, itemId, &item);
 149     if (CALENDAR_ERROR_NONE != ret) {
 150         ThrowMsg(NotFoundException, "Can't get calendar item: "<<ret);
 151     }
 152
 153     int isDeleted;
 154     if(CalendarEvent::TASK_TYPE==getType()) {
 155         ret = calendar_record_get_int(m_platformEvent, _calendar_todo.is_deleted, &isDeleted);
 156     } else {
 157         ret = calendar_record_get_int(m_platformEvent, _calendar_event.is_deleted, &isDeleted);
 158     }
 159     if (CALENDAR_ERROR_NONE!=ret) {
 160         if (item) {
 161             calendar_record_destroy(item, true);
 162         }
 163         ThrowMsg(NotFoundException, "Item already deleted.");
 164     }
 165
 166     if (item) {
 167         calendar_record_destroy(item, true);
 168     }
 169
 170     if ( 0>=recurrenceId || true==getAbstractEvent()->getIsDetached()) {
 171         // Platform detects the detached events and uptates all instances.
 172         ret = calendar_db_delete_record(dataType, itemId);
 173         if (CALENDAR_ERROR_NONE != ret) {
 174             if(CALENDAR_ERROR_DB_RECORD_NOT_FOUND==ret) {
 175                 ThrowMsg(NotFoundException, "Item not found.");
 176             } else {
 177                 ThrowMsg(PlatformException, "Can't delete calendar item: "<<ret);
 178             }
 179         }
 180         m_abstractEvent->resetId();
 181     } else {
 182         EventRecurrenceRulePtr rrule = m_abstractEvent->getRecurrenceRule();
 183         (*rrule->getExceptions()).push_back(recurrenceId);
 184
 185         std::string exdate = "";
 186         for( unsigned int i=0; i<rrule->getExceptions()->size(); i++ ) {
 187             std::stringstream ss;
 188             ss<<rrule->getExceptions()->at(i);
 189             exdate.append(ss.str());
 190             if(i!=rrule->getExceptions()->size()-1) {
 191                 exdate.append(",");
 192             }
 193         }
 194         ret = calendar_record_set_str(m_platformEvent, _calendar_event.exdate, exdate.c_str());
 195         if(ret!=CALENDAR_ERROR_NONE) {
 196             ThrowMsg(PlatformException, "Can't delete the instance: "<<ret);
 197         } else {
 198             LoggerD("Set the exdate: "<<exdate);
 199         }
 200
 201         ret = calendar_db_update_record(m_platformEvent);
 202         if (CALENDAR_ERROR_NONE != ret) {
 203             ThrowMsg(PlatformException, "Can't update the exdate "<<ret);
 204         }
 205         LoggerD("Calendar item instance deleted.");
 206     }
 207 }
 208
 209 void EventWrapper::createEventFromString(std::string value)
 210 {
 211     if (value.empty()) {
 212         ThrowMsg(NullPointerException, "Failed to create an item from string.");
 213     } else {
 214         LoggerD("string to convert: "<<value);
 215     }
 216
 217     calendar_list_h list = NULL;
 218     int ret;
 219
 220     ret = calendar_vcalendar_parse_to_calendar(value.c_str(), &list);
 221     if (CALENDAR_ERROR_NONE != ret) {
 222         ThrowMsg(PlatformException, "Can't convert string: "<<ret);
 223     }
 224     if (NULL==list) {
 225         ThrowMsg(PlatformException, "No items converted.");
 226     }
 227
 228     int count = -1;
 229     if(CALENDAR_ERROR_NONE!=calendar_list_get_count(list, &count)){
 230         LoggerW("Getting list count failed.");
 231     } else {
 232         LoggerD("List count: "<<count);
 233     }
 234
 235         calendar_record_h currentItem = NULL;
 236         char* uri = NULL;
 237         calendar_list_first(list);
 238
 239     while(count--) {
 240         // We cover only one item per string.
 241                 currentItem = NULL;
 242
 243         ret = calendar_list_get_current_record_p(list, &currentItem);
 244         if(CALENDAR_ERROR_NONE!=ret) {
 245             LoggerW("Getting current record failed: "<<ret);
 246         }
 247
 248                 // Filter out the extended features.
 249                 uri = NULL;
 250                 ret = calendar_record_get_uri_p(currentItem, &uri);
 251         if(CALENDAR_ERROR_NONE!=ret) {
 252             LoggerW("Getting uri failed: "<<ret);
 253         }
 254
 255                 if ( 0==strcmp(uri, _calendar_event._uri) && CalendarEvent::EVENT_TYPE==getType()) {
 256                         LoggerD("Found an event.");
 257                 } else if ( 0==strcmp(uri, _calendar_todo._uri) && CalendarEvent::TASK_TYPE==getType()) {
 258                         LoggerD("Found a task.");
 259                 } else {
 260                         LoggerD("Skip an extended feature.");
 261                         calendar_list_next(list);
 262                         continue;
 263                 }
 264
 265         ret = calendar_record_clone(currentItem, &m_platformEvent);
 266         if(CALENDAR_ERROR_NONE!=ret) {
 267             LoggerW("Clonning failed: "<<ret);
 268         }
 269     }
 270
 271     if(list) {
 272         calendar_list_destroy(list, true);
 273     }
 274
 275     //displayPlatformEvent();
 276 }
 277
 278 std::string EventWrapper::exportEventToString()
 279 {
 280     char *vStrings = NULL;
 281     calendar_list_h list = NULL;
 282     int ret;
 283     std::string returnString;
 284
 285     ret = calendar_list_create(&list);
 286     if (CALENDAR_ERROR_NONE != ret) {
 287         ThrowMsg(PlatformException, "Can't create a list: "<<ret);
 288     }
 289
 290     ret = calendar_list_add(list, m_platformEvent);
 291     if (CALENDAR_ERROR_NONE != ret) {
 292         ThrowMsg(PlatformException, "Can't add list item: "<<ret);
 293     }
 294
 295     ret = calendar_vcalendar_make_from_records(list, &vStrings);
 296     if (CALENDAR_ERROR_NONE != ret) {
 297         ThrowMsg(PlatformException, "Can't convert item to string: "<<ret);
 298     }
 299     if (NULL==vStrings) {
 300         ThrowMsg(PlatformException, "No items converted.");
 301     }
 302
 303     returnString = std::string(vStrings);
 304
 305     if(vStrings) {
 306         free(vStrings);
 307     }
 308     if(list) {
 309         // Don't destroy the record itself.
 310         calendar_list_destroy(list, false);
 311     }
 312
 313     return returnString;
 314 }
 315
 316 calendar_record_h EventWrapper::getPlatformEvent() const
 317 {
 318     return m_platformEvent;
 319 }
 320
 321 CalendarEventPtr EventWrapper::getAbstractEvent() const
 322 {
 323     return m_abstractEvent;
 324 }
 325
 326 void EventWrapper::freePlatformEvent()
 327 {
 328     if (m_platformEvent != NULL) {
 329         if (CALENDAR_ERROR_NONE != calendar_record_destroy(m_platformEvent, true)) {
 330             LoggerW("Can't destroy calendar record.");
 331         }
 332         m_platformEvent = NULL;
 333     } else {
 334         LoggerD("Null platform event.");
 335     }
 336 }
 337
 338 calendar_record_h EventWrapper::convertAbstractEventToPlatformEvent(bool loadBeforeConvert)
 339 {
 340     freePlatformEvent();
 341     const char *dataType;
 342     int ret;
 343
 344     if(getType() == CalendarEvent::TASK_TYPE) {
 345         dataType = _calendar_todo._uri;
 346     } else {
 347         dataType = _calendar_event._uri;
 348     }
 349
 350     if(loadBeforeConvert) {
 351         // Load the item for update operation to include the id.
 352         ret = calendar_db_get_record(dataType, m_abstractEvent->getId(), &m_platformEvent);
 353         if (CALENDAR_ERROR_NONE!=ret) {
 354             ThrowMsg(NotFoundException, "Can't load the item with id: "<<m_abstractEvent->getId()<<", error code: "<<ret);
 355         } else {
 356             LoggerD("Item loaded with id: "<<m_abstractEvent->getId());
 357         }
 358     } else {
 359         ret = calendar_record_create(dataType, &m_platformEvent);
 360         if (CALENDAR_ERROR_NONE != ret) {
 361             ThrowMsg(PlatformException, "Can't create platform record: "<<ret);
 362         } else {
 363             LoggerD("Platform item created with dataType: "<<dataType);
 364         }
 365     }
 366
 367     setCalendarIdToPlatformEvent();
 368     setDescriptionToPlatformEvent();
 369     setSummaryToPlatformEvent();
 370     setStartTimeToPlatformEvent();
 371     setEndTimeToPlatformEvent(); // replacement for duration
 372     setLocationToPlatformEvent();
 373     setCategoriesToPlatformEvent();
 374     setStatusToPlatformEvent();
 375     setAlarmsToPlatformEvent();
 376     setIsAllDayToPlatformEvent();
 377     setOrganizerToPlatformEvent();
 378     setAttendeesToPlatformEvent();
 379     setPositionToPlatformEvent();
 380     setVisibilityToPlatformEvent();
 381     setAvailabilityToPlatformEvent();
 382     setRecurrenceRuleToPlatformEvent();
 383     //setUIdToPlatformEvent(); // We don't set uid but use id field instead.
 384     setRecurrenceIdToPlatformEvent();
 385     setParentIdToPlatformEvent();
 386     setPriorityToPlatformEvent();
 387     setCreatedDateToPlatformEvent();
 388     setCompletedDateToPlatformEvent();
 389     setProgressToPlatformEvent();
 390
 391     return getPlatformEvent();
 392 }
 393
 394 void EventWrapper::setCalendarIdToPlatformEvent()
 395 {
 396     int ret;
 397
 398     if(CalendarEvent::TASK_TYPE==getType()) {
 399         ret = calendar_record_set_int(m_platformEvent, _calendar_todo.calendar_book_id, m_abstractEvent->getCalendarId());
 400     } else {
 401         ret = calendar_record_set_int(m_platformEvent, _calendar_event.calendar_book_id, m_abstractEvent->getCalendarId());
 402     }
 403     if (CALENDAR_ERROR_NONE!=ret) {
 404         LoggerW("Can't set calendarId.");
 405     }
 406 }
 407
 408 void EventWrapper::setDescriptionToPlatformEvent()
 409 {
 410     int ret;
 411     if(CalendarEvent::TASK_TYPE==getType()) {
 412         ret = calendar_record_set_str(m_platformEvent, _calendar_todo.description, m_abstractEvent->getDescription().c_str());
 413     } else {
 414         ret = calendar_record_set_str(m_platformEvent, _calendar_event.description, m_abstractEvent->getDescription().c_str());
 415     }
 416     if (CALENDAR_ERROR_NONE!=ret) {
 417         LoggerW("Can't set item description.");
 418     }
 419 }
 420
 421 void EventWrapper::setSummaryToPlatformEvent()
 422 {
 423     int ret;
 424     if(CalendarEvent::TASK_TYPE==getType()) {
 425         ret = calendar_record_set_str(m_platformEvent, _calendar_todo.summary, m_abstractEvent->getSubject().c_str());
 426     } else {
 427         ret = calendar_record_set_str(m_platformEvent, _calendar_event.summary, m_abstractEvent->getSubject().c_str());
 428     }
 429     if (CALENDAR_ERROR_NONE != ret) {
 430         LoggerW("Can't set item subject.");
 431     }
 432 }
 433
 434 void EventWrapper::setStartTimeToPlatformEvent()
 435 {
 436     int ret;
 437     long long int time = m_abstractEvent->getStartTime();
 438     if (time == UNDEFINED_TIME) {
 439         time = m_abstractEvent->getEndTime();
 440     }
 441
 442     std::string timeZone = m_abstractEvent->getTimeZone();
 443
 444     calendar_time_s cal;
 445     if(m_abstractEvent->getIsAllDay()) {
 446         cal.type = CALENDAR_TIME_LOCALTIME;
 447                 cal.time.date = CalendarUtility::LLIToCalTime(timeZone.c_str(), time).time.date;
 448     } else {
 449         cal.type = CALENDAR_TIME_UTIME;
 450             cal.time.utime = time;
 451     }
 452
 453     if(CalendarEvent::TASK_TYPE==getType()) {
 454         ret = calendar_record_set_caltime(m_platformEvent, _calendar_todo.start_time, cal);
 455     } else {
 456         ret = calendar_record_set_caltime(m_platformEvent, _calendar_event.start_time, cal);
 457     }
 458     if (CALENDAR_ERROR_NONE != ret) {
 459         ThrowMsg(PlatformException, "Can't set start time: "<<ret);
 460     } else {
 461         LoggerD("Set start time.");
 462     }
 463
 464     if(CalendarEvent::TASK_TYPE==getType()) {
 465         ret = calendar_record_set_str(m_platformEvent, _calendar_todo.start_tzid, timeZone.c_str());
 466     } else {
 467         ret = calendar_record_set_str(m_platformEvent, _calendar_event.start_tzid, timeZone.c_str());
 468     }
 469     if (CALENDAR_ERROR_NONE != ret) {
 470         ThrowMsg(PlatformException, "Can't set start time zone: "<<ret);
 471     } else {
 472         LoggerD("Set time zone: "<<timeZone);
 473     }
 474 }
 475
 476 void EventWrapper::setEndTimeToPlatformEvent()
 477 {
 478     int ret;
 479     long long int time = m_abstractEvent->getEndTime();
 480     if (time == UNDEFINED_TIME) {
 481         time = m_abstractEvent->getStartTime();
 482     }
 483
 484     calendar_time_s cal;
 485     if(m_abstractEvent->getIsAllDay()) {
 486         cal.type = CALENDAR_TIME_LOCALTIME;
 487                 cal.time.date = CalendarUtility::LLIToCalTime(m_abstractEvent->getTimeZone().c_str(), time).time.date;
 488     } else {
 489     cal.type = CALENDAR_TIME_UTIME;
 490     cal.time.utime = time;
 491     }
 492
 493     if(CalendarEvent::TASK_TYPE==getType()) {
 494         ret = calendar_record_set_caltime(m_platformEvent, _calendar_todo.due_time, cal);
 495     } else {
 496         ret = calendar_record_set_caltime(m_platformEvent, _calendar_event.end_time, cal);
 497     }
 498     if (CALENDAR_ERROR_NONE != ret) {
 499         LoggerW("Can't set end/due time: "<<ret);
 500     }
 501 }
 502
 503 void EventWrapper::setLocationToPlatformEvent()
 504 {
 505     int ret;
 506     if(CalendarEvent::TASK_TYPE==getType()) {
 507         ret = calendar_record_set_str(m_platformEvent, _calendar_todo.location, m_abstractEvent->getLocation().c_str());
 508     } else {
 509         ret = calendar_record_set_str(m_platformEvent, _calendar_event.location, m_abstractEvent->getLocation().c_str());
 510     }
 511     if (CALENDAR_ERROR_NONE != ret) {
 512         LoggerW("Can't set location.");
 513     }
 514 }
 515
 516 void EventWrapper::setRecurrenceRuleToPlatformEvent()
 517 {
 518     if (CalendarEvent::TASK_TYPE==getType()) {
 519         LoggerD("No need to set rrule for a task.");
 520         return;
 521     }
 522
 523     EventRecurrenceRulePtr rrule  = m_abstractEvent->getRecurrenceRule();
 524     if (NULL==rrule) {
 525         LoggerW("No way! Rrule is not set!");
 526         return;
 527     } else if(EventRecurrenceRule::NO_RECURRENCE==rrule->getFrequency()) {
 528         LoggerD("No recurrence frequency.");
 529     } else if(EventRecurrenceRule::UNDEFINED_RECURRENCE==rrule->getFrequency()) {
 530         LoggerD("Undefined recurrence frequency.");
 531     } else {
 532         LoggerD("frequency "<<rrule->getFrequency());
 533     }
 534
 535     // set frequency
 536     switch (rrule->getFrequency()) {
 537     case EventRecurrenceRule::NO_RECURRENCE:
 538     case EventRecurrenceRule::UNDEFINED_RECURRENCE:
 539         if(CALENDAR_ERROR_NONE!=calendar_record_set_int(m_platformEvent, _calendar_event.freq, CALENDAR_RECURRENCE_NONE)) {
 540             LoggerW("Failed setting frequency.");
 541         }
 542         break;
 543     case EventRecurrenceRule::DAILY_RECURRENCE:
 544         if(CALENDAR_ERROR_NONE!=calendar_record_set_int(m_platformEvent, _calendar_event.freq, CALENDAR_RECURRENCE_DAILY)) {
 545             LoggerW("Failed setting frequency.");
 546         }
 547         break;
 548     case EventRecurrenceRule::WEEKLY_RECURRENCE:
 549     {
 550         if(CALENDAR_ERROR_NONE!=calendar_record_set_int(m_platformEvent, _calendar_event.freq, CALENDAR_RECURRENCE_WEEKLY)) {
 551             LoggerW("Failed setting frequency.");
 552         }
 553         break;
 554     }
 555     case EventRecurrenceRule::MONTHLY_RECURRENCE:
 556     {
 557         if(CALENDAR_ERROR_NONE!=calendar_record_set_int(m_platformEvent, _calendar_event.freq, CALENDAR_RECURRENCE_MONTHLY)) {
 558             LoggerW("Failed setting frequency.");
 559         }
 560         break;
 561     }
 562     case EventRecurrenceRule::YEARLY_RECURRENCE:
 563     {
 564         if(CALENDAR_ERROR_NONE!=calendar_record_set_int(m_platformEvent, _calendar_event.freq, CALENDAR_RECURRENCE_YEARLY)) {
 565             LoggerW("Failed setting frequency.");
 566         }
 567         break;
 568     }
 569     default:
 570         LoggerW("Invalid reccurence rule frequency "<<rrule->getFrequency());
 571         break;
 572     }
 573
 574     // set byday
 575     StringArrayPtr daysOfTheWeek = rrule->getDaysOfTheWeek();
 576     if( 0 != daysOfTheWeek->size() ) {
 577         std::string byday = "";
 578         for(unsigned int i=0; i<daysOfTheWeek->size(); i++) {
 579             byday.append(daysOfTheWeek->at(i));
 580             if(i!=daysOfTheWeek->size()-1) {
 581                 byday.append(",");
 582             }
 583         }
 584
 585         LoggerD("byday: "<<byday);
 586         if (CALENDAR_ERROR_NONE!=calendar_record_set_str(m_platformEvent, _calendar_event.byday, byday.c_str())) {
 587             LoggerW("Can't set byday.");
 588         }
 589     }
 590
 591     // set the ocurrence count
 592     if (-1 != rrule->getOccurrenceCount()) {
 593         LoggerD("Set the occurrence count: "<<rrule->getOccurrenceCount());
 594
 595         if (CALENDAR_ERROR_NONE != calendar_record_set_int(m_platformEvent, _calendar_event.range_type, CALENDAR_RANGE_COUNT)) {
 596             LoggerW("Can't set rrule range type.");
 597         }
 598
 599         if (CALENDAR_ERROR_NONE != calendar_record_set_int(m_platformEvent, _calendar_event.count, rrule->getOccurrenceCount())) {
 600             LoggerW("Can't set occurrence count.");
 601         }
 602     }
 603
 604     // set the exceptions
 605     if ( !rrule->getExceptions()->empty() )
 606     {
 607         LoggerD("Set the exceptions of length: "<<rrule->getExceptions()->size());
 608
 609         std::string exdate = "";
 610         for( unsigned int i=0; i<rrule->getExceptions()->size(); i++ )
 611         {
 612             std::stringstream ss;
 613             ss<<rrule->getExceptions()->at(i);
 614             exdate.append(ss.str());
 615             if(i!=rrule->getExceptions()->size()-1) {
 616                 exdate.append(",");
 617             }
 618         }
 619         LoggerD("exdate: "<<exdate);
 620         if (CALENDAR_ERROR_NONE!=calendar_record_set_str(m_platformEvent, _calendar_event.exdate, exdate.c_str())) {
 621             LoggerW("Can't save exceptions.");
 622         }
 623     }
 624
 625     // set the setPositions
 626     if ( !rrule->getSetPositions()->empty() )
 627     {
 628         LoggerD("Set the setPositions of length: "<<rrule->getSetPositions()->size());
 629
 630         std::string bysetpos = "";
 631         for( unsigned int i=0; i<rrule->getSetPositions()->size(); i++ )
 632         {
 633             std::stringstream ss;
 634             ss<<rrule->getSetPositions()->at(i);
 635             bysetpos.append(ss.str());
 636             if(i!=rrule->getSetPositions()->size()-1) {
 637                 bysetpos.append(",");
 638             }
 639         }
 640         LoggerD("bysetpos: "<<bysetpos);
 641         if (CALENDAR_ERROR_NONE!=calendar_record_set_str(m_platformEvent, _calendar_event.bysetpos, bysetpos.c_str())) {
 642             LoggerW("Can't save setPositions.");
 643         }
 644     }
 645
 646     // set the recurrence interval
 647     if (CALENDAR_ERROR_NONE != calendar_record_set_int(m_platformEvent,
 648                                                    _calendar_event.interval,
 649                                                    rrule->getInterval()))
 650     {
 651         LoggerW("Can't set interval.");
 652     }
 653
 654     // set the recurrence end date. This is automatically calculated by platform if empty.
 655     if (UNDEFINED_TIME!=rrule->getEndDate()) {
 656         LoggerD("Setting the end date: "<<rrule->getEndDate());
 657
 658         if (CALENDAR_ERROR_NONE != calendar_record_set_int(m_platformEvent, _calendar_event.range_type, CALENDAR_RANGE_UNTIL)) {
 659             LoggerW("Can't set rrule range type.");
 660         }
 661
 662         int ret;
 663         calendar_time_s cal = {CALENDAR_TIME_UTIME, {0}};
 664         cal.type = CALENDAR_TIME_UTIME;
 665         cal.time.utime = m_abstractEvent->getRecurrenceRule()->getEndDate();
 666         ret = calendar_record_set_caltime(m_platformEvent, _calendar_event.until_time, cal);
 667         if (CALENDAR_ERROR_NONE != ret) {
 668             LoggerW("Can't set rrule until time: "<<ret);
 669         }
 670     }
 671 }
 672
 673 void EventWrapper::setAlarmsToPlatformEvent()
 674 {
 675         // Remove the preset child alarms before adding new ones.
 676     int ret;
 677     unsigned int count = 0, i;
 678
 679     if(CalendarEvent::TASK_TYPE==getType()) {
 680         ret = calendar_record_get_child_record_count(m_platformEvent, _calendar_todo.calendar_alarm, &count);
 681     } else {
 682         ret = calendar_record_get_child_record_count(m_platformEvent, _calendar_event.calendar_alarm, &count);
 683     }
 684     if (CALENDAR_ERROR_NONE != ret) {
 685         LoggerW("Can't get alarms count: "<<ret);
 686     }
 687
 688     if(0==count) {
 689         LoggerD("No alarms to remove.");
 690     } else {
 691         LoggerD("Number of alarms to remove: "<<count);
 692     }
 693
 694     calendar_record_h alarm = NULL;
 695     for(i=0; i<count; i++) {
 696                 alarm = NULL;
 697                 // Be careful about the index. We always insert 0 cause the child list is updated every time we remove one.
 698         if(CalendarEvent::TASK_TYPE==getType()) {
 699             ret = calendar_record_get_child_record_at_p(m_platformEvent, _calendar_todo.calendar_alarm, 0, &alarm);
 700         } else {
 701             ret = calendar_record_get_child_record_at_p(m_platformEvent, _calendar_event.calendar_alarm, 0, &alarm);
 702         }
 703         if (CALENDAR_ERROR_NONE != ret) {
 704             LoggerW("Can't get the alarm: "<<ret);
 705             continue;
 706         }
 707
 708         if(CalendarEvent::TASK_TYPE==getType()) {
 709             ret = calendar_record_remove_child_record(m_platformEvent, _calendar_todo.calendar_alarm, alarm);
 710         } else {
 711             ret = calendar_record_remove_child_record(m_platformEvent, _calendar_event.calendar_alarm, alarm);
 712         }
 713         if (CALENDAR_ERROR_NONE != ret) {
 714             LoggerW("Can't remove the alarm: "<<ret);
 715             continue;
 716         }
 717     }
 718
 719         // Now add the new alarms.
 720     if( 0 != m_abstractEvent->getAlarms()->size() ) {
 721         for( i=0; i<m_abstractEvent->getAlarms()->size(); i++ )
 722         {
 723             LoggerD("Set the alarms #"<<i);
 724
 725             alarm = NULL;
 726             ret = calendar_record_create(_calendar_alarm._uri, &alarm);
 727             if(CALENDAR_ERROR_NONE!=ret) {
 728                 LoggerW("Alarm creation failed: "<<ret);
 729                 continue;
 730             }
 731
 732             EventAlarmPtr theAlarm = m_abstractEvent->getAlarms()->at(i);
 733
 734             calendar_alarm_time_unit_type_e tickUnit = CALENDAR_ALARM_NONE;
 735             int tick = 0;
 736             if( UNDEFINED_TIME!=theAlarm->getAbsoluteDate() ) {
 737                 tickUnit = CALENDAR_ALARM_TIME_UNIT_SPECIFIC;
 738             } else {
 739                 if( Time::MSECS_UNIT==theAlarm->getDuration().unit ) {
 740                     tickUnit = CALENDAR_ALARM_TIME_UNIT_MINUTE; // minimum calendar time unit.
 741                     tick = theAlarm->getDuration().length / 60000;
 742                 } else if( Time::SECONDS_UNIT==theAlarm->getDuration().unit ) {
 743                     tickUnit = CALENDAR_ALARM_TIME_UNIT_MINUTE;
 744                     tick = theAlarm->getDuration().length / 1000;
 745                 } else if( Time::MINUTES_UNIT==theAlarm->getDuration().unit ) {
 746                     tickUnit = CALENDAR_ALARM_TIME_UNIT_MINUTE;
 747                     tick = theAlarm->getDuration().length;
 748                 } else if( Time::HOURS_UNIT==theAlarm->getDuration().unit ) {
 749                     tickUnit = CALENDAR_ALARM_TIME_UNIT_HOUR;
 750                     tick = theAlarm->getDuration().length;
 751                 } else if( Time::DAYS_UNIT==theAlarm->getDuration().unit ) {
 752                     tickUnit = CALENDAR_ALARM_TIME_UNIT_DAY;
 753                     tick = theAlarm->getDuration().length;
 754                 } else {
 755                     LoggerW("Wrong alarm time unit: "<<theAlarm->getDuration().unit);
 756                 }
 757             }
 758
 759             if( CALENDAR_ALARM_TIME_UNIT_SPECIFIC==tickUnit ) {
 760                 long long int time = theAlarm->getAbsoluteDate();
 761                 LoggerD("Save absolute date: "<<time);
 762                 ret = calendar_record_set_lli(alarm, _calendar_alarm.time, time);
 763                 if (CALENDAR_ERROR_NONE != ret) {
 764                     LoggerW("Can't set alarm time: "<<ret);
 765                 }
 766             } else {
 767                 ret = calendar_record_set_int(alarm, _calendar_alarm.tick, tick);
 768                 if (CALENDAR_ERROR_NONE != ret) {
 769                     LoggerW("Can't set alarm tick: "<<ret);
 770                 }
 771             }
 772
 773             ret = calendar_record_set_int(alarm, _calendar_alarm.tick_unit, tickUnit);
 774             if (CALENDAR_ERROR_NONE != ret) {
 775                 LoggerW("Can't set alarm tick unit: "<<ret);
 776             }
 777
 778             // Set the alarm type.
 779             ret = calendar_record_set_int(alarm, _calendar_alarm.type, theAlarm->getMethod());
 780             if (CALENDAR_ERROR_NONE != ret) {
 781                 LoggerW("Can't set alarm type: "<<ret);
 782             }
 783
 784             // Set the display text
 785             ret = calendar_record_set_str(alarm, _calendar_alarm.description, theAlarm->getDescription().c_str());
 786             if (CALENDAR_ERROR_NONE != ret) {
 787                 LoggerW("Can't set alarm description: "<<ret);
 788             }
 789
 790             if(CalendarEvent::TASK_TYPE==getType()) {
 791                 ret = calendar_record_add_child_record(m_platformEvent, _calendar_todo.calendar_alarm, alarm);
 792             } else {
 793                 ret = calendar_record_add_child_record(m_platformEvent, _calendar_event.calendar_alarm, alarm);
 794             }
 795             if(CALENDAR_ERROR_NONE!=ret) {
 796                 LoggerW("Cannot add alarm child record: "<<ret);
 797                 if(alarm) {
 798                     calendar_record_destroy(alarm, true);
 799                 }
 800             }
 801         }
 802     } else {
 803         LoggerD("No alarms to save.");
 804     }
 805 }
 806
 807 void EventWrapper::setStatusToPlatformEvent()
 808 {
 809     int ret;
 810     if(CalendarEvent::TASK_TYPE==getType()) {
 811         calendar_todo_status_e taskStatus = CALENDAR_TODO_STATUS_NONE;
 812
 813         switch (m_abstractEvent->getStatus()) {
 814         case CalendarEvent::NEEDS_ACTION_STATUS:
 815             taskStatus = CALENDAR_TODO_STATUS_NEEDS_ACTION;
 816             break;
 817         case CalendarEvent::COMPLETED_STATUS:
 818             taskStatus = CALENDAR_TODO_STATUS_COMPLETED;
 819             break;
 820         case CalendarEvent::IN_PROCESS_STATUS:
 821             taskStatus = CALENDAR_TODO_STATUS_IN_PROCESS;
 822             break;
 823         case CalendarEvent::CANCELLED_STATUS:
 824             taskStatus = CALENDAR_TODO_STATUS_CANCELED;
 825             break;
 826         default:
 827             break;
 828         }
 829
 830         ret = calendar_record_set_int(m_platformEvent, _calendar_todo.todo_status, taskStatus);
 831     } else {
 832         calendar_event_status_e eventStatus = CALENDAR_EVENT_STATUS_NONE;
 833
 834         switch (m_abstractEvent->getStatus()) {
 835         case CalendarEvent::TENTATIVE_STATUS:
 836             eventStatus = CALENDAR_EVENT_STATUS_TENTATIVE;
 837             break;
 838         case CalendarEvent::CONFIRMED_STATUS:
 839             eventStatus = CALENDAR_EVENT_STATUS_CONFIRMED;
 840             break;
 841         case CalendarEvent::CANCELLED_STATUS:
 842             eventStatus = CALENDAR_EVENT_STATUS_CANCELLED;
 843             break;
 844         default:
 845             break;
 846         }
 847
 848         ret = calendar_record_set_int(m_platformEvent, _calendar_event.event_status, eventStatus);
 849     }
 850
 851     if (CALENDAR_ERROR_NONE != ret) {
 852         LoggerW("Can't set item status.");
 853     }
 854 }
 855
 856 void EventWrapper::setCategoriesToPlatformEvent()
 857 {
 858     int ret;
 859     std::string categories = "";
 860
 861     // Need to concatenate all categories into one string separated by a comma.
 862     for (size_t i = 0; i < m_abstractEvent->getCategories()->size(); ++i) {
 863         if(0==i) {
 864             categories.append(m_abstractEvent->getCategories()->at(i));
 865         } else {
 866             categories.append("," + m_abstractEvent->getCategories()->at(i));
 867         }
 868     }
 869
 870     LoggerD("Saving categories: "<<categories);
 871
 872     if(CalendarEvent::TASK_TYPE==getType()) {
 873         ret = calendar_record_set_str(m_platformEvent, _calendar_todo.categories, categories.c_str());
 874     } else {
 875         ret = calendar_record_set_str(m_platformEvent, _calendar_event.categories, categories.c_str());
 876     }
 877     if (CALENDAR_ERROR_NONE !=ret) {
 878         LoggerW("Cannot save categories.");
 879     }
 880 }
 881
 882 void EventWrapper::setRecurrenceIdToPlatformEvent()
 883 {
 884     int ret;
 885     if (CalendarEvent::TASK_TYPE==getType()) {
 886         LoggerD("No need to set recurrence id for a task.");
 887     return;
 888     }
 889
 890     if(UNDEFINED_TIME!=m_abstractEvent->getRecurrenceId()) {
 891         std::stringstream ss;
 892         ss<<m_abstractEvent->getRecurrenceId();
 893         ret = calendar_record_set_str(m_platformEvent, _calendar_event.recurrence_id, ss.str().c_str());
 894         if (CALENDAR_ERROR_NONE != ret) {
 895             LoggerW("Can't set recurrence id.");
 896     } else {
 897             LoggerD("Set the recurrence id: "<<ss.str());
 898     }
 899     } else {
 900         LoggerD("Recurrence id not defined.");
 901     }
 902 }
 903
 904 void EventWrapper::setParentIdToPlatformEvent()
 905 {
 906     int ret;
 907     if (CalendarEvent::TASK_TYPE==getType()) {
 908         LoggerD("No need to set parent id for a task.");
 909         return;
 910     }
 911
 912     if(UNDEFINED_ITEM_ID!=m_abstractEvent->getParentId()) {
 913     ret = calendar_record_set_int(m_platformEvent, _calendar_event.original_event_id, m_abstractEvent->getParentId());
 914     if (CALENDAR_ERROR_NONE != ret) {
 915         LoggerW("Can't set parent Id.");
 916         } else {
 917             LoggerD("Set the parent id: "<<m_abstractEvent->getParentId());
 918         }
 919     } else {
 920         LoggerD("Parent id not defined.");
 921     }
 922 }
 923
 924 void EventWrapper::setIsAllDayToPlatformEvent()
 925 {
 926     LoggerD("All day flag is set in the start time struct: "<<m_abstractEvent->getIsAllDay());
 927 }
 928
 929 void EventWrapper::setOrganizerToPlatformEvent()
 930 {
 931     int ret;
 932     if(CalendarEvent::TASK_TYPE==getType()) {
 933         ret = calendar_record_set_str(m_platformEvent, _calendar_todo.organizer_name, m_abstractEvent->getOrganizer().c_str());
 934     } else {
 935         ret = calendar_record_set_str(m_platformEvent, _calendar_event.organizer_name, m_abstractEvent->getOrganizer().c_str());
 936     }
 937     if (CALENDAR_ERROR_NONE != ret) {
 938         LoggerW("Can't set item organizer.");
 939     }
 940 }
 941
 942 void EventWrapper::setVisibilityToPlatformEvent()
 943 {
 944     int ret;
 945     calendar_sensitivity_e visibility = CALENDAR_SENSITIVITY_PUBLIC;
 946
 947     switch (m_abstractEvent->getVisibility()) {
 948     case CalendarEvent::PUBLIC_VISIBILITY:
 949         visibility = CALENDAR_SENSITIVITY_PUBLIC;
 950         break;
 951     case CalendarEvent::PRIVATE_VISIBILITY:
 952         visibility = CALENDAR_SENSITIVITY_PRIVATE;
 953         break;
 954     case CalendarEvent::CONFIDENTIAL_VISIBILITY:
 955         visibility = CALENDAR_SENSITIVITY_CONFIDENTIAL;
 956         break;
 957     default:
 958         LoggerD("Use the default visibility");
 959         break;
 960     }
 961
 962     if(CalendarEvent::TASK_TYPE==getType()) {
 963         ret = calendar_record_set_int(m_platformEvent, _calendar_todo.sensitivity, visibility);
 964     } else {
 965         ret = calendar_record_set_int(m_platformEvent, _calendar_event.sensitivity, visibility);
 966     }
 967     if (CALENDAR_ERROR_NONE != ret) {
 968         LoggerW("Can't set visibility.");
 969     }
 970 }
 971
 972 void EventWrapper::setAvailabilityToPlatformEvent()
 973 {
 974     if(CalendarEvent::TASK_TYPE==getType()) {
 975         LoggerD("No need to set availability for a task.");
 976         return;
 977     }
 978
 979     calendar_event_busy_status_e availability = CALENDAR_EVENT_BUSY_STATUS_FREE;
 980     switch (m_abstractEvent->getAvailability()) {
 981     case CalendarEvent::BUSY_FB:
 982         availability = CALENDAR_EVENT_BUSY_STATUS_BUSY;
 983         break;
 984     case CalendarEvent::BUSY_UNAVAILABLE_FB:
 985         availability = CALENDAR_EVENT_BUSY_STATUS_UNAVAILABLE;
 986         break;
 987     case CalendarEvent::FREE_FB:
 988         availability = CALENDAR_EVENT_BUSY_STATUS_FREE;
 989         break;
 990     case CalendarEvent::BUSY_TENTATIVE_FB:
 991         availability = CALENDAR_EVENT_BUSY_STATUS_TENTATIVE;
 992         break;
 993     default:
 994         LoggerD("Use the default availability");
 995         break;
 996     }
 997
 998     int ret = calendar_record_set_int(m_platformEvent, _calendar_event.busy_status, availability);
 999     if (CALENDAR_ERROR_NONE != ret) {
1000         LoggerW("Can't set availability.");
1001     }
1002 }
1003
1004 void EventWrapper::setUIdToPlatformEvent()
1005 {
1006     int ret;
1007     if(CalendarEvent::TASK_TYPE==getType()) {
1008         ret = calendar_record_set_str(m_platformEvent, _calendar_todo.uid, m_abstractEvent->getUId().c_str());
1009     } else {
1010         ret = calendar_record_set_str(m_platformEvent, _calendar_event.uid, m_abstractEvent->getUId().c_str());
1011     }
1012     if (CALENDAR_ERROR_NONE != ret) {
1013         LoggerW("Can't set item uid.");
1014     }
1015 }
1016
1017 void EventWrapper::setAttendeesToPlatformEvent()
1018 {
1019         // Remove the preset child attendees before adding new ones.
1020     int ret;
1021     unsigned int count = 0, i;
1022
1023     if(CalendarEvent::TASK_TYPE==getType()) {
1024         ret = calendar_record_get_child_record_count(m_platformEvent, _calendar_todo.calendar_attendee, &count);
1025     } else {
1026         ret = calendar_record_get_child_record_count(m_platformEvent, _calendar_event.calendar_attendee, &count);
1027     }
1028     if (CALENDAR_ERROR_NONE != ret) {
1029         LoggerW("Can't get attendees count: "<<ret);
1030     }
1031
1032     if(0==count) {
1033         LoggerD("No attendees to remove.");
1034     } else {
1035         LoggerD("Number of attendees to remove: "<<count);
1036     }
1037
1038     calendar_record_h attendee = NULL;
1039     for(i=0; i<count; i++) {
1040                 attendee = NULL;
1041                 // Be careful about the index. We always insert 0 cause the child list is updated every time we remove one.
1042         if(CalendarEvent::TASK_TYPE==getType()) {
1043             ret = calendar_record_get_child_record_at_p(m_platformEvent, _calendar_todo.calendar_attendee, 0, &attendee);
1044         } else {
1045             ret = calendar_record_get_child_record_at_p(m_platformEvent, _calendar_event.calendar_attendee, 0, &attendee);
1046         }
1047         if (CALENDAR_ERROR_NONE != ret) {
1048             LoggerW("Can't get the attendee: "<<ret);
1049             continue;
1050         }
1051
1052         if(CalendarEvent::TASK_TYPE==getType()) {
1053             ret = calendar_record_remove_child_record(m_platformEvent, _calendar_todo.calendar_attendee, attendee);
1054         } else {
1055             ret = calendar_record_remove_child_record(m_platformEvent, _calendar_event.calendar_attendee, attendee);
1056         }
1057         if (CALENDAR_ERROR_NONE != ret) {
1058             LoggerW("Can't remove the attendee: "<<ret);
1059             continue;
1060         }
1061     }
1062
1063         // Now add the new attendees.
1064     EventAttendeeListPtr attendeeList  = m_abstractEvent->getAttendees();
1065
1066     if( 0!=attendeeList->size() ) {
1067         for (i = 0; i < attendeeList->size(); ++i) {
1068             LoggerD("Adding attendee "<<i+1<<" over "<<attendeeList->size());
1069
1070             attendee = NULL;
1071             ret = calendar_record_create(_calendar_attendee._uri, &attendee);
1072             if(CALENDAR_ERROR_NONE!=ret) {
1073                 LoggerW("Attendee creation failed: "<<ret);
1074                 continue;
1075             }
1076
1077             EventAttendeePtr theAttendee = attendeeList->at(i);
1078
1079             // save name
1080             ret = calendar_record_set_str(attendee, _calendar_attendee.name, theAttendee->getName().c_str());
1081             if (CALENDAR_ERROR_NONE!=ret) {
1082                 LoggerW("Cannot set attendee name: "<<ret);
1083             }
1084
1085             // save uri
1086             ret = calendar_record_set_str(attendee, _calendar_attendee.email, theAttendee->getURI().c_str());
1087             if (CALENDAR_ERROR_NONE!=ret) {
1088                 LoggerW("Cannot set attendee URI: "<<ret);
1089             }
1090
1091             // save role
1092             calendar_attendee_role_e role = CALENDAR_ATTENDEE_ROLE_CHAIR;
1093             switch (theAttendee->getRole()) {
1094             case EventAttendee::REQ_PARTICIPANT_ROLE:
1095                 role = CALENDAR_ATTENDEE_ROLE_REQ_PARTICIPANT;
1096                 break;
1097             case EventAttendee::OPT_PARTICIPANT_ROLE:
1098                 role = CALENDAR_ATTENDEE_ROLE_OPT_PARTICIPANT;
1099                 break;
1100             case EventAttendee::NON_PARTICIPANT_ROLE:
1101                 role = CALENDAR_ATTENDEE_ROLE_NON_PARTICIPANT;
1102                 break;
1103             case EventAttendee::CHAIR_ROLE:
1104                 role = CALENDAR_ATTENDEE_ROLE_CHAIR;
1105                 break;
1106             default:
1107                 LoggerD("Use the default role");
1108                 break;
1109             }
1110             ret = calendar_record_set_int(attendee, _calendar_attendee.role, role);
1111             if (CALENDAR_ERROR_NONE != ret) {
1112                 LoggerW("Cannot set attendee role: "<<ret);
1113             }
1114
1115             // save status
1116             calendar_attendee_status_e status = CALENDAR_ATTENDEE_STATUS_PENDING;
1117             switch (theAttendee->getStatus()) {
1118             case EventAttendee::PENDING_AT_STATUS:
1119                 status = CALENDAR_ATTENDEE_STATUS_PENDING;
1120                 break;
1121             case EventAttendee::ACCEPTED_AT_STATUS:
1122                 status = CALENDAR_ATTENDEE_STATUS_ACCEPTED;
1123                 break;
1124             case EventAttendee::DECLINED_AT_STATUS:
1125                 status = CALENDAR_ATTENDEE_STATUS_DECLINED;
1126                 break;
1127             case EventAttendee::TENTATIVE_AT_STATUS:
1128                 status = CALENDAR_ATTENDEE_STATUS_TENTATIVE;
1129                 break;
1130             case EventAttendee::DELEGATED_AT_STATUS:
1131                 status = CALENDAR_ATTENDEE_STATUS_DELEGATED;
1132                 break;
1133             case EventAttendee::COMPLETED_AT_STATUS:
1134                 status = CALENDAR_ATTENDEE_STATUS_COMPLETED;
1135                 break;
1136             case EventAttendee::IN_PROCESS_AT_STATUS:
1137                 status = CALENDAR_ATTENDEE_STATUS_IN_PROCESS;
1138                 break;
1139             default:
1140                 LoggerD("Use the default status");
1141                 break;
1142             }
1143             ret = calendar_record_set_int(attendee, _calendar_attendee.status, status);
1144             if (CALENDAR_ERROR_NONE != ret) {
1145                 LoggerW("Cannot set attendee status: "<<ret);
1146             }
1147
1148             // save RSVP
1149             ret = calendar_record_set_int(attendee, _calendar_attendee.rsvp, theAttendee->getRSVP());
1150             if (CALENDAR_ERROR_NONE != ret) {
1151                 LoggerW("Cannot set attendee RSVP: "<<ret);
1152             }
1153
1154             // save type
1155             ret = calendar_record_set_int(attendee, _calendar_attendee.type, theAttendee->getType());
1156             if (CALENDAR_ERROR_NONE != ret) {
1157                 LoggerW("Cannot set attendee type: "<<ret);
1158             }
1159
1160             // save group
1161             ret = calendar_record_set_str(attendee, _calendar_attendee.group, theAttendee->getGroup().c_str());
1162             if (CALENDAR_ERROR_NONE != ret) {
1163                 LoggerW("Cannot set attendee group: "<<ret);
1164             }
1165
1166             // save delegatorURI
1167             ret = calendar_record_set_str(attendee, _calendar_attendee.delegator_uri, theAttendee->getDelegatorURI().c_str());
1168             if (CALENDAR_ERROR_NONE != ret ) {
1169                 LoggerW("Cannot set attendee delegator uri "<<ret);
1170             }
1171
1172             // save delegateURI
1173             ret = calendar_record_set_str(attendee, _calendar_attendee.delegate_uri, theAttendee->getDelegateURI().c_str());
1174             if (CALENDAR_ERROR_NONE != ret) {
1175                 LoggerW("Cannot set attendee delegate uri: "<<ret);
1176             }
1177
1178             // save contactId
1179             ret = calendar_record_set_str(attendee, _calendar_attendee.uid, theAttendee->getContactId().c_str());
1180             if (CALENDAR_ERROR_NONE != ret) {
1181                 LoggerW("Cannot set attendee uid: "<<ret);
1182             }
1183
1184             // save addressBookId
1185             std::stringstream ss(attendeeList->at(i)->getAddressBookId());
1186             int addressBookId;
1187             ss>>addressBookId;
1188             LoggerD("addressBookId: "<<addressBookId);
1189             ret = calendar_record_set_int(attendee, _calendar_attendee.person_id, addressBookId);
1190             if (CALENDAR_ERROR_NONE != ret) {
1191                 LoggerW("Cannot set attendee address book id "<<ret);
1192             }
1193
1194             if(CalendarEvent::TASK_TYPE==getType()) {
1195                 ret = calendar_record_add_child_record(m_platformEvent, _calendar_todo.calendar_attendee, attendee);
1196                 return;
1197             } else {
1198                 ret = calendar_record_add_child_record(m_platformEvent, _calendar_event.calendar_attendee, attendee);
1199             }
1200             if(CALENDAR_ERROR_NONE!=ret) {
1201                 LoggerW("Cannot add attendee child record: "<<ret);
1202                 if(attendee) {
1203                     calendar_record_destroy(attendee, true);
1204                 }
1205             }
1206         }
1207     } else {
1208        LoggerD("No attendee to save.");
1209    }
1210 }
1211
1212 void EventWrapper::setPositionToPlatformEvent()
1213 {
1214     int ret;
1215     if(CalendarEvent::TASK_TYPE==getType()) {
1216         ret = calendar_record_set_double(m_platformEvent, _calendar_todo.latitude, m_abstractEvent->getGeolocation()->getLatitude());
1217     } else {
1218         ret = calendar_record_set_double(m_platformEvent, _calendar_event.latitude, m_abstractEvent->getGeolocation()->getLatitude());
1219     }
1220     if (CALENDAR_ERROR_NONE != ret) {
1221         LoggerW("Can't set latitude: "<<ret);
1222     }
1223
1224     if(CalendarEvent::TASK_TYPE==getType()) {
1225         ret = calendar_record_set_double(m_platformEvent, _calendar_todo.longitude, m_abstractEvent->getGeolocation()->getLongitude());
1226     } else {
1227         ret = calendar_record_set_double(m_platformEvent, _calendar_event.longitude, m_abstractEvent->getGeolocation()->getLongitude());
1228     }
1229
1230     if (CALENDAR_ERROR_NONE != ret) {
1231         LoggerW("Can't set longitude: "<<ret);
1232     }
1233 }
1234
1235 void EventWrapper::setPriorityToPlatformEvent()
1236 {
1237     int ret;
1238     if(CalendarEvent::TASK_TYPE==getType()) {
1239         calendar_todo_priority_e todoPriority = CALENDAR_TODO_PRIORITY_NORMAL;
1240
1241         switch (m_abstractEvent->getPriority()) {
1242         case CalendarEvent::HIGH_PRIORITY:
1243             todoPriority = CALENDAR_TODO_PRIORITY_HIGH;
1244             break;
1245         case CalendarEvent::MEDIUM_PRIORITY:
1246             todoPriority = CALENDAR_TODO_PRIORITY_NORMAL;
1247             break;
1248         case CalendarEvent::LOW_PRIORITY:
1249             todoPriority = CALENDAR_TODO_PRIORITY_LOW;
1250             break;
1251         default:
1252             break;
1253         }
1254
1255         ret = calendar_record_set_int(m_platformEvent, _calendar_todo.priority, todoPriority);
1256         if (CALENDAR_ERROR_NONE != ret) {
1257             LoggerW("Can't set task priority: "<<ret);
1258         }
1259     } else {
1260         calendar_event_priority_e eventPriority = CALENDAR_EVENT_PRIORITY_NORMAL;
1261
1262         switch (m_abstractEvent->getPriority()) {
1263         case CalendarEvent::HIGH_PRIORITY:
1264             eventPriority = CALENDAR_EVENT_PRIORITY_HIGH;
1265             break;
1266         case CalendarEvent::MEDIUM_PRIORITY:
1267             eventPriority = CALENDAR_EVENT_PRIORITY_NORMAL;
1268             break;
1269         case CalendarEvent::LOW_PRIORITY:
1270             eventPriority = CALENDAR_EVENT_PRIORITY_LOW;
1271             break;
1272         default:
1273             break;
1274         }
1275
1276         ret = calendar_record_set_int(m_platformEvent, _calendar_event.priority, eventPriority);
1277         if (CALENDAR_ERROR_NONE != ret) {
1278             LoggerW("Can't set event priority: "<<ret);
1279         }
1280     }
1281 }
1282
1283 void EventWrapper::setCreatedDateToPlatformEvent()
1284 {
1285     int ret;
1286
1287     if(CalendarEvent::TASK_TYPE==getType()) {
1288         ret = calendar_record_set_lli(m_platformEvent, _calendar_todo.created_time, m_abstractEvent->getCreatedDate());
1289     } else {
1290         ret = calendar_record_set_lli(m_platformEvent, _calendar_event.created_time, m_abstractEvent->getCreatedDate());
1291     }
1292     if (CALENDAR_ERROR_NONE != ret) {
1293         LoggerW("Can't set createde time: "<<ret);
1294     }
1295 }
1296
1297 void EventWrapper::setCompletedDateToPlatformEvent()
1298 {
1299     if(CalendarEvent::EVENT_TYPE==getType()) {
1300         LoggerD("No need to set the completed date for an event.");
1301         return;
1302     }
1303
1304     int ret = calendar_record_set_lli(m_platformEvent, _calendar_todo.completed_time, m_abstractEvent->getCompletedDate());
1305     if (CALENDAR_ERROR_NONE != ret) {
1306         LoggerW( "Can't set createde time: "<<ret);
1307     }
1308 }
1309
1310 void EventWrapper::setProgressToPlatformEvent()
1311 {
1312     if(CalendarEvent::EVENT_TYPE==getType()) {
1313         LoggerD("No need to set the progress for an event.");
1314         return;
1315     }
1316
1317     int ret = calendar_record_set_int(m_platformEvent, _calendar_todo.progress, m_abstractEvent->getProgress());
1318     if (CALENDAR_ERROR_NONE != ret) {
1319         LoggerW("Can't set progress: "<<ret);
1320     }
1321 }
1322
1323 CalendarEventPtr EventWrapper::convertPlatformEventToAbstractEvent()
1324 {
1325     LoggerD("Convert to abstract item.");
1326
1327     setCalendarIdFromPlatformEvent();
1328     setDescriptionFromPlatformEvent();
1329     setSummaryFromPlatformEvent();
1330     setStartTimeFromPlatformEvent();
1331     setEndTimeFromPlatformEvent(); // replace for duration
1332     setLocationFromPlatformEvent();
1333     setCategoriesFromPlatformEvent();
1334     setStatusFromPlatformEvent();
1335     setAlarmsFromPlatformEvent();
1336     setIsAllDayFromPlatformEvent();
1337     setOrganizerFromPlatformEvent();
1338     setAttendeesFromPlatformEvent();
1339     setPositionFromPlatformEvent();
1340     setVisibilityFromPlatformEvent();
1341     setLastModifiedDateFromPlatformEvent();
1342     setAvailabilityFromPlatformEvent();
1343     setRecurrenceRuleFromPlatformEvent();
1344     setIdFromPlatformEvent();
1345     setRecurrenceIdFromPlatformEvent();
1346     setParentIdFromPlatformEvent();
1347     //setUIdFromPlatformEvent(); // We set the uid value as the same with id.
1348     setPriorityFromPlatformEvent();
1349     setCreatedDateFromPlatformEvent();
1350     setCompletedDateFromPlatformEvent();
1351     setProgressFromPlatformEvent();
1352     setIsDetachedFromPlatformEvent();
1353
1354     return getAbstractEvent();
1355 }
1356
1357 void EventWrapper::setCalendarIdFromPlatformEvent()
1358 {
1359     int ret, calendarId;
1360
1361     if(CalendarEvent::TASK_TYPE==getType()) {
1362         ret = calendar_record_get_int(m_platformEvent, _calendar_todo.calendar_book_id, &calendarId);
1363     } else {
1364         ret = calendar_record_get_int(m_platformEvent, _calendar_event.calendar_book_id, &calendarId);
1365     }
1366     if (CALENDAR_ERROR_NONE != ret) {
1367         LoggerW("Can't get calenadrId: "<<ret);
1368     }
1369
1370         m_abstractEvent->setCalendarId(calendarId);
1371 }
1372
1373 void EventWrapper::setDescriptionFromPlatformEvent()
1374 {
1375     int ret;
1376     char *description = NULL;
1377     if(CalendarEvent::TASK_TYPE==getType()) {
1378         ret = calendar_record_get_str(m_platformEvent, _calendar_todo.description, &description);
1379     } else {
1380         ret = calendar_record_get_str(m_platformEvent, _calendar_event.description, &description);
1381     }
1382     if (CALENDAR_ERROR_NONE != ret) {
1383         LoggerW("Can't get description: "<<ret);
1384     }
1385
1386     if (description) {
1387         m_abstractEvent->setDescription(description);
1388         free(description);
1389     }
1390 }
1391
1392 void EventWrapper::setSummaryFromPlatformEvent()
1393 {
1394     int ret;
1395     char *summary = NULL;
1396     if(CalendarEvent::TASK_TYPE==getType()) {
1397         ret = calendar_record_get_str(m_platformEvent, _calendar_todo.summary, &summary);
1398     } else {
1399         ret = calendar_record_get_str(m_platformEvent, _calendar_event.summary, &summary);
1400     }
1401     if (CALENDAR_ERROR_NONE != ret) {
1402         LoggerW("Can't get summary: "<<ret);
1403     }
1404
1405     if (summary) {
1406         m_abstractEvent->setSubject(summary);
1407         free(summary);
1408     }
1409 }
1410
1411 void EventWrapper::setStartTimeFromPlatformEvent()
1412 {
1413     int ret;
1414     calendar_time_s cal;
1415
1416     // Retrive the time zone info only when the start time is loaded.
1417     char *timeZone = NULL;
1418     if(CalendarEvent::TASK_TYPE==getType()) {
1419         ret = calendar_record_get_str(m_platformEvent, _calendar_todo.start_tzid, &timeZone);
1420     } else {
1421         ret = calendar_record_get_str(m_platformEvent, _calendar_event.start_tzid, &timeZone);
1422     }
1423     if (CALENDAR_ERROR_NONE != ret) {
1424         LoggerW("Can't get time zone: "<<ret);
1425     }
1426
1427     if( timeZone ) {
1428         LoggerD("timeZone: "<<timeZone);
1429         m_abstractEvent->setTimeZone(std::string(timeZone));
1430     }
1431
1432     if(CalendarEvent::TASK_TYPE==getType()) {
1433         ret = calendar_record_get_caltime(m_platformEvent, _calendar_todo.start_time, &cal);
1434     } else {
1435         ret = calendar_record_get_caltime(m_platformEvent, _calendar_event.start_time, &cal);
1436     }
1437     if (CALENDAR_ERROR_NONE != ret) {
1438         LoggerW("Can't get start time: "<<ret);
1439     }
1440
1441     // Set the isAllDay flag also.
1442     if(CALENDAR_TIME_LOCALTIME==cal.type) {
1443         m_abstractEvent->setStartTime(CalendarUtility::calTimeToLLI(timeZone, cal));
1444         m_abstractEvent->setIsAllDay(true);
1445     } else {
1446         m_abstractEvent->setStartTime(cal.time.utime);
1447         m_abstractEvent->setIsAllDay(false);
1448     }
1449
1450         if( timeZone ) {
1451                 free(timeZone);
1452         }
1453 }
1454
1455 void EventWrapper::setEndTimeFromPlatformEvent()
1456 {
1457     int ret;
1458     calendar_time_s cal;
1459
1460     if(CalendarEvent::TASK_TYPE==getType()) {
1461         ret = calendar_record_get_caltime(m_platformEvent, _calendar_todo.due_time, &cal);
1462     } else {
1463         ret = calendar_record_get_caltime(m_platformEvent, _calendar_event.end_time, &cal);
1464     }
1465     if (CALENDAR_ERROR_NONE != ret) {
1466         LoggerW("Can't get due/end time: "<<ret);
1467         return;
1468     }
1469
1470     // Set the isAllDay flag also.
1471     if(CALENDAR_TIME_LOCALTIME==cal.type) {
1472         m_abstractEvent->setEndTime(CalendarUtility::calTimeToLLI(m_abstractEvent->getTimeZone().c_str(), cal));
1473     } else {
1474     m_abstractEvent->setEndTime(cal.time.utime);
1475 }
1476 }
1477
1478 void EventWrapper::setLocationFromPlatformEvent()
1479 {
1480     int ret;
1481     char *location = NULL;
1482     if(CalendarEvent::TASK_TYPE==getType()) {
1483         ret = calendar_record_get_str(m_platformEvent, _calendar_todo.location, &location);
1484     } else {
1485         ret = calendar_record_get_str(m_platformEvent, _calendar_event.location, &location);
1486     }
1487     if (CALENDAR_ERROR_NONE != ret) {
1488         LoggerW("Can't get location: "<<ret);
1489     }
1490
1491     if (location) {
1492         m_abstractEvent->setLocation(location);
1493         free(location);
1494     }
1495 }
1496
1497 void EventWrapper::setRecurrenceRuleFromPlatformEvent()
1498 {
1499     if (CalendarEvent::TASK_TYPE==getType()) {
1500         LoggerD("No need to set rrule for a task.");
1501         return;
1502     }
1503
1504     int ret;
1505     EventRecurrenceRulePtr rrule(new EventRecurrenceRule());
1506
1507     // load the recurrence frequency
1508     int frequency;
1509     ret = calendar_record_get_int(m_platformEvent, _calendar_event.freq, &frequency);
1510     if (CALENDAR_ERROR_NONE != ret) {
1511         LoggerW("Can't get frequency: "<<ret);
1512         return;
1513     }
1514     LoggerD("frequency "<<frequency);
1515     switch (frequency) {
1516     case CALENDAR_RECURRENCE_NONE:
1517         rrule->setFrequency(EventRecurrenceRule::NO_RECURRENCE);
1518         return;
1519         break;
1520     case CALENDAR_RECURRENCE_DAILY:
1521         rrule->setFrequency(EventRecurrenceRule::DAILY_RECURRENCE);
1522         break;
1523     case CALENDAR_RECURRENCE_WEEKLY:
1524         rrule->setFrequency(EventRecurrenceRule::WEEKLY_RECURRENCE);
1525         break;
1526     case CALENDAR_RECURRENCE_MONTHLY:
1527         rrule->setFrequency(EventRecurrenceRule::MONTHLY_RECURRENCE);
1528         break;
1529     case CALENDAR_RECURRENCE_YEARLY:
1530         rrule->setFrequency(EventRecurrenceRule::YEARLY_RECURRENCE);
1531         break;
1532     default:
1533         LoggerW("Unknown recurrence frequency.");
1534         rrule->setFrequency(EventRecurrenceRule::NO_RECURRENCE);
1535         return;
1536         break;
1537     }
1538
1539     // load the byday
1540     StringArrayPtr daysOfTheWeek(new StringArray());
1541     char* byday = NULL;
1542     ret = calendar_record_get_str(m_platformEvent, _calendar_event.byday, &byday);
1543     if (CALENDAR_ERROR_NONE != ret) {
1544         LoggerW("Can't get byday: "<<ret);
1545     }
1546     if (byday) {
1547             LoggerD("Loaded byday: "<<byday);
1548         char *saveptr = NULL;
1549         char* pch = strtok_r(byday, ",", &saveptr);
1550         while (NULL != pch) {
1551             (*daysOfTheWeek).push_back(pch);
1552             pch = strtok_r(NULL, ",", &saveptr);
1553         }
1554         free(byday);
1555     }
1556     rrule->setDaysOfTheWeek(daysOfTheWeek);
1557     LoggerD("Number of daysOfTheWeek: "<<rrule->getDaysOfTheWeek()->size());
1558
1559     // load the recurrence interval
1560     int interval;
1561     ret = calendar_record_get_int(m_platformEvent, _calendar_event.interval, &interval);
1562     if (CALENDAR_ERROR_NONE != ret) {
1563         LoggerW("Can't get interval: "<<ret);
1564     }
1565     rrule->setInterval(interval);
1566
1567     // load the ocurrence count
1568     int occurrrenceCount;
1569     ret = calendar_record_get_int(m_platformEvent, _calendar_event.count, &occurrrenceCount);
1570     if (CALENDAR_ERROR_NONE != ret) {
1571         LoggerW("Can't get occurrrence count: "<<ret);
1572     }
1573     rrule->setOccurrenceCount(occurrrenceCount);
1574
1575     // load the recurrence end date
1576     calendar_time_s cal = {CALENDAR_TIME_UTIME, {0}};
1577     ret = calendar_record_get_caltime(m_platformEvent, _calendar_event.until_time, &cal);
1578     if (CALENDAR_ERROR_NONE != ret) {
1579         LoggerW("Can't get recurrence end date: "<<ret);
1580     }
1581         if(cal.time.utime>0) {
1582                 if(CALENDAR_RECORD_NO_UNTIL==cal.time.utime) {
1583                         rrule->setEndDate(UNDEFINED_TIME);
1584                 } else {
1585                     rrule->setEndDate(cal.time.utime);
1586                 }
1587         } else {
1588                 rrule->setEndDate(UNDEFINED_TIME);
1589         }
1590     LoggerD("endDate from platform = "<<rrule->getEndDate());
1591
1592     // load the exceptions
1593     NumberArrayPtr exceptions(new NumberArray());
1594     char* exdate = NULL;
1595     ret = calendar_record_get_str(m_platformEvent, _calendar_event.exdate, &exdate);
1596     if (CALENDAR_ERROR_NONE != ret) {
1597         LoggerW("Can't get exdate: "<<ret);
1598     }
1599     if (exdate) {
1600             LoggerD("Loaded exdate: "<<exdate);
1601         char *saveptr = NULL;
1602         char *pch = strtok_r(exdate, ",", &saveptr);
1603         while (NULL != pch) {
1604             std::stringstream ss(pch);
1605             long long int oneException;
1606             ss>>oneException;
1607             (*exceptions).push_back(oneException);
1608             pch = strtok_r(NULL, ",", &saveptr);
1609         }
1610         free(exdate);
1611     }
1612     rrule->setExceptions(exceptions);
1613     LoggerD("Number of exceptions: "<<rrule->getExceptions()->size());
1614
1615     // load the setPositions
1616     NumberArrayPtr setPositions(new NumberArray());
1617     char* bysetpos = NULL;
1618     ret = calendar_record_get_str(m_platformEvent, _calendar_event.bysetpos, &bysetpos);
1619     if (CALENDAR_ERROR_NONE != ret) {
1620         LoggerW("Can't get bysetpos: "<<ret);
1621     }
1622     if (bysetpos) {
1623             LoggerD("Loaded bysetpos: "<<bysetpos);
1624         char *saveptr = NULL;
1625         char *pch = strtok_r(bysetpos, ",", &saveptr);
1626         while (NULL != pch) {
1627             std::stringstream ss(pch);
1628             int setPos;
1629             ss>>setPos;
1630             (*setPositions).push_back(setPos);
1631             pch = strtok_r(NULL, ",", &saveptr);
1632         }
1633         free(bysetpos);
1634     }
1635     rrule->setSetPositions(setPositions);
1636     LoggerD("Number of setPositions: "<<rrule->getSetPositions()->size());
1637
1638     // set the loaded recurrence rule
1639     m_abstractEvent->setRecurrenceRule(rrule);
1640 }
1641
1642 void EventWrapper::setAlarmsFromPlatformEvent()
1643 {
1644     int ret;
1645     unsigned int count = 0, i;
1646     calendar_list_h list = NULL;
1647
1648     if(CalendarEvent::TASK_TYPE==getType()) {
1649         ret = calendar_record_get_child_record_count(m_platformEvent, _calendar_todo.calendar_alarm, &count);
1650     } else {
1651         ret = calendar_record_get_child_record_count(m_platformEvent, _calendar_event.calendar_alarm, &count);
1652     }
1653     if (CALENDAR_ERROR_NONE != ret) {
1654         LoggerW("Can't get alarms count: "<<ret);
1655     }
1656
1657     if(0==count) {
1658         LoggerD("No alarms to set.");
1659         return;
1660     } else {
1661         LoggerD("Number of alarms: "<<count);
1662     }
1663
1664     if(CalendarEvent::TASK_TYPE==getType()) {
1665         ret = calendar_record_clone_child_record_list(m_platformEvent, _calendar_todo.calendar_alarm, &list);
1666     } else {
1667         ret = calendar_record_clone_child_record_list(m_platformEvent, _calendar_event.calendar_alarm, &list);
1668     }
1669     if (CALENDAR_ERROR_NONE != ret) {
1670         LoggerW("Can't get alarms list: "<<ret);
1671         return;
1672     }
1673
1674     int tick, tickUnit;
1675     calendar_record_h alarm = NULL;
1676     for(i=0; i<count; i++)
1677     {
1678         LoggerD("Processing the alarm #"<<i);
1679
1680         if(CalendarEvent::TASK_TYPE==getType()) {
1681             ret = calendar_record_get_child_record_at_p(m_platformEvent, _calendar_todo.calendar_alarm, i, &alarm);
1682         } else {
1683             ret = calendar_record_get_child_record_at_p(m_platformEvent, _calendar_event.calendar_alarm, i, &alarm);
1684         }
1685         if (CALENDAR_ERROR_NONE != ret) {
1686             LoggerW("Can't get the alarm: "<<ret);
1687             continue;
1688         }
1689
1690         EventAlarmPtr theAlarm( new EventAlarm() );
1691
1692         ret = calendar_record_get_int(alarm, _calendar_alarm.tick_unit, &tickUnit);
1693         if (CALENDAR_ERROR_NONE != ret) {
1694             LoggerW("Cannot read alarm tick unit: "<<ret);
1695             continue;
1696         }
1697
1698         if( CALENDAR_ALARM_TIME_UNIT_SPECIFIC==tickUnit ) {
1699             long long int time;
1700             ret = calendar_record_get_lli(alarm, _calendar_alarm.time, &time);
1701             if (CALENDAR_ERROR_NONE != ret) {
1702                 LoggerW("Can't get alarm tick: "<<ret);
1703                 continue;
1704             }
1705             theAlarm->setAbsoluteDate(time);
1706             LoggerD("Loaded absolute date: "<<theAlarm->getAbsoluteDate());
1707         } else {
1708             ret = calendar_record_get_int(alarm, _calendar_alarm.tick, &tick);
1709             if (CALENDAR_ERROR_NONE != ret) {
1710                 LoggerW("Cannot read alarm tick. Stop processing alarms.");
1711                 continue;
1712             }
1713
1714             Time::DurationProperties duration;
1715             if( CALENDAR_ALARM_TIME_UNIT_MINUTE==tickUnit ) {
1716                 duration.unit = Time::MINUTES_UNIT;
1717                 duration.length = tick;
1718             } else if( CALENDAR_ALARM_TIME_UNIT_HOUR==tickUnit ) {
1719                 duration.unit = Time::HOURS_UNIT;
1720                 duration.length = tick;
1721             } else if( CALENDAR_ALARM_TIME_UNIT_DAY==tickUnit ) {
1722                 duration.unit = Time::DAYS_UNIT;
1723                 duration.length = tick;
1724             } else if( CALENDAR_ALARM_TIME_UNIT_WEEK==tickUnit) {
1725                 duration.unit = Time::DAYS_UNIT;
1726                 duration.length = tick*7;
1727             } else if( CALENDAR_ALARM_TIME_UNIT_MONTH==tickUnit) {
1728                 // Not supportd correctly.
1729                 duration.unit = Time::DAYS_UNIT;
1730                 duration.length = tick*30;
1731             } else {
1732                 LoggerW("Wrong tick unit: "<<tickUnit);
1733             }
1734
1735             theAlarm->setDuration(duration);
1736         }
1737
1738         int type;
1739         ret = calendar_record_get_int(alarm, _calendar_alarm.type, &type);
1740         if (CALENDAR_ERROR_NONE != ret) {
1741             LoggerW("Cannot read alarm type: "<<ret);
1742             continue;
1743         }
1744         theAlarm->setMethod((EventAlarm::EventAlarmType)type);
1745
1746         char* description = NULL;
1747         ret = calendar_record_get_str(alarm, _calendar_alarm.description, &description);
1748         if (CALENDAR_ERROR_NONE != ret) {
1749             LoggerW("Cannot read alarm description: "<<ret);
1750             theAlarm->setDescription("");
1751             free(description);
1752         } else {
1753             if(description) {
1754                     LoggerD("Alarm description: "<<description);
1755                 theAlarm->setDescription(description);
1756             }
1757         }
1758
1759         // Save the alarm.
1760         m_abstractEvent->getAlarms()->push_back(theAlarm);
1761     }
1762
1763     if(list) {
1764         calendar_list_destroy(list, true);
1765     }
1766     LoggerD("Number of alarms: "<<m_abstractEvent->getAlarms()->size());
1767 }
1768
1769 void EventWrapper::setStatusFromPlatformEvent()
1770 {
1771     int ret;
1772     int status;
1773     if(CalendarEvent::TASK_TYPE==getType()) {
1774         ret = calendar_record_get_int(m_platformEvent, _calendar_todo.todo_status, &status);
1775     } else {
1776         ret = calendar_record_get_int(m_platformEvent, _calendar_event.event_status, &status);
1777     }
1778     if (CALENDAR_ERROR_NONE != ret) {
1779         LoggerW("Can't get status: "<<ret);
1780         return;
1781     }
1782
1783     switch (status) {
1784     case CALENDAR_EVENT_STATUS_TENTATIVE:
1785         m_abstractEvent->setStatus(CalendarEvent::TENTATIVE_STATUS);
1786         break;
1787     case CALENDAR_EVENT_STATUS_CONFIRMED:
1788         m_abstractEvent->setStatus(CalendarEvent::CONFIRMED_STATUS);
1789         break;
1790     case CALENDAR_EVENT_STATUS_CANCELLED:
1791     case CALENDAR_TODO_STATUS_CANCELED:
1792         m_abstractEvent->setStatus(CalendarEvent::CANCELLED_STATUS);
1793         break;
1794     case CALENDAR_TODO_STATUS_NEEDS_ACTION:
1795         m_abstractEvent->setStatus(CalendarEvent::NEEDS_ACTION_STATUS);
1796         break;
1797     case CALENDAR_TODO_STATUS_COMPLETED:
1798         m_abstractEvent->setStatus(CalendarEvent::COMPLETED_STATUS);
1799         break;
1800     case CALENDAR_TODO_STATUS_IN_PROCESS:
1801         m_abstractEvent->setStatus(CalendarEvent::IN_PROCESS_STATUS);
1802         break;
1803     default:
1804         m_abstractEvent->setStatus(CalendarEvent::UNDEFINED_STATUS);
1805         break;
1806     }
1807 }
1808
1809 void EventWrapper::setCategoriesFromPlatformEvent()
1810 {
1811     m_abstractEvent->getCategories()->clear();
1812
1813     int ret;
1814     char *categories = NULL;
1815     if(CalendarEvent::TASK_TYPE==getType()) {
1816         ret = calendar_record_get_str(m_platformEvent, _calendar_todo.categories, &categories);
1817     } else {
1818         ret = calendar_record_get_str(m_platformEvent, _calendar_event.categories, &categories);
1819     }
1820     if (CALENDAR_ERROR_NONE != ret) {
1821         LoggerW("Can't get categories: "<<ret);
1822     }
1823
1824     if( categories ) {
1825         LoggerD("Loaded categories: "<<categories);
1826
1827         char *saveptr = NULL;
1828         char* pch = strtok_r(categories, ",", &saveptr);
1829         while (NULL != pch) {
1830             m_abstractEvent->getCategories()->push_back(pch);
1831             pch = strtok_r(NULL, ",", &saveptr);
1832         }
1833         free(categories);
1834     }
1835
1836     LoggerD("Number of categories: "<<m_abstractEvent->getCategories()->size());
1837 }
1838
1839 void EventWrapper::setIdFromPlatformEvent()
1840 {
1841         if (m_platformEvent == NULL) {
1842                 ThrowMsg(NullPointerException, "m_platformEvent is not set");
1843         }
1844
1845         int ret, id;
1846         if(CalendarEvent::TASK_TYPE==getType()) {
1847                 ret = calendar_record_get_int(m_platformEvent, _calendar_todo.id, &id);
1848         } else {
1849                 ret = calendar_record_get_int(m_platformEvent, _calendar_event.id, &id);
1850         }
1851         if (CALENDAR_ERROR_NONE!=ret) {
1852                 ThrowMsg(PlatformException, "Can't get id: "<<ret);
1853         }
1854
1855     m_abstractEvent->setId(id);
1856
1857     // Set the uid also.
1858     std::stringstream ss;
1859     ss<<id;
1860     m_abstractEvent->setUId(ss.str());
1861 }
1862
1863 void EventWrapper::setRecurrenceIdFromPlatformEvent()
1864 {
1865     if(CalendarEvent::TASK_TYPE==getType()) {
1866         LoggerD("No need to set the recurrence id for a task.");
1867         return;
1868     }
1869
1870     int ret;
1871     char* recurrenceId = NULL;
1872     ret = calendar_record_get_str(m_platformEvent, _calendar_event.recurrence_id, &recurrenceId);
1873     if (CALENDAR_ERROR_NONE != ret) {
1874         LoggerW("Can't get recurrence id: "<<ret);
1875         return;
1876     }
1877
1878     if( recurrenceId ) {
1879         long long int rid;
1880         std::stringstream ss(recurrenceId);
1881         ss>>rid;
1882         m_abstractEvent->setRecurrenceId(rid);
1883         LoggerD("Set the recurrence id: "<<rid);
1884     } else {
1885         m_abstractEvent->setRecurrenceId(UNDEFINED_TIME);
1886     }
1887 }
1888
1889 void EventWrapper::setParentIdFromPlatformEvent()
1890 {
1891     if(CalendarEvent::TASK_TYPE==getType()) {
1892         LoggerD("No need to set the parent id for a task.");
1893         return;
1894     }
1895
1896     int ret, parentId;
1897     ret = calendar_record_get_int(m_platformEvent, _calendar_event.original_event_id, &parentId);
1898     if (CALENDAR_ERROR_NONE != ret) {
1899         LoggerW("Can't get parent id: "<<ret);
1900         return;
1901     }
1902
1903     if( parentId>0 ) {
1904     m_abstractEvent->setParentId(parentId);
1905     } else {
1906         m_abstractEvent->setParentId(UNDEFINED_ITEM_ID);
1907     }
1908 }
1909
1910 void EventWrapper::setIsAllDayFromPlatformEvent()
1911 {
1912     LoggerD("All day flag is set when getting the start time: "<<m_abstractEvent->getIsAllDay());
1913 }
1914
1915 void EventWrapper::setOrganizerFromPlatformEvent()
1916 {
1917     int ret;
1918     char* organizer = NULL;
1919     if(CalendarEvent::TASK_TYPE==getType()) {
1920         ret = calendar_record_get_str(m_platformEvent, _calendar_todo.organizer_name, &organizer);
1921     } else {
1922         ret = calendar_record_get_str(m_platformEvent, _calendar_event.organizer_name, &organizer);
1923     }
1924     if (CALENDAR_ERROR_NONE != ret) {
1925         LoggerW("Can't get organizer: "<<ret);
1926     }
1927
1928     if (organizer) {
1929         m_abstractEvent->setOrganizer(organizer);
1930         free(organizer);
1931     }
1932 }
1933
1934 void EventWrapper::setLastModifiedDateFromPlatformEvent()
1935 {
1936     int ret;
1937     long long int lastModifiedDate;
1938
1939     if(CalendarEvent::TASK_TYPE==getType()) {
1940         ret = calendar_record_get_lli(m_platformEvent, _calendar_todo.last_modified_time, &lastModifiedDate);
1941     } else {
1942         ret = calendar_record_get_lli(m_platformEvent, _calendar_event.last_modified_time, &lastModifiedDate);
1943     }
1944     if (CALENDAR_ERROR_NONE != ret) {
1945         LoggerW("Can't get last modification time: "<<ret);
1946         return;
1947     }
1948
1949     m_abstractEvent->setLastModifiedDate(lastModifiedDate);
1950 }
1951
1952 void EventWrapper::setVisibilityFromPlatformEvent()
1953 {
1954     int ret, visibility;
1955
1956     if(CalendarEvent::TASK_TYPE==getType()) {
1957         ret = calendar_record_get_int(m_platformEvent, _calendar_todo.sensitivity, &visibility);
1958     } else {
1959         ret = calendar_record_get_int(m_platformEvent, _calendar_event.sensitivity, &visibility);
1960     }
1961     if (CALENDAR_ERROR_NONE != ret) {
1962         LoggerW("Can't get visibility: "<<ret);
1963         return;
1964     }
1965
1966     switch (visibility) {
1967     case CALENDAR_SENSITIVITY_PUBLIC:
1968         m_abstractEvent->setVisibility(CalendarEvent::PUBLIC_VISIBILITY);
1969         break;
1970     case CALENDAR_SENSITIVITY_PRIVATE:
1971         m_abstractEvent->setVisibility(CalendarEvent::PRIVATE_VISIBILITY);
1972         break;
1973     case CALENDAR_SENSITIVITY_CONFIDENTIAL:
1974         m_abstractEvent->setVisibility(CalendarEvent::CONFIDENTIAL_VISIBILITY);
1975         break;
1976     default:
1977         m_abstractEvent->setVisibility(CalendarEvent::PUBLIC_VISIBILITY);
1978         break;
1979     }
1980 }
1981
1982 void EventWrapper::setAvailabilityFromPlatformEvent()
1983 {
1984     if(CalendarEvent::TASK_TYPE==getType()) {
1985         LoggerD("No need to set availability for a task.");
1986         return;
1987     }
1988
1989     int ret, availability;
1990     ret = calendar_record_get_int(m_platformEvent, _calendar_event.busy_status, &availability);
1991     if (CALENDAR_ERROR_NONE != ret) {
1992         LoggerW("Can't get visibility: "<<ret);
1993         return;
1994     }
1995
1996     switch (availability) {
1997     case CALENDAR_EVENT_BUSY_STATUS_BUSY:
1998         m_abstractEvent->setAvailability(CalendarEvent::BUSY_FB);
1999         break;
2000     case CALENDAR_EVENT_BUSY_STATUS_UNAVAILABLE:
2001         m_abstractEvent->setAvailability(CalendarEvent::BUSY_UNAVAILABLE_FB);
2002         break;
2003     case CALENDAR_EVENT_BUSY_STATUS_FREE:
2004         m_abstractEvent->setAvailability(CalendarEvent::FREE_FB);
2005         break;
2006     case CALENDAR_EVENT_BUSY_STATUS_TENTATIVE:
2007         m_abstractEvent->setAvailability(CalendarEvent::BUSY_TENTATIVE_FB);
2008         break;
2009     default:
2010         m_abstractEvent->setAvailability(CalendarEvent::FREE_FB);
2011         break;
2012     }
2013 }
2014
2015 void EventWrapper::setUIdFromPlatformEvent()
2016 {
2017     int ret;
2018     char* uid = NULL;
2019
2020     if(CalendarEvent::TASK_TYPE==getType()) {
2021         ret = calendar_record_get_str(m_platformEvent, _calendar_todo.uid, &uid);
2022     } else {
2023         ret = calendar_record_get_str(m_platformEvent, _calendar_event.uid, &uid);
2024     }
2025     if (CALENDAR_ERROR_NONE != ret) {
2026         LoggerW("Can't get uid: "<<ret);
2027     }
2028
2029     if (uid) {
2030         m_abstractEvent->setUId(uid);
2031         free(uid);
2032     }
2033 }
2034
2035 void EventWrapper::setAttendeesFromPlatformEvent()
2036 {
2037     if ( NULL != m_abstractEvent->getAttendees() ) {
2038         m_abstractEvent->getAttendees()->clear();
2039     }
2040
2041     int ret;
2042     unsigned int count = 0, i;
2043     calendar_record_h attendee = NULL;
2044     calendar_list_h list = NULL;
2045
2046     if(CalendarEvent::TASK_TYPE==getType()) {
2047         ret = calendar_record_get_child_record_count(m_platformEvent, _calendar_todo.calendar_attendee, &count);
2048     } else {
2049         ret = calendar_record_get_child_record_count(m_platformEvent, _calendar_event.calendar_attendee, &count);
2050     }
2051     if (CALENDAR_ERROR_NONE != ret) {
2052         LoggerW("Can't get attendee count: "<<ret);
2053         return;
2054     }
2055
2056     if(0==count) {
2057         LoggerD("No attendees to set.");
2058         return;
2059     }
2060
2061     if(CalendarEvent::TASK_TYPE==getType()) {
2062         ret = calendar_record_clone_child_record_list(m_platformEvent, _calendar_todo.calendar_attendee, &list);
2063     } else {
2064         ret = calendar_record_clone_child_record_list(m_platformEvent, _calendar_event.calendar_attendee, &list);
2065     }
2066     if (CALENDAR_ERROR_NONE != ret) {
2067         LoggerW("Can't get attendee list: "<<ret);
2068         return;
2069     }
2070
2071     for (i=0; i<count; i++)
2072     {
2073         LoggerD("Processing the attendee #"<<i);
2074
2075         if(CalendarEvent::TASK_TYPE==getType()) {
2076             ret = calendar_record_get_child_record_at_p(m_platformEvent, _calendar_todo.calendar_attendee, i, &attendee);
2077         } else {
2078             ret = calendar_record_get_child_record_at_p(m_platformEvent, _calendar_event.calendar_attendee, i, &attendee);
2079         }
2080         if (CALENDAR_ERROR_NONE != ret) {
2081             LoggerW("Can't get attendee record: "<<ret);
2082             continue;
2083         }
2084
2085         EventAttendeePtr attendeePtr(new EventAttendee());
2086
2087         // load name
2088         char* attendeeName = NULL;
2089         ret = calendar_record_get_str(attendee, _calendar_attendee.name, &attendeeName);
2090         if (CALENDAR_ERROR_NONE != ret) {
2091             LoggerW("Cannot read attendee name. Setting an empty string.");
2092             attendeePtr->setName("");
2093         } else {
2094             if(attendeeName) {
2095                 attendeePtr->setName(attendeeName);
2096                 free(attendeeName);
2097             }
2098         }
2099
2100         // load URI
2101         char* attendeeURI = NULL;
2102         ret = calendar_record_get_str(attendee, _calendar_attendee.email, &attendeeURI);
2103         if (CALENDAR_ERROR_NONE != ret) {
2104             LoggerW("Cannot read attendee URI. Setting an empty string.");
2105             attendeePtr->setURI("");
2106         } else {
2107             if(attendeeURI) {
2108                 attendeePtr->setURI(attendeeURI);
2109                 free(attendeeURI);
2110             }
2111         }
2112
2113         // load role
2114         int attendeeRole;
2115         ret = calendar_record_get_int(attendee, _calendar_attendee.role, &attendeeRole);
2116         if (CALENDAR_ERROR_NONE != ret) {
2117             LoggerW("Cannot read attendee role. Setting the default value.");
2118         }
2119         switch (attendeeRole) {
2120         case CALENDAR_ATTENDEE_ROLE_REQ_PARTICIPANT:
2121             attendeePtr->setRole(EventAttendee::REQ_PARTICIPANT_ROLE);
2122             break;
2123         case CALENDAR_ATTENDEE_ROLE_OPT_PARTICIPANT:
2124             attendeePtr->setRole(EventAttendee::OPT_PARTICIPANT_ROLE);
2125             break;
2126         case CALENDAR_ATTENDEE_ROLE_NON_PARTICIPANT:
2127             attendeePtr->setRole(EventAttendee::NON_PARTICIPANT_ROLE);
2128             break;
2129         case CALENDAR_ATTENDEE_ROLE_CHAIR:
2130             attendeePtr->setRole(EventAttendee::CHAIR_ROLE);
2131             break;
2132         default:
2133             attendeePtr->setRole(EventAttendee::REQ_PARTICIPANT_ROLE);
2134             break;
2135         }
2136
2137         // load status
2138         int attendeeStatus;
2139         ret = calendar_record_get_int(attendee, _calendar_attendee.status, &attendeeStatus);
2140         if (CALENDAR_ERROR_NONE != ret) {
2141             LoggerW("Cannot read attendee status. Setting the default value.");
2142         }
2143         switch (attendeeStatus) {
2144         case CALENDAR_ATTENDEE_STATUS_PENDING:
2145             attendeePtr->setStatus(EventAttendee::PENDING_AT_STATUS);
2146             break;
2147         case CALENDAR_ATTENDEE_STATUS_ACCEPTED:
2148             attendeePtr->setStatus(EventAttendee::ACCEPTED_AT_STATUS);
2149             break;
2150         case CALENDAR_ATTENDEE_STATUS_DECLINED:
2151             attendeePtr->setStatus(EventAttendee::DECLINED_AT_STATUS);
2152             break;
2153         case CALENDAR_ATTENDEE_STATUS_TENTATIVE:
2154             attendeePtr->setStatus(EventAttendee::TENTATIVE_AT_STATUS);
2155             break;
2156         case CALENDAR_ATTENDEE_STATUS_DELEGATED:
2157             attendeePtr->setStatus(EventAttendee::DELEGATED_AT_STATUS);
2158             break;
2159         case CALENDAR_ATTENDEE_STATUS_COMPLETED:
2160             attendeePtr->setStatus(EventAttendee::COMPLETED_AT_STATUS);
2161             break;
2162         case CALENDAR_ATTENDEE_STATUS_IN_PROCESS:
2163             attendeePtr->setStatus(EventAttendee::IN_PROCESS_AT_STATUS);
2164             break;
2165         default:
2166             attendeePtr->setStatus(EventAttendee::PENDING_AT_STATUS);
2167             break;
2168         }
2169
2170         // load RSVP
2171         int attendeeRSVP;
2172         ret = calendar_record_get_int(attendee, _calendar_attendee.rsvp, &attendeeRSVP);
2173         if (CALENDAR_ERROR_NONE != ret) {
2174             LoggerW("Cannot read attendee RSVP. Setting the default value.");
2175         }
2176         attendeePtr->setRSVP(attendeeRSVP>0 ? true : false);
2177
2178         // load type
2179         int attendeeType;
2180         ret = calendar_record_get_int(attendee, _calendar_attendee.type, &attendeeType);
2181         if (CALENDAR_ERROR_NONE != ret) {
2182             LoggerW("Cannot read attendee type. Setting the default value.");
2183         }
2184         attendeePtr->setType((EventAttendee::EventAttendeeType)attendeeType);
2185
2186         // load group
2187         char* attendeeGroup = NULL;
2188         ret = calendar_record_get_str(attendee, _calendar_attendee.group, &attendeeGroup);
2189         if (CALENDAR_ERROR_NONE != ret) {
2190             LoggerW("Cannot read attendee group. Setting an empty string.");
2191             attendeePtr->setGroup("");
2192         } else {
2193             if(attendeeGroup) {
2194                 attendeePtr->setGroup(attendeeGroup);
2195                 free(attendeeGroup);
2196             }
2197         }
2198
2199         // load delegatorURI
2200         char* attendeeDelegatorURI = NULL;
2201         ret = calendar_record_get_str(attendee, _calendar_attendee.delegator_uri, &attendeeDelegatorURI);
2202         if (CALENDAR_ERROR_NONE != ret) {
2203             LoggerW("Cannot read attendee delegatorURI. Setting an empty string.");
2204             attendeePtr->setDelegatorURI("");
2205         } else {
2206             if(attendeeDelegatorURI) {
2207                 attendeePtr->setDelegatorURI(attendeeDelegatorURI);
2208                 free(attendeeDelegatorURI);
2209             }
2210         }
2211
2212         // load delegateURI
2213         char* attendeeDelegateURI = NULL;
2214         ret = calendar_record_get_str(attendee, _calendar_attendee.delegate_uri, &attendeeDelegateURI);
2215         if (CALENDAR_ERROR_NONE != ret) {
2216             LoggerW("Cannot read attendee delegateURI. Setting an empty string.");
2217             attendeePtr->setDelegateURI("");
2218         } else {
2219             if(attendeeDelegateURI) {
2220                 attendeePtr->setDelegateURI(attendeeDelegateURI);
2221                 free(attendeeDelegateURI);
2222             }
2223         }
2224
2225         // load contactId
2226         char* attendeeContactId = NULL;
2227         ret = calendar_record_get_str(attendee, _calendar_attendee.uid, &attendeeContactId);
2228         if (CALENDAR_ERROR_NONE != ret) {
2229             LoggerW("Cannot read attendee UId. Setting an empty string.");
2230             attendeePtr->setContactId("");
2231         } else {
2232             if(attendeeContactId) {
2233                 attendeePtr->setContactId(attendeeContactId);
2234                 free(attendeeContactId);
2235             }
2236         }
2237
2238         // load addressBookId
2239         int attendeeAddressBookId;
2240         ret = calendar_record_get_int(attendee, _calendar_attendee.person_id, &attendeeAddressBookId);
2241         LoggerD("attendeeAddressBookId: "<<attendeeAddressBookId);
2242         if (CALENDAR_ERROR_NONE != ret) {
2243             LoggerW("Cannot read attendee address book id. Setting an empty string.");
2244             attendeeAddressBookId = -1;
2245         }
2246         std::stringstream ss;
2247         if (attendeeAddressBookId>=0) {
2248             ss<<attendeeAddressBookId;
2249         } else {
2250             ss<<"";
2251         }
2252         attendeePtr->setAddressBookId(ss.str());
2253
2254         m_abstractEvent->getAttendees()->push_back(attendeePtr);
2255     }
2256
2257     if(list) {
2258         calendar_list_destroy(list, true);
2259     }
2260 }
2261
2262 void EventWrapper::setPositionFromPlatformEvent()
2263 {
2264     int ret;
2265     double value;
2266
2267     if(CalendarEvent::TASK_TYPE==getType()) {
2268         ret = calendar_record_get_double(m_platformEvent, _calendar_todo.latitude, &value);
2269     } else {
2270         ret = calendar_record_get_double(m_platformEvent, _calendar_event.latitude, &value);
2271     }
2272     if (CALENDAR_ERROR_NONE != ret) {
2273         LoggerW("Can't get item latitude.");
2274         return;
2275     }
2276     m_abstractEvent->getGeolocation()->setLatitude(value);
2277
2278     if(CalendarEvent::TASK_TYPE==getType()) {
2279         ret = calendar_record_get_double(m_platformEvent, _calendar_todo.longitude, &value);
2280     } else {
2281         ret = calendar_record_get_double(m_platformEvent, _calendar_event.longitude, &value);
2282     }
2283     if (CALENDAR_ERROR_NONE != ret) {
2284         LoggerW("Can't get item longitude.");
2285         return;
2286     }
2287     m_abstractEvent->getGeolocation()->setLongitude(value);
2288 }
2289
2290 void EventWrapper::setPriorityFromPlatformEvent()
2291 {
2292     int ret;
2293     int priority;
2294
2295     if(CalendarEvent::TASK_TYPE==getType()) {
2296         ret = calendar_record_get_int(m_platformEvent, _calendar_todo.priority, &priority);
2297         if (CALENDAR_ERROR_NONE != ret) {
2298             LoggerW("Can't get task priority: "<<ret);
2299             return;
2300         }
2301
2302         switch (priority) {
2303         case CALENDAR_TODO_PRIORITY_LOW:
2304             m_abstractEvent->setPriority(CalendarEvent::LOW_PRIORITY);
2305             break;
2306         case CALENDAR_TODO_PRIORITY_NORMAL:
2307             m_abstractEvent->setPriority(CalendarEvent::MEDIUM_PRIORITY);
2308             break;
2309         case CALENDAR_TODO_PRIORITY_HIGH:
2310             m_abstractEvent->setPriority(CalendarEvent::HIGH_PRIORITY);
2311             break;
2312         default:
2313             m_abstractEvent->setPriority(CalendarEvent::MEDIUM_PRIORITY);
2314             break;
2315         }
2316     } else {
2317         ret = calendar_record_get_int(m_platformEvent, _calendar_event.priority, &priority);
2318         if (CALENDAR_ERROR_NONE != ret) {
2319             LoggerW("Can't get event priority: "<<ret);
2320             return;
2321         }
2322
2323         switch (priority) {
2324         case CALENDAR_EVENT_PRIORITY_LOW:
2325             m_abstractEvent->setPriority(CalendarEvent::LOW_PRIORITY);
2326             break;
2327         case CALENDAR_EVENT_PRIORITY_NORMAL:
2328             m_abstractEvent->setPriority(CalendarEvent::MEDIUM_PRIORITY);
2329             break;
2330         case CALENDAR_EVENT_PRIORITY_HIGH:
2331             m_abstractEvent->setPriority(CalendarEvent::HIGH_PRIORITY);
2332             break;
2333         default:
2334             m_abstractEvent->setPriority(CalendarEvent::MEDIUM_PRIORITY);
2335             break;
2336         }
2337     }
2338 }
2339
2340 void EventWrapper::setCreatedDateFromPlatformEvent()
2341 {
2342     int ret;
2343     long long int createdDate;
2344
2345     if(CalendarEvent::TASK_TYPE==getType()) {
2346         ret = calendar_record_get_lli(m_platformEvent, _calendar_todo.created_time, &createdDate);
2347     } else {
2348         ret = calendar_record_get_lli(m_platformEvent, _calendar_event.created_time, &createdDate);
2349     }
2350     if (CALENDAR_ERROR_NONE != ret) {
2351         LoggerW("Can't get created date: "<<ret);
2352         return;
2353     }
2354
2355     m_abstractEvent->setCreatedDate(createdDate);
2356 }
2357
2358 void EventWrapper::setCompletedDateFromPlatformEvent()
2359 {
2360     if(CalendarEvent::EVENT_TYPE==getType()) {
2361         LoggerD("No need to set completedDate for an event.");
2362         return;
2363     }
2364
2365     int ret;
2366     long long int completedDate;
2367
2368     ret = calendar_record_get_lli(m_platformEvent, _calendar_todo.completed_time, &completedDate);
2369     if (CALENDAR_ERROR_NONE != ret) {
2370         LoggerW("Can't get completed date: "<<ret);
2371         return;
2372     }
2373
2374     m_abstractEvent->setCompletedDate(completedDate);
2375 }
2376
2377 void EventWrapper::setProgressFromPlatformEvent()
2378 {
2379     if(CalendarEvent::EVENT_TYPE==getType()) {
2380         LoggerD("No need to set progress for an event.");
2381         return;
2382     }
2383
2384     int ret;
2385     int progress = 0;
2386     ret = calendar_record_get_int(m_platformEvent, _calendar_todo.progress, &progress);
2387     if (CALENDAR_ERROR_NONE != ret) {
2388         LoggerW("Can't get progress: "<<ret);
2389         return;
2390     }
2391
2392     m_abstractEvent->setProgress(progress);
2393 }
2394
2395 void EventWrapper::setIsDetachedFromPlatformEvent()
2396 {
2397     if(CalendarEvent::TASK_TYPE==getType()) {
2398         LoggerD("No need to set isDetached flag for a task.");
2399         return;
2400     }
2401
2402     int ret;
2403     int isDetached;
2404     ret = calendar_record_get_int(m_platformEvent, _calendar_event.original_event_id, &isDetached);
2405     if (CALENDAR_ERROR_NONE != ret) {
2406         LoggerW("Can't get isDetached: "<<ret);
2407         return;
2408     }
2409
2410     if (isDetached>0) {
2411         m_abstractEvent->setIsDetached(true);
2412         LoggerD("This is a detached event.");
2413     } else {
2414         m_abstractEvent->setIsDetached(false);
2415     }
2416 }
2417
2418 void EventWrapper::displayAbstractEvent()
2419 {
2420     m_abstractEvent->display();
2421 }
2422
2423 void EventWrapper::displayPlatformEvent()
2424 {
2425      LoggerD("Displaying platform itemt disabled.");
2426 }
2427
2428 CalendarEvent::CalendarType EventWrapper::getType()
2429 {
2430     return m_calendarType;
2431 }
2432
2433 }
2434 }