src/standards/Tizen/Calendar/CalendarConverter.cpp

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