src/Calendar/CalendarConverter.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
  19 #include <dpl/log/log.h>
  20 #include <CommonsJavaScript/Validator.h>
  21 #include <CommonsJavaScript/JSUtils.h>
  22 #include "JSCalendarEvent.h"
  23 #include "JSCalendarTask.h"
  24 #include "JSCalendarItemProperties.h"
  25 #include "JSCalendarEventId.h"
  26 #include "CalendarConverter.h"
  27 #include "JSCalendar.h"
  28 #include "JSCalendarManager.h"
  29 #include "JSCalendarAttendee.h"
  30 #include "JSCalendarRecurrenceRule.h"
  31 #include "JSCalendarAlarm.h"
  32
  33 #include <TimeUtilConverter.h>
  34 #include <DurationProperties.h>
  35 #include <JSSimpleCoordinates.h>
  36 #include <ContactConverter.h>
  37
  38
  39 using namespace WrtDeviceApis::Commons;
  40 using namespace WrtDeviceApis::CommonsJavaScript;
  41 using namespace DeviceAPI::Time;
  42
  43 namespace {
  44 const int DEFAULT_EVENT_INTERVAL = 1;
  45 }
  46
  47 namespace DeviceAPI {
  48 namespace Calendar {
  49
  50 CalendarConverter::CalendarConverter(JSContextRef context, CalendarEvent::CalendarType calendarType) : Converter(context)
  51 {
  52     m_calendarType = calendarType;
  53 }
  54
  55 CalendarConverter::~CalendarConverter()
  56 {
  57 }
  58
  59 JSValueRef CalendarConverter::toJSValueRefEvent(const CalendarEventPtr& arg)
  60 {
  61     return JSUtils::makeObject(m_context, JSCalendarEvent::getClassRef(), arg);
  62 }
  63
  64 JSValueRef CalendarConverter::toJSValueRefTask(const CalendarEventPtr& arg)
  65 {
  66     return JSUtils::makeObject(m_context, JSCalendarTask::getClassRef(), arg);
  67 }
  68
  69 JSValueRef CalendarConverter::toJSValueRefEventArray(const CalendarEventListPtr &arg)
  70 {
  71     return toJSValueRef_(*arg, &CalendarConverter::toJSValueRefEvent, this);
  72 }
  73
  74 JSValueRef CalendarConverter::toJSValueRefTaskArray(const CalendarEventListPtr &arg)
  75 {
  76     return toJSValueRef_(*arg, &CalendarConverter::toJSValueRefTask, this);
  77 }
  78
  79 JSValueRef CalendarConverter::toJSValueRefCalendar(const ICalendarPtr& arg)
  80 {
  81     CalendarPrivObject *priv = new CalendarPrivObject(m_context, arg);
  82     return JSObjectMake(m_context, JSCalendar::getClassRef(), priv);
  83 }
  84
  85 JSValueRef CalendarConverter::toJSValueRef(const std::vector<ICalendarPtr> &arg)
  86 {
  87     return toJSValueRef_(arg, &CalendarConverter::toJSValueRefCalendar, this);
  88 }
  89
  90 JSValueRef CalendarConverter::toJSValueRefStringArray(const StringArrayPtr &arg)
  91 {
  92         int size = arg->size();
  93
  94         JSObjectRef resultObject = JSCreateArrayObject(m_context, 0, NULL);
  95         if (!resultObject) {
  96                 ThrowMsg(ConversionException, "Can not create an array object.");
  97         }
  98
  99         for(int i = 0; i < size; i++) {
 100                 JSValueRef jsvalue = toJSValueRef(arg->at(i));
 101                 if (!JSSetArrayElement(m_context, resultObject, i, jsvalue)) {
 102                         ThrowMsg(ConversionException, "Can not add an object to array.");
 103                 }
 104         }
 105
 106         return resultObject;
 107 }
 108
 109 JSValueRef CalendarConverter::toJSValueRefNumberArray(const NumberArrayPtr &arg)
 110 {
 111         int size = arg->size();
 112
 113         JSObjectRef resultObject = JSCreateArrayObject(m_context, 0, NULL);
 114         if (!resultObject) {
 115                 ThrowMsg(ConversionException, "Can not create an array object.");
 116         }
 117
 118         for(int i = 0; i < size; i++) {
 119                 JSValueRef jsvalue = toJSValueRef(arg->at(i));
 120                 if (!JSSetArrayElement(m_context, resultObject, i, jsvalue)) {
 121                         ThrowMsg(ConversionException, "Can not add an object to array.");
 122                 }
 123         }
 124
 125         return resultObject;
 126 }
 127
 128 JSValueRef CalendarConverter::toJSValueRefTZDateArray(const NumberArrayPtr &arg, const std::string &timeZone)
 129 {
 130         int size = arg->size();
 131
 132         JSObjectRef resultObject = JSCreateArrayObject(m_context, 0, NULL);
 133         if (!resultObject) {
 134                 ThrowMsg(ConversionException, "Can not create an array object.");
 135         }
 136
 137     TimeUtilConverter timeConverter(m_context);
 138         for(int i = 0; i < size; i++) {
 139                 JSValueRef jsvalue = timeConverter.toJSValueRefTZDate((double)((arg->at(i))*1000.0), timeZone);
 140                 if (!JSSetArrayElement(m_context, resultObject, i, jsvalue)) {
 141                         ThrowMsg(ConversionException, "Can not add an object to array.");
 142                 }
 143         }
 144
 145         return resultObject;
 146 }
 147
 148 StringArrayPtr CalendarConverter::toStringArray(const JSValueRef &jsValue)
 149 {
 150         StringArrayPtr result = StringArrayPtr(new StringArray());
 151         if(!JSIsArrayValue(m_context, jsValue)) {
 152                 LogWarning("StringArray is not an array. Skip this.");
 153                 return result;
 154         }
 155
 156         JSObjectRef jsObject = toJSObjectRef(jsValue);
 157     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
 158         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
 159         result->push_back(toString(element));
 160     }
 161     return result;
 162 }
 163
 164 NumberArrayPtr CalendarConverter::toNumberArray(const JSValueRef &jsValue)
 165 {
 166         NumberArrayPtr result = NumberArrayPtr(new NumberArray());
 167         if(!JSIsArrayValue(m_context, jsValue)) {
 168                 LogWarning("NumberArray is not an array. Skip this.");
 169                 return result;
 170         }
 171
 172         JSObjectRef jsObject = toJSObjectRef(jsValue);
 173     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
 174         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
 175         result->push_back((long long int) (toLongLong(element)));
 176     }
 177     return result;
 178 }
 179
 180 NumberArrayPtr CalendarConverter::toTZDateArray(const JSValueRef &jsValue)
 181 {
 182         NumberArrayPtr result = NumberArrayPtr(new NumberArray());
 183         if(!JSIsArrayValue(m_context, jsValue)) {
 184                 LogWarning("TZDateArray is not an array. Skip this.");
 185                 return result;
 186         }
 187
 188     TimeUtilConverter timeConverter(m_context);
 189
 190         JSObjectRef jsObject = toJSObjectRef(jsValue);
 191     for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
 192         JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
 193         result->push_back((long long int) (timeConverter.getTimeInMilliseconds(element)/1000));
 194     }
 195     LogDebug("First value: "<<result->at(0));
 196     return result;
 197 }
 198
 199 EventAlarm::EventAlarmType CalendarConverter::toEventAlarmType(std::string alarmMethod)
 200 const
 201 {
 202     if (!alarmMethod.compare(TIZEN_CALENDAR_PROPERTY_DISPLAY_ALARM))
 203         return EventAlarm::SILENT_ALARM;
 204     else if (!alarmMethod.compare(TIZEN_CALENDAR_PROPERTY_SOUND_ALARM))
 205         return EventAlarm::SOUND_ALARM;
 206     else
 207         ThrowMsg(ConversionException, "Invalid alarm type.");
 208
 209     return EventAlarm::UNDEFINED_ALARM_TYPE;
 210 }
 211
 212 std::string CalendarConverter::toTizenValue(EventAlarm::EventAlarmType abstractValue) const
 213 {
 214     switch (abstractValue) {
 215     case EventAlarm::SILENT_ALARM:
 216         return TIZEN_CALENDAR_PROPERTY_DISPLAY_ALARM;
 217     case EventAlarm::SOUND_ALARM:
 218         return TIZEN_CALENDAR_PROPERTY_SOUND_ALARM;
 219     default:
 220         break;
 221     }
 222     ThrowMsg(ConversionException, "Invalid alarm type");
 223 }
 224
 225 CalendarEvent::EventStatus CalendarConverter::toEventStatus(std::string tizenValue) const
 226 {
 227     if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_TENTATIVE_STATUS))
 228         return CalendarEvent::TENTATIVE_STATUS;
 229     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CONFIRMED_STATUS))
 230         return CalendarEvent::CONFIRMED_STATUS;
 231     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CANCELLED_STATUS))
 232         return CalendarEvent::CANCELLED_STATUS;
 233     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_NEEDS_ACTION_STATUS))
 234         return CalendarEvent::NEEDS_ACTION_STATUS;
 235     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_IN_PROCESS_STATUS))
 236         return CalendarEvent::IN_PROCESS_STATUS;
 237     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS))
 238         return CalendarEvent::COMPLETED_STATUS;
 239     else
 240         ThrowMsg(ConversionException, "Invalid status type.");
 241
 242     return CalendarEvent::UNDEFINED_STATUS;
 243 }
 244
 245 std::string CalendarConverter::toTizenValue(CalendarEvent::EventStatus abstractValue)
 246 const
 247 {
 248     switch (abstractValue) {
 249     case CalendarEvent::TENTATIVE_STATUS:
 250         return TIZEN_CALENDAR_PROPERTY_TENTATIVE_STATUS;
 251     case CalendarEvent::CONFIRMED_STATUS:
 252         return TIZEN_CALENDAR_PROPERTY_CONFIRMED_STATUS;
 253     case CalendarEvent::CANCELLED_STATUS:
 254         return TIZEN_CALENDAR_PROPERTY_CANCELLED_STATUS;
 255     case CalendarEvent::NEEDS_ACTION_STATUS:
 256         return TIZEN_CALENDAR_PROPERTY_NEEDS_ACTION_STATUS;
 257     case CalendarEvent::IN_PROCESS_STATUS:
 258         return TIZEN_CALENDAR_PROPERTY_IN_PROCESS_STATUS;
 259     case CalendarEvent::COMPLETED_STATUS:
 260         return TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS;
 261     default:
 262         {
 263             if (CalendarEvent::TASK_TYPE==m_calendarType) {
 264                 return TIZEN_CALENDAR_PROPERTY_NEEDS_ACTION_STATUS;
 265             } else {
 266                 return TIZEN_CALENDAR_PROPERTY_CONFIRMED_STATUS;
 267             }
 268             break;
 269         }
 270     }
 271 }
 272
 273 EventRecurrenceRule::EventRecurrence CalendarConverter::toRecurrenceFrequency(
 274         std::string tizenValue) const
 275 {
 276     if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_DAILY_RECURRENCE))
 277         return EventRecurrenceRule::DAILY_RECURRENCE;
 278     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_WEEKLY_RECURRENCE))
 279         return EventRecurrenceRule::WEEKLY_RECURRENCE;
 280     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_MONTHLY_RECURRENCE))
 281         return EventRecurrenceRule::MONTHLY_RECURRENCE;
 282     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_YEARLY_RECURRENCE))
 283         return EventRecurrenceRule::YEARLY_RECURRENCE;
 284     else
 285         ThrowMsg(ConversionException, "Invalid recurrence frequency type.");
 286
 287     return EventRecurrenceRule::UNDEFINED_RECURRENCE;
 288 }
 289
 290 std::string CalendarConverter::toTizenValue(
 291         EventRecurrenceRule::EventRecurrence abstractValue) const
 292 {
 293     switch (abstractValue) {
 294     case EventRecurrenceRule::DAILY_RECURRENCE:
 295         return TIZEN_CALENDAR_PROPERTY_DAILY_RECURRENCE;
 296     case EventRecurrenceRule::WEEKLY_RECURRENCE:
 297         return TIZEN_CALENDAR_PROPERTY_WEEKLY_RECURRENCE;
 298     case EventRecurrenceRule::MONTHLY_RECURRENCE:
 299         return TIZEN_CALENDAR_PROPERTY_MONTHLY_RECURRENCE;
 300     case EventRecurrenceRule::YEARLY_RECURRENCE:
 301         return TIZEN_CALENDAR_PROPERTY_YEARLY_RECURRENCE;
 302     case EventRecurrenceRule::NO_RECURRENCE:
 303     default:
 304         return "";
 305         break;
 306     }
 307 }
 308
 309 EventRecurrenceRulePtr CalendarConverter::toEventRecurrenceRule(JSValueRef rrule)
 310 {
 311     EventRecurrenceRulePtr result(new EventRecurrenceRule());
 312
 313     const ScopedJSStringRef frequencyStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_FREQUENCY));
 314     const ScopedJSStringRef intervalStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_INTERVAL));
 315     const ScopedJSStringRef untilDateStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_UNTIL_DATE));
 316     const ScopedJSStringRef occurrenceCountStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_OCCURRENCE_COUNT));
 317     //const ScopedJSStringRef daysOfTheMonthStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_MONTH));
 318     const ScopedJSStringRef daysOfTheWeekStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_WEEK));
 319     //const ScopedJSStringRef daysOfTheYearStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_YEAR));
 320     //const ScopedJSStringRef weeksOfTheYearStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_WEEKS_OF_THE_YEAR));
 321     const ScopedJSStringRef setPositionsStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_SET_POSITIONS));
 322     const ScopedJSStringRef exceptionsStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_EXCEPTIONS));
 323
 324     JSObjectRef arg = toJSObjectRef(rrule);
 325
 326     JSValueRef frequencyData = JSObjectGetProperty(m_context, arg, frequencyStr.get(), NULL);
 327     JSValueRef intervalData = JSObjectGetProperty(m_context, arg, intervalStr.get(), NULL);
 328     JSValueRef untilDateData = JSObjectGetProperty(m_context, arg, untilDateStr.get(), NULL);
 329     JSValueRef occurrenceCountData = JSObjectGetProperty(m_context, arg, occurrenceCountStr.get(), NULL);
 330     //JSValueRef daysOfTheMonthData = JSObjectGetProperty(m_context, arg, daysOfTheMonthStr.get(), NULL);
 331     JSValueRef daysOfTheWeekData = JSObjectGetProperty(m_context, arg, daysOfTheWeekStr.get(), NULL);
 332     //JSValueRef daysOfTheYearData = JSObjectGetProperty(m_context, arg, daysOfTheYearStr.get(), NULL);
 333     //JSValueRef weeksOfTheYearData = JSObjectGetProperty(m_context, arg, weeksOfTheYearStr.get(), NULL);
 334     JSValueRef setPositionsData = JSObjectGetProperty(m_context, arg, setPositionsStr.get(), NULL);
 335     JSValueRef exceptionsData = JSObjectGetProperty(m_context, arg, exceptionsStr.get(), NULL);
 336
 337     if (!JSValueIsUndefined(m_context, frequencyData)) {
 338         result->setFrequency(toRecurrenceFrequency(toString(frequencyData)));
 339     }
 340     if (!JSValueIsUndefined(m_context, intervalData)) {
 341         result->setInterval(toInt(intervalData));
 342     }
 343     if (!JSValueIsUndefined(m_context, untilDateData)) {
 344         if (!JSValueIsNull(m_context, untilDateData)) {
 345             TimeUtilConverter timeUtilConverter(m_context);
 346             result->setEndDate((long long int) (timeUtilConverter.getTimeInMilliseconds(untilDateData)/1000));
 347             result->setTimeZone(timeUtilConverter.getPropertiesInTZDate(untilDateData).timezone);
 348         } else {
 349             result->setEndDate(0);
 350         }
 351     }
 352     if (!JSValueIsUndefined(m_context, occurrenceCountData)) {
 353         result->setOccurrenceCount(toLong(occurrenceCountData));
 354     }
 355     /*if (!JSValueIsUndefined(m_context, daysOfTheMonthData)) {
 356         result->setDaysOfTheMonth(toVectorOfInts(daysOfTheMonthData));
 357     }*/
 358     if (!JSValueIsUndefined(m_context, daysOfTheWeekData)) {
 359         result->setDaysOfTheWeek(toStringArray(daysOfTheWeekData));
 360     }
 361     /*if (!JSValueIsUndefined(m_context, daysOfTheYearData)) {
 362         result->setDaysOfTheYear(toVectorOfInts(daysOfTheYearData));
 363     }
 364     if (!JSValueIsUndefined(m_context, weeksOfTheYearData)) {
 365         result->setWeeksOfTheYear(toVectorOfInts(weeksOfTheYearData));
 366     }*/
 367     if (!JSValueIsUndefined(m_context, setPositionsData)) {
 368         result->setSetPositions(toNumberArray(setPositionsData));
 369     }
 370     if (!JSValueIsUndefined(m_context, exceptionsData)) {
 371         result->setExceptions(toTZDateArray(exceptionsData));
 372     }
 373
 374     return result;
 375 }
 376
 377 CalendarEvent::EventVisibility CalendarConverter::toEventVisibility(std::string tizenValue)
 378 const
 379 {
 380     if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_PUBLIC_VISIBILITY))
 381         return CalendarEvent::PUBLIC_VISIBILITY;
 382     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_PRIVATE_VISIBILITY))
 383         return CalendarEvent::PRIVATE_VISIBILITY;
 384     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CONFIDENTIAL_VISIBILITY))
 385         return CalendarEvent::CONFIDENTIAL_VISIBILITY;
 386     else
 387         ThrowMsg(ConversionException, "Invalid visibility type.");
 388
 389     return CalendarEvent::UNDEFINED_VISIBILITY;
 390 }
 391
 392 std::string CalendarConverter::toTizenValue(
 393         CalendarEvent::EventVisibility abstractValue) const
 394 {
 395     switch (abstractValue) {
 396     case CalendarEvent::PUBLIC_VISIBILITY:
 397         return TIZEN_CALENDAR_PROPERTY_PUBLIC_VISIBILITY;
 398     case CalendarEvent::PRIVATE_VISIBILITY:
 399         return TIZEN_CALENDAR_PROPERTY_PRIVATE_VISIBILITY;
 400     case CalendarEvent::CONFIDENTIAL_VISIBILITY:
 401         return TIZEN_CALENDAR_PROPERTY_CONFIDENTIAL_VISIBILITY;
 402     default:
 403         break;
 404     }
 405
 406     return TIZEN_CALENDAR_PROPERTY_PUBLIC_VISIBILITY;
 407 }
 408
 409 CalendarEvent::EventAvailability CalendarConverter::toEventAvailability(std::string tizenValue)
 410 const
 411 {
 412     if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_BUSY))
 413         return CalendarEvent::BUSY_FB;
 414     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_BUSY_UNAVAILABLE_FB))
 415         return CalendarEvent::BUSY_UNAVAILABLE_FB;
 416     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_FREE))
 417         return CalendarEvent::FREE_FB;
 418     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_BUSY_TENTATIVE))
 419         return CalendarEvent::BUSY_TENTATIVE_FB;
 420     else
 421         ThrowMsg(ConversionException, "Invalid availability type.");
 422
 423     return CalendarEvent::UNDEFINED_AVAILABILITY;
 424 }
 425
 426 std::string CalendarConverter::toTizenValue(
 427         CalendarEvent::EventAvailability abstractValue) const
 428 {
 429     switch (abstractValue) {
 430     case CalendarEvent::BUSY_FB:
 431         return TIZEN_CALENDAR_PROPERTY_BUSY;
 432     case CalendarEvent::BUSY_UNAVAILABLE_FB:
 433         return TIZEN_CALENDAR_PROPERTY_BUSY_UNAVAILABLE_FB;
 434     case CalendarEvent::FREE_FB:
 435         return TIZEN_CALENDAR_PROPERTY_FREE;
 436     case CalendarEvent::BUSY_TENTATIVE_FB:
 437         return TIZEN_CALENDAR_PROPERTY_BUSY_TENTATIVE;
 438     default:
 439         break;
 440     }
 441
 442     return TIZEN_CALENDAR_PROPERTY_BUSY;
 443 }
 444
 445 EventAttendee::EventAttendeeRole CalendarConverter::toEventAttendeeRole(std::string tizenValue)
 446 const
 447 {
 448     if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_REQ_PARTICIPANT_ROLE))
 449         return EventAttendee::REQ_PARTICIPANT_ROLE;
 450     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_OPT_PARTICIPANT_ROLE))
 451         return EventAttendee::OPT_PARTICIPANT_ROLE;
 452     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_NON_PARTICIPANT_ROLE))
 453         return EventAttendee::NON_PARTICIPANT_ROLE;
 454     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CHAIR_ROLE))
 455         return EventAttendee::CHAIR_ROLE;
 456     else
 457         ThrowMsg(ConversionException, "Invalid attendee role type.");
 458
 459     return EventAttendee::UNDEFINED_ATTENDEE_ROLE;
 460 }
 461
 462 std::string CalendarConverter::toTizenValue(
 463         EventAttendee::EventAttendeeRole abstractValue) const
 464 {
 465     switch (abstractValue) {
 466     case EventAttendee::REQ_PARTICIPANT_ROLE:
 467         return TIZEN_CALENDAR_PROPERTY_REQ_PARTICIPANT_ROLE;
 468     case EventAttendee::OPT_PARTICIPANT_ROLE:
 469         return TIZEN_CALENDAR_PROPERTY_OPT_PARTICIPANT_ROLE;
 470     case EventAttendee::NON_PARTICIPANT_ROLE:
 471         return TIZEN_CALENDAR_PROPERTY_NON_PARTICIPANT_ROLE;
 472     case EventAttendee::CHAIR_ROLE:
 473         return TIZEN_CALENDAR_PROPERTY_CHAIR_ROLE;
 474     default:
 475         break;
 476     }
 477     return TIZEN_CALENDAR_PROPERTY_REQ_PARTICIPANT_ROLE;
 478 }
 479
 480 EventAttendee::EventAttendeeStatus CalendarConverter::toEventAttendeeStatus(std::string tizenValue)
 481 const
 482 {
 483     if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_PENDING_STATUS))
 484         return EventAttendee::PENDING_AT_STATUS;
 485     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_ACCEPTED_STATUS))
 486         return EventAttendee::ACCEPTED_AT_STATUS;
 487     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_DECLINED_STATUS))
 488         return EventAttendee::DECLINED_AT_STATUS;
 489     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_TENTATIVE_STATUS))
 490         return EventAttendee::TENTATIVE_AT_STATUS;
 491     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_DELEGATED_STATUS))
 492         return EventAttendee::DELEGATED_AT_STATUS;
 493     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS))
 494         return EventAttendee::COMPLETED_AT_STATUS;
 495     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_IN_PROCESS_STATUS))
 496         return EventAttendee::IN_PROCESS_AT_STATUS;
 497     else
 498         ThrowMsg(ConversionException, "Invalid attendee status type.");
 499
 500     return EventAttendee::UNDEFINED_ATTENDEE_STATUS;
 501 }
 502
 503 std::string CalendarConverter::toTizenValue(
 504         EventAttendee::EventAttendeeStatus abstractValue) const
 505 {
 506     switch (abstractValue) {
 507     case EventAttendee::PENDING_AT_STATUS:
 508         return TIZEN_CALENDAR_PROPERTY_PENDING_STATUS;
 509     case EventAttendee::ACCEPTED_AT_STATUS:
 510         return TIZEN_CALENDAR_PROPERTY_ACCEPTED_STATUS;
 511     case EventAttendee::DECLINED_AT_STATUS:
 512         return TIZEN_CALENDAR_PROPERTY_DECLINED_STATUS;
 513     case EventAttendee::TENTATIVE_AT_STATUS:
 514         return TIZEN_CALENDAR_PROPERTY_TENTATIVE_STATUS;
 515     case EventAttendee::DELEGATED_AT_STATUS:
 516         return TIZEN_CALENDAR_PROPERTY_DELEGATED_STATUS;
 517     case EventAttendee::COMPLETED_AT_STATUS:
 518         return TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS;
 519     case EventAttendee::IN_PROCESS_AT_STATUS:
 520         return TIZEN_CALENDAR_PROPERTY_IN_PROCESS_STATUS;
 521     default:
 522         break;
 523     }
 524     return TIZEN_CALENDAR_PROPERTY_PENDING_STATUS;
 525 }
 526
 527 EventAttendee::EventAttendeeType CalendarConverter::toEventAttendeeType(std::string tizenValue)
 528 const
 529 {
 530     if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_INDIVIDUAL_TYPE))
 531         return EventAttendee::INDIVIDUAL_TYPE;
 532     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_GROUP_TYPE))
 533         return EventAttendee::GROUP_TYPE;
 534     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_RESOURCE_TYPE))
 535         return EventAttendee::RESOURCE_TYPE;
 536     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_ROOM_TYPE))
 537         return EventAttendee::ROOM_TYPE;
 538     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_UNKNOWN_TYPE))
 539         return EventAttendee::UNKNOWN_TYPE;
 540     else
 541         ThrowMsg(ConversionException, "Invalid attendee type.");
 542
 543     return EventAttendee::INDIVIDUAL_TYPE;
 544 }
 545
 546 std::string CalendarConverter::toTizenValue(
 547         EventAttendee::EventAttendeeType abstractValue) const
 548 {
 549     switch (abstractValue) {
 550     case EventAttendee::INDIVIDUAL_TYPE:
 551         return TIZEN_CALENDAR_PROPERTY_INDIVIDUAL_TYPE;
 552     case EventAttendee::GROUP_TYPE:
 553         return TIZEN_CALENDAR_PROPERTY_GROUP_TYPE;
 554     case EventAttendee::RESOURCE_TYPE:
 555         return TIZEN_CALENDAR_PROPERTY_RESOURCE_TYPE;
 556     case EventAttendee::ROOM_TYPE:
 557         return TIZEN_CALENDAR_PROPERTY_ROOM_TYPE;
 558     case EventAttendee::UNKNOWN_TYPE:
 559         return TIZEN_CALENDAR_PROPERTY_UNKNOWN_TYPE;
 560     default:
 561         break;
 562     }
 563
 564     return TIZEN_CALENDAR_PROPERTY_INDIVIDUAL_TYPE;
 565 }
 566
 567 JSValueRef CalendarConverter::toFunctionOrNull(const JSValueRef& arg)
 568 {
 569     if (Validator(m_context).isCallback(arg)) {
 570         return arg;
 571     } else if (!JSValueIsNull(m_context,
 572                               arg) && !JSValueIsUndefined(m_context, arg)) {
 573         ThrowMsg(ConversionException, "Not a function nor JS null.");
 574     }
 575     return NULL;
 576 }
 577
 578 JSValueRef CalendarConverter::toFunction(const JSValueRef& arg)
 579 {
 580     if (Validator(m_context).isCallback(arg)) {
 581         return arg;
 582     }
 583     ThrowMsg(ConversionException, "Not a function.");
 584 }
 585
 586 StringArrayPtr CalendarConverter::toCategories(JSValueRef categories)
 587 {
 588     StringArrayPtr result(new StringArray());
 589     *result = toVectorOfStrings(categories);
 590     return result;
 591 }
 592
 593 EventAttendeePtr CalendarConverter::toAttendee(JSValueRef attendee)
 594 {
 595     EventAttendeePtr result(new EventAttendee());
 596     const ScopedJSStringRef nameStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_NAME));
 597     const ScopedJSStringRef uriStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_URI));
 598     const ScopedJSStringRef roleStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_ROLE));
 599     const ScopedJSStringRef statusStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_STATUS));
 600     const ScopedJSStringRef RSVPStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_RSVP));
 601     const ScopedJSStringRef typeStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_TYPE));
 602     const ScopedJSStringRef groupStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_GROUP));
 603     const ScopedJSStringRef delegatorURIStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_DELEGATORURI));
 604     const ScopedJSStringRef delegateURIStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_DELEGATEURI));
 605     const ScopedJSStringRef contactRefStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_CONTACT_REF));
 606
 607     JSObjectRef arg = toJSObjectRef(attendee);
 608
 609     JSValueRef nameData = JSObjectGetProperty(m_context, arg, nameStr.get(), NULL);
 610     JSValueRef uriData = JSObjectGetProperty(m_context, arg, uriStr.get(), NULL);
 611     JSValueRef roleData = JSObjectGetProperty(m_context, arg, roleStr.get(), NULL);
 612     JSValueRef statusData = JSObjectGetProperty(m_context, arg, statusStr.get(), NULL);
 613     JSValueRef RSVPData = JSObjectGetProperty(m_context, arg, RSVPStr.get(), NULL);
 614     JSValueRef typeData = JSObjectGetProperty(m_context, arg, typeStr.get(), NULL);
 615     JSValueRef groupData = JSObjectGetProperty(m_context, arg, groupStr.get(), NULL);
 616     JSValueRef delegatorURIData = JSObjectGetProperty(m_context, arg, delegatorURIStr.get(), NULL);
 617     JSValueRef delegateURIData = JSObjectGetProperty(m_context, arg, delegateURIStr.get(), NULL);
 618     JSValueRef contactRefData = JSObjectGetProperty(m_context, arg, contactRefStr.get(), NULL);
 619
 620     if (!JSValueIsUndefined(m_context, nameData)) {
 621         result->setName(toString(nameData));
 622     }
 623     if (!JSValueIsUndefined(m_context, uriData)) {
 624         result->setURI(toString(uriData));
 625     }
 626     if (!JSValueIsUndefined(m_context, roleData)) {
 627         result->setRole(toEventAttendeeRole(toString(roleData)));
 628     }
 629     if (!JSValueIsUndefined(m_context, statusData)) {
 630         result->setStatus(toEventAttendeeStatus(toString(statusData)));
 631     }
 632     if (!JSValueIsUndefined(m_context, RSVPData)) {
 633         result->setRSVP(toBool(RSVPData));
 634     }
 635     if (!JSValueIsUndefined(m_context, typeData)) {
 636         result->setType(toEventAttendeeType(toString(typeData)));
 637     }
 638     if (!JSValueIsUndefined(m_context, groupData)) {
 639         result->setGroup(toString(groupData));
 640     }
 641     if (!JSValueIsUndefined(m_context, delegatorURIData)) {
 642         result->setDelegatorURI(toString(delegatorURIData));
 643     }
 644     if (!JSValueIsUndefined(m_context, delegateURIData)) {
 645         result->setDelegateURI(toString(delegateURIData));
 646     }
 647     if (!JSValueIsUndefined(m_context, contactRefData)) {
 648         DeviceAPI::Contact::ContactConverter contactConverter(m_context);
 649         result->setContactId(contactConverter.toContactRef(contactRefData)->getContactId());
 650         result->setAddressBookId(contactConverter.toContactRef(contactRefData)->getAddressBookId());
 651     }
 652
 653     return result;
 654 }
 655
 656 EventAttendeeListPtr CalendarConverter::toVectorOfAttendeesFromDictionary(JSValueRef attendees)
 657 {
 658     EventAttendeeListPtr result(new EventAttendeeList());
 659
 660     JSObjectRef objArg = toJSObjectRef(attendees);
 661     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
 662     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
 663         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
 664         result->push_back(toAttendee(element));
 665     }
 666
 667     return result;
 668 }
 669
 670 EventAttendeeListPtr CalendarConverter::toVectorOfAttendeesFromReference(JSValueRef attendees)
 671 {
 672     EventAttendeeListPtr result(new EventAttendeeList());
 673
 674     JSObjectRef objArg = toJSObjectRef(attendees);
 675     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
 676     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
 677         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
 678                 if (JSValueIsObjectOfClass(m_context, element, JSCalendarAttendee::getClassRef())) {
 679                 result->push_back(JSCalendarAttendee::getPrivateObject(JSValueToObject(m_context, element, NULL)));
 680                 } else {
 681                         LogDebug("Invalid attendee type. Skip this with index: "<<i);
 682                         continue;
 683                 }
 684     }
 685
 686     return result;
 687 }
 688
 689 EventAlarmPtr CalendarConverter::toEventAlarm(JSValueRef alarm)
 690 {
 691     EventAlarmPtr result(new EventAlarm());
 692     const ScopedJSStringRef absoluteDateStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ALARM_ABSOLUTE_DATE));
 693     const ScopedJSStringRef beforeStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ALARM_BEFORE));
 694     const ScopedJSStringRef methodStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ALARM_METHOD));
 695     const ScopedJSStringRef descriptionStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ALARM_DESCRIPTION));
 696
 697     JSObjectRef arg = toJSObjectRef(alarm);
 698
 699     JSValueRef absoluteDateData = JSObjectGetProperty(m_context, arg, absoluteDateStr.get(), NULL);
 700     JSValueRef beforeData = JSObjectGetProperty(m_context, arg, beforeStr.get(), NULL);
 701     JSValueRef methodData = JSObjectGetProperty(m_context, arg, methodStr.get(), NULL);
 702     JSValueRef descriptionData = JSObjectGetProperty(m_context, arg, descriptionStr.get(), NULL);
 703
 704     if (!JSValueIsUndefined(m_context, absoluteDateData)) {
 705         TimeUtilConverter timeConverter(m_context);
 706         result->setAbsoluteDate((long long int) (timeConverter.getTimeInMilliseconds(absoluteDateData)/1000));
 707     }
 708     if (!JSValueIsUndefined(m_context, beforeData)) {
 709         TimeUtilConverter timeConverter(m_context);
 710         result->setDuration(timeConverter.getDurationPropertis(beforeData));
 711     }
 712     if (!JSValueIsUndefined(m_context, methodData)) {
 713         result->setMethod(toEventAlarmType(toString(methodData)));
 714     }
 715     if (!JSValueIsUndefined(m_context, descriptionData)) {
 716         result->setDescription(toString(descriptionData));
 717     }
 718
 719     return result;
 720 }
 721
 722 EventAlarmListPtr CalendarConverter::toVectorOfEventAlarmsFromDictionary(JSValueRef alarms)
 723 {
 724     EventAlarmListPtr result(new EventAlarmList());
 725
 726     JSObjectRef objArg = toJSObjectRef(alarms);
 727     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
 728     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
 729         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
 730         result->push_back(toEventAlarm(element));
 731     }
 732
 733     return result;
 734 }
 735
 736 EventAlarmListPtr CalendarConverter::toVectorOfEventAlarmsFromReference(JSValueRef alarms)
 737 {
 738     EventAlarmListPtr result(new EventAlarmList());
 739
 740     JSObjectRef objArg = toJSObjectRef(alarms);
 741     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
 742     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
 743         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
 744                 if (JSValueIsObjectOfClass(m_context, element, JSCalendarAlarm::getClassRef())) {
 745                 result->push_back(JSCalendarAlarm::getPrivateObject(JSValueToObject(m_context, element, NULL)));
 746                 } else {
 747                         LogDebug("Invalid alarm type. Skip this with index: "<<i);
 748                         continue;
 749                 }
 750     }
 751
 752     return result;
 753 }
 754
 755 CalendarEventPtr CalendarConverter::toItem(const JSValueRef value, bool updateMode)
 756 {
 757         CalendarEventPtr result;
 758         JSObjectRef arg = toJSObjectRef(value);
 759
 760         if(updateMode) {
 761                 LogDebug("Update mode.");
 762         result = JSCalendarEvent::getPrivateObject(arg);
 763         } else {
 764                 LogDebug("Constructor mode.");
 765             CalendarEventPtr resultPtr(new CalendarEvent());
 766                 result = resultPtr;
 767         }
 768
 769     const ScopedJSStringRef descriptionStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_DESCRIPTION));
 770     const ScopedJSStringRef summaryStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_SUMMARY));
 771     const ScopedJSStringRef startTimeStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_START_DATE));
 772     const ScopedJSStringRef durationStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_DURATION));
 773     const ScopedJSStringRef locationStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_LOCATION));
 774     const ScopedJSStringRef categoriesStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_CATEGORIES));
 775     const ScopedJSStringRef statusStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_STATUS));
 776     const ScopedJSStringRef alarmsStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_ALARMS));
 777     const ScopedJSStringRef isAllDayStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_IS_ALL_DAY));
 778     const ScopedJSStringRef organizerStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_ORGANIZER));
 779     const ScopedJSStringRef attendeesStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_ATTENDEES));
 780     const ScopedJSStringRef geolocationStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_GEOLOCATION));
 781     const ScopedJSStringRef visibilityStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_VISIBILITY));
 782     const ScopedJSStringRef availabilityStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_EVENT_AVAILABILITY));
 783     const ScopedJSStringRef recurrenceRuleStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_EVENT_RECURRENCE_RULE));
 784     const ScopedJSStringRef priorityStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_PRIORITY));
 785     const ScopedJSStringRef endDateStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_EVENT_END_DATE));
 786     const ScopedJSStringRef dueDateStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_TASK_DUE_DATE));
 787     const ScopedJSStringRef completedDateStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_TASK_COMPLETED_DATE));
 788     const ScopedJSStringRef progressStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_TASK_PROGRESS));
 789
 790     JSValueRef descriptionData = JSObjectGetProperty(m_context, arg, descriptionStr.get(), NULL);
 791     JSValueRef summaryData = JSObjectGetProperty(m_context, arg, summaryStr.get(), NULL);
 792     JSValueRef startTimeData = JSObjectGetProperty(m_context, arg, startTimeStr.get(), NULL);
 793     JSValueRef durationData = JSObjectGetProperty(m_context, arg, durationStr.get(), NULL);
 794     JSValueRef locationData = JSObjectGetProperty(m_context, arg, locationStr.get(), NULL);
 795     JSValueRef categoriesData = JSObjectGetProperty(m_context, arg, categoriesStr.get(), NULL);
 796     JSValueRef statusData = JSObjectGetProperty(m_context, arg, statusStr.get(), NULL);
 797     JSValueRef alarmsData = JSObjectGetProperty(m_context, arg, alarmsStr.get(), NULL);
 798     JSValueRef isAllDayData = JSObjectGetProperty(m_context, arg, isAllDayStr.get(), NULL);
 799     JSValueRef organizerData = JSObjectGetProperty(m_context, arg, organizerStr.get(), NULL);
 800     JSValueRef attendeesData = JSObjectGetProperty(m_context, arg, attendeesStr.get(), NULL);
 801     JSValueRef geolocationData = JSObjectGetProperty(m_context, arg, geolocationStr.get(), NULL);
 802     JSValueRef visibilityData = JSObjectGetProperty(m_context, arg, visibilityStr.get(), NULL);
 803     JSValueRef availabilityData = JSObjectGetProperty(m_context, arg, availabilityStr.get(), NULL);
 804     JSValueRef recurrenceRuleData = JSObjectGetProperty(m_context, arg, recurrenceRuleStr.get(), NULL);
 805     JSValueRef priorityData = JSObjectGetProperty(m_context, arg, priorityStr.get(), NULL);
 806     JSValueRef endDateData = JSObjectGetProperty(m_context, arg, endDateStr.get(), NULL);
 807     JSValueRef dueDateData = JSObjectGetProperty(m_context, arg, dueDateStr.get(), NULL);
 808     JSValueRef completedDateData = JSObjectGetProperty(m_context, arg, completedDateStr.get(), NULL);
 809     JSValueRef progressData = JSObjectGetProperty(m_context, arg, progressStr.get(), NULL);
 810
 811     TimeUtilConverter timeUtilConverter(m_context);
 812
 813     if (!JSValueIsUndefined(m_context, descriptionData)) {
 814         result->setDescription(toString(descriptionData));
 815     }
 816
 817     if (!JSValueIsUndefined(m_context, summaryData)) {
 818         result->setSubject(toString(summaryData));
 819     }
 820
 821     //It's important to set startTime before duration to set end date
 822     if (!JSValueIsUndefined(m_context, startTimeData)) {
 823         result->setStartTime((long long int) (timeUtilConverter.getTimeInMilliseconds(startTimeData)/1000));
 824         result->setTimeZone(timeUtilConverter.getPropertiesInTZDate(startTimeData).timezone);
 825         LogInfo("start time converted from TZDate: "<<result->getStartTime()<<", time zone: "<<result->getTimeZone());
 826     } else {
 827
 828         //set default value, current local time.
 829         if(m_calendarType == CalendarEvent::EVENT_TYPE) {
 830             //result->setStartTime(std::time(NULL));
 831         }
 832     }
 833
 834     if (!JSValueIsUndefined(m_context, durationData)) {
 835         long length = timeUtilConverter.getDurationLength(durationData);
 836         int unit = timeUtilConverter.getDurationUnit(durationData);
 837         LogDebug("duration length: "<<length<<", unit "<<unit);
 838         if (length < 0) {
 839             ThrowMsg(ConversionException, "Wrong duration length.");
 840         }
 841         if( MSECS_UNIT==unit ) {
 842                     result->setEndTime(result->getStartTime() + length/1000);
 843         } else if( SECONDS_UNIT==unit ) {
 844             result->setEndTime(result->getStartTime() + length);
 845         } else if ( MINUTES_UNIT==unit ) {
 846             result->setEndTime(result->getStartTime() + length*60);
 847         } else if ( HOURS_UNIT==unit ) {
 848             result->setEndTime(result->getStartTime() + length*60*60);
 849         } else if ( DAYS_UNIT==unit ) {
 850             result->setEndTime(result->getStartTime() + length*24*60*60);
 851         } else {
 852             ThrowMsg(ConversionException, "Wrong duration unit.");
 853         }
 854     }
 855     if (!JSValueIsUndefined(m_context, locationData)) {
 856         result->setLocation(toString(locationData));
 857     }
 858     if (!JSValueIsUndefined(m_context, categoriesData)) {
 859         StringArrayPtr categories(new StringArray());
 860         *categories = toVectorOfStrings(categoriesData);
 861         result->setCategories(categories);
 862     }
 863
 864     if (!JSValueIsUndefined(m_context, statusData)) {
 865         result->setStatus(toEventStatus(toString(statusData)));
 866     } else {
 867         result->setStatus(CalendarEvent::CONFIRMED_STATUS);
 868     }
 869     if (!JSValueIsUndefined(m_context, alarmsData)) {
 870         EventAlarmListPtr alarms = toVectorOfEventAlarmsFromReference(alarmsData);
 871         result->setAlarms(alarms);
 872     }
 873     if (!JSValueIsUndefined(m_context, isAllDayData)) {
 874         result->setIsAllDay(toBool(isAllDayData));
 875     }
 876     if (!JSValueIsUndefined(m_context, organizerData)) {
 877         result->setOrganizer(toString(organizerData));
 878     }
 879     if (!JSValueIsUndefined(m_context, attendeesData)) {
 880         EventAttendeeListPtr attendees = toVectorOfAttendeesFromReference(attendeesData);
 881         result->setAttendees(attendees);
 882     }
 883     if (!JSValueIsUndefined(m_context, geolocationData)) {
 884         DeviceAPI::Tizen::SimpleCoordinatesPtr geoLocation =
 885             DeviceAPI::Tizen::JSSimpleCoordinates::getSimpleCoordinates(m_context, geolocationData);
 886         result->setLatitude(geoLocation->getLatitude());
 887         result->setLongitude(geoLocation->getLongitude());
 888     }
 889     if (!JSValueIsUndefined(m_context, visibilityData)) {
 890         result->setVisibility(toEventVisibility(toString(visibilityData)));
 891     }
 892     if (!JSValueIsUndefined(m_context, availabilityData)) {
 893         result->setAvailability(toEventAvailability(toString(availabilityData)));
 894     }
 895     if (!JSValueIsUndefined(m_context, recurrenceRuleData)) {
 896                 if(updateMode) {
 897                         result->setRecurrenceRule(toEventRecurrenceRule(recurrenceRuleData));
 898                 } else {
 899                 result->setRecurrenceRule(JSCalendarRecurrenceRule::getPrivateObject(JSValueToObject(m_context, recurrenceRuleData, NULL)));
 900                 }
 901     }
 902     if (!JSValueIsUndefined(m_context, priorityData)) {
 903         result->setPriority(toTaskPriority(toString(priorityData)));
 904     }
 905     if (!JSValueIsUndefined(m_context, endDateData)) {
 906         if( result->getTimeZone().empty() ) {
 907             result->setTimeZone(timeUtilConverter.getPropertiesInTZDate(endDateData).timezone);
 908         }
 909         result->setEndTime((long long int) (timeUtilConverter.getTimeInMilliseconds(endDateData)/1000));
 910     }
 911     if (!JSValueIsUndefined(m_context, dueDateData)) {
 912         if( result->getTimeZone().empty() ) {
 913             result->setTimeZone(timeUtilConverter.getPropertiesInTZDate(dueDateData).timezone);
 914         }
 915         result->setEndTime((long long int) (timeUtilConverter.getTimeInMilliseconds(dueDateData)/1000));
 916     }
 917     if (!JSValueIsUndefined(m_context, completedDateData)) {
 918         if( result->getTimeZone().empty() ) {
 919             result->setTimeZone(timeUtilConverter.getPropertiesInTZDate(completedDateData).timezone);
 920         }
 921         result->setCompletedDate((long long int) (timeUtilConverter.getTimeInMilliseconds(completedDateData)/1000));
 922     }
 923     if (!JSValueIsUndefined(m_context, progressData)) {
 924         result->setProgress(toInt(progressData));
 925     }
 926     LogDebug("timezone: "<<result->getTimeZone());
 927
 928     return result;
 929 }
 930
 931 CalendarEventListPtr CalendarConverter::toVectorOfItems(JSValueRef events)
 932 {
 933     CalendarEventListPtr result(new CalendarEventList());
 934
 935     JSObjectRef objArg = toJSObjectRef(events);
 936     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
 937     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
 938         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
 939                 if (JSValueIsObjectOfClass(m_context, element, JSCalendarEvent::getClassRef())) {
 940                 JSObjectRef arg = JSValueToObject(m_context, element, NULL);
 941             result->push_back(JSCalendarEvent::getPrivateObject(arg));
 942                 } else if (JSValueIsObjectOfClass(m_context, element, JSCalendarTask::getClassRef())) {
 943                 JSObjectRef arg = JSValueToObject(m_context, element, NULL);
 944             result->push_back(JSCalendarTask::getPrivateObject(arg));
 945                 } else {
 946                         LogDebug("Invalid item type. Skip this with index: "<<i);
 947                         continue;
 948                 }
 949     }
 950
 951     return result;
 952 }
 953
 954 CalendarEventListPtr CalendarConverter::toVectorOfItemsFromDictionary(JSValueRef events)
 955 {
 956     CalendarEventListPtr result(new CalendarEventList());
 957
 958     JSObjectRef objArg = toJSObjectRef(events);
 959     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
 960     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
 961         result->push_back(toItem(JSGetArrayElement(m_context, objArg, i), true));
 962     }
 963
 964     return result;
 965 }
 966
 967 EventIdPtr CalendarConverter::toEventId(JSValueRef eventId)
 968 {
 969     EventIdPtr result(new EventId());
 970     const ScopedJSStringRef uidStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_EVENT_ID_UID));
 971     const ScopedJSStringRef recurrenceIdStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_EVENT_ID_RECURRENCEID));
 972
 973     JSObjectRef arg = toJSObjectRef(eventId);
 974
 975     JSValueRef uidData = JSObjectGetProperty(m_context, arg, uidStr.get(), NULL);
 976     JSValueRef recurrenceIdData = JSObjectGetProperty(m_context, arg, recurrenceIdStr.get(), NULL);
 977
 978     if (!JSValueIsUndefined(m_context, uidData)) {
 979         result->setUId(toString(uidData));
 980     }
 981     if (!JSValueIsUndefined(m_context, recurrenceIdData)) {
 982         result->setRecurrenceId(toString(recurrenceIdData));
 983    }
 984
 985     return result;
 986 }
 987
 988 EventIdListPtr CalendarConverter::toVectorOfEventIds(JSValueRef eventIds)
 989 {
 990     EventIdListPtr result(new EventIdList());
 991
 992     JSObjectRef objArg = toJSObjectRef(eventIds);
 993     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
 994     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
 995         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
 996
 997                 if (JSValueIsObjectOfClass(m_context, element, JSCalendarEventId::getClassRef())) {
 998                         EventIdPtr idPtr = JSCalendarEventId::getPrivateObject(JSValueToObject(m_context, element, NULL));
 999                     idPtr->setCalendarType(CalendarEvent::EVENT_TYPE);
1000                         result->push_back(idPtr);
1001                 } else {
1002                         LogDebug("Invalid event id type. Skip this index: "<<i);
1003                         continue;
1004                 }
1005     }
1006
1007     return result;
1008 }
1009
1010 std::vector<long long int> CalendarConverter::toVectorOfTimeFromTZDate(JSValueRef dates)
1011 {
1012     std::vector<long long int> result;
1013     TimeUtilConverter converter(m_context);
1014
1015     JSObjectRef objArg = toJSObjectRef(dates);
1016     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
1017     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
1018         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
1019         result.push_back((long long int) (converter.getTimeInMilliseconds(element)/1000));
1020     }
1021
1022     return result;
1023 }
1024
1025 std::string CalendarConverter::toTizenValue(CalendarEvent::TaskPriority abstractValue) const
1026 {
1027     switch (abstractValue) {
1028     case CalendarEvent::HIGH_PRIORITY:
1029         return TIZEN_CALENDAR_PROPERTY_HIGH_PRIORITY;
1030     case CalendarEvent::MEDIUM_PRIORITY:
1031         return TIZEN_CALENDAR_PROPERTY_MEDIUM_PRIORITY;
1032     case CalendarEvent::LOW_PRIORITY:
1033         return TIZEN_CALENDAR_PROPERTY_LOW_PRIORITY;
1034     default:
1035         break;
1036     }
1037     return TIZEN_CALENDAR_PROPERTY_LOW_PRIORITY;
1038 }
1039
1040 CalendarEvent::TaskPriority CalendarConverter::toTaskPriority(std::string priority) const
1041 {
1042     if (!priority.compare(TIZEN_CALENDAR_PROPERTY_HIGH_PRIORITY))
1043         return CalendarEvent::HIGH_PRIORITY;
1044     else if (!priority.compare(TIZEN_CALENDAR_PROPERTY_MEDIUM_PRIORITY))
1045         return CalendarEvent::MEDIUM_PRIORITY;
1046     else if (!priority.compare(TIZEN_CALENDAR_PROPERTY_LOW_PRIORITY))
1047         return CalendarEvent::LOW_PRIORITY;
1048     else
1049         ThrowMsg(ConversionException, "Invalid priority type.");
1050
1051     return CalendarEvent::UNDEFINED_PRIORITY;
1052 }
1053
1054 CalendarEvent::CalendarType CalendarConverter::toCalendarType(std::string type) const
1055 {
1056     if (!type.compare(TIZEN_CALENDAR_PROPERTY_TYPE_EVENT))
1057         return CalendarEvent::EVENT_TYPE;
1058     else if (!type.compare(TIZEN_CALENDAR_PROPERTY_TYPE_TASK))
1059         return CalendarEvent::TASK_TYPE;
1060     else
1061         ThrowMsg(ConversionException, "Invalid calendar type.");
1062
1063     return CalendarEvent::UNDEFINED_TYPE;
1064 }
1065
1066 CalendarEvent::VObjectFormat CalendarConverter::toVObjectFormat(std::string format) const
1067 {
1068     if (!format.compare(TIZEN_CALENDAR_PROPERTY_VCALENDAR_20_FORMAT))
1069         return CalendarEvent::ICALENDAR_20;
1070     else if (!format.compare(TIZEN_CALENDAR_PROPERTY_VCALENDAR_10_FORMAT))
1071         return CalendarEvent::VCALENDAR_10;
1072     else
1073         ThrowMsg(ConversionException, "Invalid format type.");
1074
1075     return CalendarEvent::UNDEFINED_FORMAT;
1076 }
1077
1078 }
1079 }