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