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.h>
  19 #include <CommonsJavaScript/Validator.h>
  20 #include <CommonsJavaScript/JSUtils.h>
  21 #include "JSCalendarItem.h"
  22 #include "JSCalendarItemProperties.h"
  23 #include "JSEventId.h"
  24 #include "CalendarConverter.h"
  25 #include "JSCalendar.h"
  26 #include "JSCalendarManager.h"
  27 #include "JSCategoryArray.h"
  28 #include "JSAttendee.h"
  29 #include "JSRecurrenceRule.h"
  30 #include <Tizen/TimeUtil/TimeUtilConverter.h>
  31
  32 using namespace TizenApis::Api::Calendar;
  33 using namespace WrtDeviceApis::Commons;
  34 using namespace WrtDeviceApis::CommonsJavaScript;
  35
  36 namespace {
  37 const int DEFAULT_EVENT_INTERVAL = 1;
  38 }
  39
  40 namespace TizenApis {
  41 namespace Tizen1_0 {
  42 namespace Calendar {
  43
  44 std::vector<std::string> CalendarConverter::m_allowedAttributes;
  45 std::vector<std::string> CalendarConverter::m_allowedCreateProperties;
  46
  47 CalendarConverter::CalendarConverter(JSContextRef context, CalendarEvent::CalendarType calendarType) : Converter(context)
  48 {
  49     LogDebug("entered");
  50
  51     m_calendarType = calendarType;
  52
  53     if (m_allowedAttributes.size() == 0) { // for search filter
  54         m_allowedAttributes.push_back("id");
  55         m_allowedAttributes.push_back("summary");
  56         m_allowedAttributes.push_back("description");
  57         m_allowedAttributes.push_back("location");
  58         m_allowedAttributes.push_back("category");
  59         m_allowedAttributes.push_back("status");
  60         m_allowedAttributes.push_back("initialStartDate");
  61         m_allowedAttributes.push_back("endStartDate");
  62     }
  63     if (m_allowedCreateProperties.size() == 0) {
  64         m_allowedCreateProperties.push_back("description");
  65         m_allowedCreateProperties.push_back("summary");
  66         m_allowedCreateProperties.push_back("startDate");
  67         m_allowedCreateProperties.push_back("duration");
  68         m_allowedCreateProperties.push_back("location");
  69         m_allowedCreateProperties.push_back("categories");
  70         m_allowedCreateProperties.push_back("status");
  71         m_allowedCreateProperties.push_back("alarms");
  72         m_allowedCreateProperties.push_back("isAllDay");
  73         m_allowedCreateProperties.push_back("organizer");
  74         m_allowedCreateProperties.push_back("attendees");
  75         m_allowedCreateProperties.push_back("position");
  76         m_allowedCreateProperties.push_back("visibility");
  77         m_allowedCreateProperties.push_back("lastModifiedDate");
  78         m_allowedCreateProperties.push_back("availability");
  79         m_allowedCreateProperties.push_back("recurrenceRule");
  80         m_allowedCreateProperties.push_back("isDetached");
  81         m_allowedCreateProperties.push_back("attributesOfInterest");
  82     }
  83 }
  84
  85 CalendarConverter::~CalendarConverter()
  86 {
  87     LogDebug("entered");
  88 }
  89
  90 JSValueRef CalendarConverter::toJSValueRefItem(const CalendarEventPtr& arg)
  91 {
  92     return JSUtils::makeObject(m_context, JSCalendarItem::getClassRef(), arg);
  93 }
  94
  95 JSValueRef CalendarConverter::toJSValueRef(const CalendarEventListPtr &arg)
  96 {
  97     return toJSValueRef_(*arg, &CalendarConverter::toJSValueRefItem, this);
  98 }
  99
 100 JSValueRef CalendarConverter::toJSValueRefItemProperties(const CalendarEventPtr& arg)
 101 {
 102     return JSUtils::makeObject(m_context, JSCalendarItemProperties::getClassRef(), arg);
 103 }
 104
 105 JSValueRef CalendarConverter::toJSValueRefCalendar(const ICalendarPtr& arg)
 106 {
 107     CalendarPrivObject *priv = new CalendarPrivObject(m_context, arg);
 108     return JSObjectMake(m_context, JSCalendar::getClassRef(), priv);
 109 }
 110
 111 JSValueRef CalendarConverter::toJSValueRef(const std::vector<ICalendarPtr> &arg)
 112 {
 113     return toJSValueRef_(arg, &CalendarConverter::toJSValueRefCalendar, this);
 114 }
 115
 116 JSValueRef CalendarConverter::toJSValueRef(const EventIdPtr& arg)
 117 {
 118     return JSUtils::makeObject(m_context, JSEventId::getClassRef(), arg);
 119 }
 120
 121 CalendarEvent::EventAlarmType CalendarConverter::toEventAlarmType(int tizenValue)
 122 const
 123 {
 124     switch (tizenValue) {
 125     case JSCalendarManager::NO_ALARM:
 126         return CalendarEvent::NO_ALARM;
 127     case JSCalendarManager::SILENT_ALARM:
 128         return CalendarEvent::SILENT_ALARM;
 129     case JSCalendarManager::SOUND_ALARM:
 130         return CalendarEvent::SOUND_ALARM;
 131     default:
 132         break;
 133     }
 134     ThrowMsg(InvalidArgumentException, "Alarm type has wrong value");
 135 }
 136
 137 int CalendarConverter::toTizenValue(
 138         CalendarEvent::EventAlarmType abstractValue) const
 139 {
 140     switch (abstractValue) {
 141     case CalendarEvent::NO_ALARM:
 142         return JSCalendarManager::NO_ALARM;
 143     case CalendarEvent::SILENT_ALARM:
 144         return JSCalendarManager::SILENT_ALARM;
 145     case CalendarEvent::SOUND_ALARM:
 146         return JSCalendarManager::SOUND_ALARM;
 147     default:
 148         break;
 149     }
 150     ThrowMsg(ConversionException, "Invalid alarm type");
 151 }
 152
 153 CalendarEvent::EventStatus CalendarConverter::toEventStatus(std::string tizenValue) const
 154 {
 155     if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_TENTATIVE_STATUS))
 156         return CalendarEvent::TENTATIVE_STATUS;
 157     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CONFIRMED_STATUS))
 158         return CalendarEvent::CONFIRMED_STATUS;
 159     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CANCELLED_STATUS))
 160         return CalendarEvent::CANCELLED_STATUS;
 161     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_NEEDS_ACTION_STATUS))
 162         return CalendarEvent::NEEDS_ACTION_STATUS;
 163     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_IN_PROCESS_STATUS))
 164         return CalendarEvent::IN_PROCESS_STATUS;
 165     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS))
 166         return CalendarEvent::COMPLETED_STATUS;
 167
 168     // default value setting.
 169     if(m_calendarType == CalendarEvent::EVENT_TYPE) {
 170         return CalendarEvent::TENTATIVE_STATUS;
 171     } else {
 172         return CalendarEvent::NEEDS_ACTION_STATUS;
 173     }
 174 }
 175
 176 std::string CalendarConverter::toTizenValue(CalendarEvent::EventStatus abstractValue)
 177 const
 178 {
 179     switch (abstractValue) {
 180     case CalendarEvent::TENTATIVE_STATUS:
 181         return TIZEN_CALENDAR_PROPERTY_TENTATIVE_STATUS;
 182     case CalendarEvent::CONFIRMED_STATUS:
 183         return TIZEN_CALENDAR_PROPERTY_CONFIRMED_STATUS;
 184     case CalendarEvent::CANCELLED_STATUS:
 185         return TIZEN_CALENDAR_PROPERTY_CANCELLED_STATUS;
 186     case CalendarEvent::NEEDS_ACTION_STATUS:
 187         return TIZEN_CALENDAR_PROPERTY_NEEDS_ACTION_STATUS;
 188     case CalendarEvent::IN_PROCESS_STATUS:
 189         return TIZEN_CALENDAR_PROPERTY_IN_PROCESS_STATUS;
 190     case CalendarEvent::COMPLETED_STATUS:
 191         return TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS;
 192     default:
 193         break;
 194     }
 195
 196     ThrowMsg(ConversionException, "Invalid status");
 197 }
 198
 199 EventRecurrenceRule::EventRecurrence CalendarConverter::toRecurrenceFrequency(
 200         std::string tizenValue) const
 201 {
 202     if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_NO_RECURRENCE))
 203         return EventRecurrenceRule::NO_RECURRENCE;
 204     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_DAILY_RECURRENCE))
 205         return EventRecurrenceRule::DAILY_RECURRENCE;
 206     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_WEEKLY_RECURRENCE))
 207         return EventRecurrenceRule::WEEKLY_RECURRENCE;
 208     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_MONTHLY_RECURRENCE))
 209         return EventRecurrenceRule::MONTHLY_RECURRENCE;
 210     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_YEARLY_RECURRENCE))
 211         return EventRecurrenceRule::YEARLY_RECURRENCE;
 212
 213     return EventRecurrenceRule::NO_RECURRENCE;
 214 }
 215
 216 std::string CalendarConverter::toTizenValue(
 217         EventRecurrenceRule::EventRecurrence abstractValue) const
 218 {
 219     switch (abstractValue) {
 220     case EventRecurrenceRule::NO_RECURRENCE:
 221         return TIZEN_CALENDAR_PROPERTY_NO_RECURRENCE;
 222     case EventRecurrenceRule::DAILY_RECURRENCE:
 223         return TIZEN_CALENDAR_PROPERTY_DAILY_RECURRENCE;
 224     case EventRecurrenceRule::WEEKLY_RECURRENCE:
 225     case EventRecurrenceRule::WEEKDAY_RECURRENCE:
 226         return TIZEN_CALENDAR_PROPERTY_WEEKLY_RECURRENCE;
 227     case EventRecurrenceRule::MONTHLY_RECURRENCE:
 228     case EventRecurrenceRule::MONTHLY_ON_DAY_RECURRENCE:
 229         return TIZEN_CALENDAR_PROPERTY_MONTHLY_RECURRENCE;
 230     case EventRecurrenceRule::YEARLY_RECURRENCE:
 231         return TIZEN_CALENDAR_PROPERTY_YEARLY_RECURRENCE;
 232     default:
 233         break;
 234     }
 235
 236     return TIZEN_CALENDAR_PROPERTY_NO_RECURRENCE;
 237 }
 238
 239 EventRecurrenceRulePtr CalendarConverter::toEventRecurrenceRule(JSValueRef rrule)
 240 {
 241     LogDebug("entered");
 242     EventRecurrenceRulePtr result(new EventRecurrenceRule());
 243     const ScopedJSStringRef frequencyStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_FREQUENCY));
 244     const ScopedJSStringRef intervalStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_INTERVAL));
 245     const ScopedJSStringRef endDateStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_END_DATE));
 246     const ScopedJSStringRef occurrenceCountStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_OCCURRENCE_COUNT));
 247 //    const ScopedJSStringRef daysOfTheMonthStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_MONTH));
 248     const ScopedJSStringRef daysOfTheWeekStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_WEEK));
 249 //    const ScopedJSStringRef daysOfTheYearStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_YEAR));
 250 //    const ScopedJSStringRef weeksOfTheYearStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_WEEKS_OF_THE_YEAR));
 251     const ScopedJSStringRef setPositionStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_SET_POSITION));
 252     const ScopedJSStringRef exceptionsStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_EXCEPTIONS));
 253
 254     JSObjectRef arg = toJSObjectRef(rrule);
 255
 256     JSValueRef frequencyData = JSObjectGetProperty(m_context, arg, frequencyStr.get(), NULL);
 257     JSValueRef intervalData = JSObjectGetProperty(m_context, arg, intervalStr.get(), NULL);
 258     JSValueRef endDateData = JSObjectGetProperty(m_context, arg, endDateStr.get(), NULL);
 259     JSValueRef occurrenceCountData = JSObjectGetProperty(m_context, arg, occurrenceCountStr.get(), NULL);
 260 //    JSValueRef daysOfTheMonthData = JSObjectGetProperty(m_context, arg, daysOfTheMonthStr.get(), NULL);
 261     JSValueRef daysOfTheWeekData = JSObjectGetProperty(m_context, arg, daysOfTheWeekStr.get(), NULL);
 262 //    JSValueRef daysOfTheYearData = JSObjectGetProperty(m_context, arg, daysOfTheYearStr.get(), NULL);
 263 //    JSValueRef weeksOfTheYearData = JSObjectGetProperty(m_context, arg, weeksOfTheYearStr.get(), NULL);
 264     JSValueRef setPositionData = JSObjectGetProperty(m_context, arg, setPositionStr.get(), NULL);
 265     JSValueRef exceptionsData = JSObjectGetProperty(m_context, arg, exceptionsStr.get(), NULL);
 266
 267     if (!JSValueIsUndefined(m_context, frequencyData)) {
 268         result->setFrequency(toRecurrenceFrequency(toString(frequencyData)));
 269     }
 270     if (!JSValueIsUndefined(m_context, intervalData)) {
 271         result->setInterval(toInt(intervalData));
 272     } else {
 273         result->setInterval(DEFAULT_EVENT_INTERVAL);
 274     }
 275     if (!JSValueIsUndefined(m_context, endDateData)) {
 276         if (!JSValueIsNull(m_context, endDateData)) {
 277             result->setEndDate(toDateTimeT(endDateData));
 278         } else {
 279             result->resetEndDate();
 280         }
 281     }
 282     if (!JSValueIsUndefined(m_context, occurrenceCountData)) {
 283         result->setOccurrenceCount(toLong(occurrenceCountData));
 284     }
 285 /*    if (!JSValueIsUndefined(m_context, daysOfTheMonthData)) {
 286         result->setDaysOfTheMonth(toVectorOfInts(daysOfTheMonthData));
 287     }*/
 288     if (!JSValueIsUndefined(m_context, daysOfTheWeekData)) {
 289         result->setDaysOfTheWeek(toVectorOfStrings(daysOfTheWeekData));
 290     }
 291 /*    if (!JSValueIsUndefined(m_context, daysOfTheYearData)) {
 292         result->setDaysOfTheYear(toVectorOfInts(daysOfTheYearData));
 293     }
 294     if (!JSValueIsUndefined(m_context, weeksOfTheYearData)) {
 295         result->setWeeksOfTheYear(toVectorOfInts(weeksOfTheYearData));
 296     }*/
 297     if (!JSValueIsUndefined(m_context, setPositionData)) {
 298         Throw(UnsupportedException);
 299         //result->setSetPosition(toBool(setPositionData));
 300     }
 301     if (!JSValueIsUndefined(m_context, exceptionsData)) {
 302         result->setExceptions(toVectorOfTimeT(exceptionsData));
 303     }
 304
 305     return result;
 306 }
 307
 308 CalendarEvent::EventVisibility CalendarConverter::toEventVisibility(std::string tizenValue)
 309 const
 310 {
 311     if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_PUBLIC_VISIBILITY))
 312         return CalendarEvent::PUBLIC_VISIBILITY;
 313     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_PRIVATE_VISIBILITY))
 314         return CalendarEvent::PRIVATE_VISIBILITY;
 315     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CONFIDENTIAL_VISIBILITY))
 316         return CalendarEvent::CONFIDENTIAL_VISIBILITY;
 317
 318     return CalendarEvent::PUBLIC_VISIBILITY;
 319 }
 320
 321 std::string CalendarConverter::toTizenValue(
 322         CalendarEvent::EventVisibility abstractValue) const
 323 {
 324     switch (abstractValue) {
 325     case CalendarEvent::PUBLIC_VISIBILITY:
 326         return TIZEN_CALENDAR_PROPERTY_PUBLIC_VISIBILITY;
 327     case CalendarEvent::PRIVATE_VISIBILITY:
 328         return TIZEN_CALENDAR_PROPERTY_PRIVATE_VISIBILITY;
 329     case CalendarEvent::CONFIDENTIAL_VISIBILITY:
 330         return TIZEN_CALENDAR_PROPERTY_CONFIDENTIAL_VISIBILITY;
 331     default:
 332         break;
 333     }
 334
 335     return TIZEN_CALENDAR_PROPERTY_PUBLIC_VISIBILITY;
 336 }
 337
 338 CalendarEvent::EventAvailability CalendarConverter::toEventAvailability(std::string tizenValue)
 339 const
 340 {
 341     if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_BUSY))
 342         return CalendarEvent::BUSY_FB;
 343     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_BUSY_UNAVAILABLE_FB))
 344         return CalendarEvent::BUSY_UNAVAILABLE_FB;
 345     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_FREE))
 346         return CalendarEvent::FREE_FB;
 347     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_BUSY_TENTATIVE))
 348         return CalendarEvent::BUSY_TENTATIVE_FB;
 349
 350     return CalendarEvent::BUSY_FB;
 351 }
 352
 353 std::string CalendarConverter::toTizenValue(
 354         CalendarEvent::EventAvailability abstractValue) const
 355 {
 356     switch (abstractValue) {
 357     case CalendarEvent::BUSY_FB:
 358         return TIZEN_CALENDAR_PROPERTY_BUSY;
 359     case CalendarEvent::BUSY_UNAVAILABLE_FB:
 360         return TIZEN_CALENDAR_PROPERTY_BUSY_UNAVAILABLE_FB;
 361     case CalendarEvent::FREE_FB:
 362         return TIZEN_CALENDAR_PROPERTY_FREE;
 363     case CalendarEvent::BUSY_TENTATIVE_FB:
 364         return TIZEN_CALENDAR_PROPERTY_BUSY_TENTATIVE;
 365     default:
 366         break;
 367     }
 368
 369     return TIZEN_CALENDAR_PROPERTY_BUSY;
 370 }
 371
 372 EventAttendee::EventAttendeeRole CalendarConverter::toEventAttendeeRole(std::string tizenValue)
 373 const
 374 {
 375     if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_REQ_PARTICIPANT_ROLE))
 376         return EventAttendee::REQ_PARTICIPANT_ROLE;
 377     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_OPT_PARTICIPANT_ROLE))
 378         return EventAttendee::OPT_PARTICIPANT_ROLE;
 379     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_NON_PARTICIPANT_ROLE))
 380         return EventAttendee::NON_PARTICIPANT_ROLE;
 381     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CHAIR_ROLE))
 382         return EventAttendee::CHAIR_ROLE;
 383
 384     return EventAttendee::REQ_PARTICIPANT_ROLE;
 385 }
 386
 387 std::string CalendarConverter::toTizenValue(
 388         EventAttendee::EventAttendeeRole abstractValue) const
 389 {
 390     switch (abstractValue) {
 391     case EventAttendee::REQ_PARTICIPANT_ROLE:
 392         return TIZEN_CALENDAR_PROPERTY_REQ_PARTICIPANT_ROLE;
 393     case EventAttendee::OPT_PARTICIPANT_ROLE:
 394         return TIZEN_CALENDAR_PROPERTY_OPT_PARTICIPANT_ROLE;
 395     case EventAttendee::NON_PARTICIPANT_ROLE:
 396         return TIZEN_CALENDAR_PROPERTY_NON_PARTICIPANT_ROLE;
 397     case EventAttendee::CHAIR_ROLE:
 398         return TIZEN_CALENDAR_PROPERTY_CHAIR_ROLE;
 399     default:
 400         break;
 401     }
 402     return TIZEN_CALENDAR_PROPERTY_REQ_PARTICIPANT_ROLE;
 403 }
 404
 405 EventAttendee::EventAttendeeStatus CalendarConverter::toEventAttendeeStatus(std::string tizenValue)
 406 const
 407 {
 408     if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_PENDING_STATUS))
 409         return EventAttendee::PENDING_AT_STATUS;
 410     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_ACCEPTED_STATUS))
 411         return EventAttendee::ACCEPTED_AT_STATUS;
 412     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_DECLINED_STATUS))
 413         return EventAttendee::DECLINED_AT_STATUS;
 414     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_TENTATIVE_STATUS))
 415         return EventAttendee::TENTATIVE_AT_STATUS;
 416     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_DELEGATED_STATUS))
 417         return EventAttendee::DELEGATED_AT_STATUS;
 418     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS))
 419         return EventAttendee::COMPLETED_AT_STATUS;
 420     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_IN_PROCESS_STATUS))
 421         return EventAttendee::IN_PROCESS_AT_STATUS;
 422
 423     return EventAttendee::PENDING_AT_STATUS;
 424 }
 425
 426 std::string CalendarConverter::toTizenValue(
 427         EventAttendee::EventAttendeeStatus abstractValue) const
 428 {
 429     switch (abstractValue) {
 430     case EventAttendee::PENDING_AT_STATUS:
 431         return TIZEN_CALENDAR_PROPERTY_PENDING_STATUS;
 432     case EventAttendee::ACCEPTED_AT_STATUS:
 433         return TIZEN_CALENDAR_PROPERTY_ACCEPTED_STATUS;
 434     case EventAttendee::DECLINED_AT_STATUS:
 435         return TIZEN_CALENDAR_PROPERTY_DECLINED_STATUS;
 436     case EventAttendee::TENTATIVE_AT_STATUS:
 437         return TIZEN_CALENDAR_PROPERTY_TENTATIVE_STATUS;
 438     case EventAttendee::DELEGATED_AT_STATUS:
 439         return TIZEN_CALENDAR_PROPERTY_DELEGATED_STATUS;
 440     case EventAttendee::COMPLETED_AT_STATUS:
 441         return TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS;
 442     case EventAttendee::IN_PROCESS_AT_STATUS:
 443         return TIZEN_CALENDAR_PROPERTY_IN_PROCESS_STATUS;
 444     default:
 445         break;
 446     }
 447     return TIZEN_CALENDAR_PROPERTY_PENDING_STATUS;
 448 }
 449
 450 EventAttendee::EventAttendeeType CalendarConverter::toEventAttendeeType(std::string tizenValue)
 451 const
 452 {
 453     if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_INDIVIDUAL_TYPE))
 454         return EventAttendee::INDIVIDUAL_TYPE;
 455     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_GROUP_TYPE))
 456         return EventAttendee::GROUP_TYPE;
 457     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_RESOURCE_TYPE))
 458         return EventAttendee::RESOURCE_TYPE;
 459     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_ROOM_TYPE))
 460         return EventAttendee::ROOM_TYPE;
 461     else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_UNKNOWN_TYPE))
 462         return EventAttendee::UNKNOWN_TYPE;
 463
 464     return EventAttendee::INDIVIDUAL_TYPE;
 465 }
 466
 467 std::string CalendarConverter::toTizenValue(
 468         EventAttendee::EventAttendeeType abstractValue) const
 469 {
 470     switch (abstractValue) {
 471     case EventAttendee::INDIVIDUAL_TYPE:
 472         return TIZEN_CALENDAR_PROPERTY_INDIVIDUAL_TYPE;
 473     case EventAttendee::GROUP_TYPE:
 474         return TIZEN_CALENDAR_PROPERTY_GROUP_TYPE;
 475     case EventAttendee::RESOURCE_TYPE:
 476         return TIZEN_CALENDAR_PROPERTY_RESOURCE_TYPE;
 477     case EventAttendee::ROOM_TYPE:
 478         return TIZEN_CALENDAR_PROPERTY_ROOM_TYPE;
 479     case EventAttendee::UNKNOWN_TYPE:
 480         return TIZEN_CALENDAR_PROPERTY_UNKNOWN_TYPE;
 481     default:
 482         break;
 483     }
 484
 485     return TIZEN_CALENDAR_PROPERTY_INDIVIDUAL_TYPE;
 486 }
 487
 488 JSValueRef CalendarConverter::toFunctionOrNull(const JSValueRef& arg)
 489 {
 490     if (Validator(m_context).isCallback(arg)) {
 491         return arg;
 492     } else if (!JSValueIsNull(m_context,
 493                               arg) && !JSValueIsUndefined(m_context, arg)) {
 494         ThrowMsg(InvalidArgumentException, "Not a function nor JS null.");
 495     }
 496     return NULL;
 497 }
 498
 499 JSValueRef CalendarConverter::toFunction(const JSValueRef& arg)
 500 {
 501     if (Validator(m_context).isCallback(arg)) {
 502         return arg;
 503     } else if (JSValueIsNull(m_context,
 504                              arg) || JSValueIsUndefined(m_context, arg)) {
 505         ThrowMsg(ConversionException, "JS null passed as function.");
 506     }
 507     ThrowMsg(InvalidArgumentException, "Not a function nor JS null.");
 508 }
 509
 510 void CalendarConverter::toEventFilterConvertId(
 511         const EventFilterPtr &result,
 512         const JSValueRef &filters)
 513 {
 514     const ScopedJSStringRef idStr(JSStringCreateWithUTF8CString("id"));
 515     JSObjectRef filterObj = toJSObjectRef(filters);
 516     if (JSObjectHasProperty(m_context, filterObj, idStr.get())) {
 517         LogDebug("converting id");
 518         JSValueRef value = JSObjectGetProperty(m_context, filterObj,
 519                                                idStr.get(), NULL);
 520         result->setIdFilter(toString(value));
 521     }
 522 }
 523
 524 void CalendarConverter::toEventFilterConvertSummary(
 525         const EventFilterPtr &result,
 526         const JSValueRef &filters)
 527 {
 528     const ScopedJSStringRef summaryStr(JSStringCreateWithUTF8CString("summary"));
 529     JSObjectRef filterObj = toJSObjectRef(filters);
 530     if (JSObjectHasProperty(m_context, filterObj, summaryStr.get())) {
 531         LogDebug("converting summary");
 532         JSValueRef value = JSObjectGetProperty(m_context,
 533                                                filterObj,
 534                                                summaryStr.get(),
 535                                                NULL);
 536         result->setSubjectFilter(toString(value));
 537     }
 538 }
 539
 540 void CalendarConverter::toEventFilterConvertDescription(
 541         const EventFilterPtr &result,
 542         const JSValueRef &filters)
 543 {
 544     const ScopedJSStringRef descriptionStr(JSStringCreateWithUTF8CString(
 545                                                "description"));
 546     JSObjectRef filterObj = toJSObjectRef(filters);
 547     if (JSObjectHasProperty(m_context, filterObj, descriptionStr.get())) {
 548         LogDebug("converting description");
 549         JSValueRef value = JSObjectGetProperty(m_context,
 550                                                filterObj,
 551                                                descriptionStr.get(),
 552                                                NULL);
 553         result->setDescriptionFilter(toString(value));
 554     }
 555 }
 556
 557 void CalendarConverter::toEventFilterConvertLocation(
 558         const EventFilterPtr &result,
 559         const JSValueRef &filters)
 560 {
 561     const ScopedJSStringRef locationStr(JSStringCreateWithUTF8CString(
 562                                             "location"));
 563     JSObjectRef filterObj = toJSObjectRef(filters);
 564     if (JSObjectHasProperty(m_context, filterObj, locationStr.get())) {
 565         LogDebug("converting location");
 566         JSValueRef value = JSObjectGetProperty(m_context,
 567                                                filterObj,
 568                                                locationStr.get(),
 569                                                NULL);
 570         result->setLocationFilter(toString(value));
 571     }
 572 }
 573
 574 void CalendarConverter::toEventFilterConvertCategory(
 575         const EventFilterPtr &result,
 576         const JSValueRef &filters)
 577 {
 578     const ScopedJSStringRef locationStr(JSStringCreateWithUTF8CString(
 579                                             "category"));
 580     JSObjectRef filterObj = toJSObjectRef(filters);
 581     if (JSObjectHasProperty(m_context, filterObj, locationStr.get())) {
 582         LogDebug("converting category");
 583         JSValueRef value = JSObjectGetProperty(m_context,
 584                                                filterObj,
 585                                                locationStr.get(),
 586                                                NULL);
 587         result->setCategoryFilter(toString(value));
 588     }
 589 }
 590
 591 void CalendarConverter::toEventFilterConvertStatus(
 592         const EventFilterPtr &result,
 593         const JSValueRef &filters)
 594 {
 595     const ScopedJSStringRef statusStr(JSStringCreateWithUTF8CString("status"));
 596     JSObjectRef filterObj = toJSObjectRef(filters);
 597     if (JSObjectHasProperty(m_context, filterObj, statusStr.get())) {
 598         LogDebug("converting status");
 599         JSValueRef value = JSObjectGetProperty(m_context,
 600                                                filterObj,
 601                                                statusStr.get(),
 602                                                NULL);
 603         std::vector<std::string> statuses = toVectorOfStrings(value);
 604         for (std::size_t i = 0; i < statuses.size(); ++i) {
 605             CalendarEvent::EventStatus status(toEventStatus(statuses[i]));
 606             if (status == CalendarEvent::INVALID_STATUS) {
 607                 ThrowMsg(InvalidArgumentException,
 608                          "Status filter has wrong value");
 609             }
 610             result->addStatusFilter(status);
 611         }
 612     }
 613 }
 614
 615 void CalendarConverter::toEventFilterConvertStartTime(
 616         const EventFilterPtr &result,
 617         const JSValueRef &filters)
 618 {
 619     const ScopedJSStringRef initialStartDateStr(JSStringCreateWithUTF8CString(
 620                                                     "initialStartDate"));
 621     const ScopedJSStringRef endStartDateStr(JSStringCreateWithUTF8CString(
 622                                                 "endStartDate"));
 623     JSObjectRef filterObj = toJSObjectRef(filters);
 624     if (JSObjectHasProperty(m_context, filterObj, initialStartDateStr.get()) ||
 625         JSObjectHasProperty(m_context, filterObj, endStartDateStr.get())) {
 626         LogDebug("converting startTime");
 627         JSValueRef valueStart = JSObjectGetProperty(m_context,
 628                                                     filterObj,
 629                                                     initialStartDateStr.get(),
 630                                                     NULL);
 631         JSValueRef valueEnd = JSObjectGetProperty(m_context,
 632                                                   filterObj,
 633                                                   endStartDateStr.get(),
 634                                                   NULL);
 635         //no filters
 636         if ((JSValueIsNull(m_context,
 637                            valueStart) ||
 638              JSValueIsUndefined(m_context, valueStart)) &&
 639             (JSValueIsNull(m_context,
 640                            valueEnd) ||
 641              JSValueIsUndefined(m_context, valueEnd))) {
 642             return;
 643         }
 644         //start
 645         if (!JSValueIsNull(m_context, valueStart) &&
 646             !JSValueIsUndefined(m_context, valueStart)) {
 647             result->setStartTimeMinFilter(toDateTimeT(valueStart));
 648         }
 649         //end
 650         if (!JSValueIsNull(m_context, valueEnd) &&
 651             !JSValueIsUndefined(m_context, valueEnd)) {
 652             result->setStartTimeMaxFilter(toDateTimeT(valueEnd));
 653         }
 654     }
 655 }
 656
 657 EventFilterPtr CalendarConverter::toEventFilter(const JSValueRef &filters)
 658 {
 659     LogDebug("entered");
 660     EventFilterPtr result(new EventFilter());
 661     Validator validator(m_context);
 662     if (!JSValueIsObject(m_context, filters)) {
 663         LogError("Wrong filter parameter");
 664         Throw(InvalidArgumentException);
 665     }
 666     if (!validator.checkArrayKeys(m_allowedAttributes, filters)) {
 667         LogError("Wrong filter's attribue");
 668         Throw(ConversionException);
 669     }
 670     toEventFilterConvertId(result, filters);
 671     toEventFilterConvertSummary(result, filters);
 672     toEventFilterConvertDescription(result, filters);
 673     toEventFilterConvertLocation(result, filters);
 674     toEventFilterConvertCategory(result, filters);
 675     toEventFilterConvertStatus(result, filters);
 676     toEventFilterConvertStartTime(result, filters);
 677     return result;
 678 }
 679
 680 CategoryListPtr CalendarConverter::toCategories(JSValueRef categories)
 681 {
 682     LogDebug("entered");
 683     if (JSValueIsObjectOfClass(m_context, categories,
 684                                JSCategoryArray::getClassRef())) {
 685         return JSCategoryArray::getCategories(m_context,
 686                                               toJSObjectRef(categories));
 687     }
 688     CategoryListPtr result(new CategoryList());
 689     *result = toVectorOfStrings(categories);
 690     return result;
 691 }
 692
 693 EventAttendeePtr CalendarConverter::toAttendee(JSValueRef attendee)
 694 {
 695     LogDebug("entered");
 696     EventAttendeePtr result(new EventAttendee());
 697     const ScopedJSStringRef nameStr(JSStringCreateWithUTF8CString("name"));
 698     const ScopedJSStringRef uriStr(JSStringCreateWithUTF8CString("uri"));
 699     const ScopedJSStringRef roleStr(JSStringCreateWithUTF8CString("role"));
 700     const ScopedJSStringRef statusStr(JSStringCreateWithUTF8CString("status"));
 701     const ScopedJSStringRef RSVPStr(JSStringCreateWithUTF8CString("RSVP"));
 702     const ScopedJSStringRef typeStr(JSStringCreateWithUTF8CString("type"));
 703     const ScopedJSStringRef groupStr(JSStringCreateWithUTF8CString("group"));
 704     const ScopedJSStringRef delegatorURIStr(JSStringCreateWithUTF8CString("delegatorURI"));
 705     const ScopedJSStringRef delegateURIStr(JSStringCreateWithUTF8CString("delegateURI"));
 706     const ScopedJSStringRef uidStr(JSStringCreateWithUTF8CString("uid"));
 707
 708     JSObjectRef arg = toJSObjectRef(attendee);
 709
 710     JSValueRef nameData = JSObjectGetProperty(m_context, arg, nameStr.get(), NULL);
 711     JSValueRef uriData = JSObjectGetProperty(m_context, arg, uriStr.get(), NULL);
 712     JSValueRef roleData = JSObjectGetProperty(m_context, arg, roleStr.get(), NULL);
 713     JSValueRef statusData = JSObjectGetProperty(m_context, arg, statusStr.get(), NULL);
 714     JSValueRef RSVPData = JSObjectGetProperty(m_context, arg, RSVPStr.get(), NULL);
 715     JSValueRef typeData = JSObjectGetProperty(m_context, arg, typeStr.get(), NULL);
 716     JSValueRef groupData = JSObjectGetProperty(m_context, arg, groupStr.get(), NULL);
 717     JSValueRef delegatorURIData = JSObjectGetProperty(m_context, arg, delegatorURIStr.get(), NULL);
 718     JSValueRef delegateURIData = JSObjectGetProperty(m_context, arg, delegateURIStr.get(), NULL);
 719     JSValueRef uidData = JSObjectGetProperty(m_context, arg, uidStr.get(), NULL);
 720
 721     if (!JSValueIsUndefined(m_context, nameData)) {
 722         result->setName(toString(nameData));
 723     }
 724     if (!JSValueIsUndefined(m_context, uriData)) {
 725         result->setURI(toString(uriData));
 726     }
 727     if (!JSValueIsUndefined(m_context, roleData)) {
 728         result->setRole(toEventAttendeeRole(toString(roleData)));
 729     }
 730     if (!JSValueIsUndefined(m_context, statusData)) {
 731         result->setStatus(toEventAttendeeStatus(toString(statusData)));
 732     }
 733     if (!JSValueIsUndefined(m_context, RSVPData)) {
 734         result->setRSVP(toBool(RSVPData));
 735     }
 736     if (!JSValueIsUndefined(m_context, typeData)) {
 737         result->setType(toEventAttendeeType(toString(typeData)));
 738     }
 739     if (!JSValueIsUndefined(m_context, groupData)) {
 740         result->setGroup(toString(groupData));
 741     }
 742     if (!JSValueIsUndefined(m_context, delegatorURIData)) {
 743         result->setDelegatorURI(toString(delegatorURIData));
 744     }
 745     if (!JSValueIsUndefined(m_context, delegateURIData)) {
 746         result->setDelegateURI(toString(delegateURIData));
 747     }
 748     if (!JSValueIsUndefined(m_context, uidData)) {
 749         result->setPersonId(toString(uidData));
 750     }
 751
 752     return result;
 753 }
 754
 755 EventAttendeeListPtr CalendarConverter::toVectorOfAttendees(JSValueRef attendees)
 756 {
 757     LogDebug("entered");
 758     EventAttendeeListPtr result(new EventAttendeeList());
 759
 760     std::vector<EventAttendeePtr> resultVector;
 761     JSObjectRef objArg = toJSObjectRef(attendees);
 762     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
 763     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
 764         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
 765         resultVector.push_back(toAttendee(element));
 766     }
 767
 768     *result = resultVector;
 769     return result;
 770 }
 771
 772 EventAlarmPtr CalendarConverter::toEventAlarm(JSValueRef alarm)
 773 {
 774     LogDebug("entered");
 775     EventAlarmPtr result(new EventAlarm());
 776     const ScopedJSStringRef absoluteDateStr(JSStringCreateWithUTF8CString("absoluteDate"));
 777     const ScopedJSStringRef minutesStr(JSStringCreateWithUTF8CString("minutes"));
 778     const ScopedJSStringRef daysStr(JSStringCreateWithUTF8CString("days"));
 779     const ScopedJSStringRef methodsStr(JSStringCreateWithUTF8CString("methods"));
 780
 781     JSObjectRef arg = toJSObjectRef(alarm);
 782
 783     JSValueRef absoluteDateData = JSObjectGetProperty(m_context, arg, absoluteDateStr.get(), NULL);
 784     JSValueRef minutesData = JSObjectGetProperty(m_context, arg, minutesStr.get(), NULL);
 785     JSValueRef daysData = JSObjectGetProperty(m_context, arg, daysStr.get(), NULL);
 786     JSValueRef methodsData = JSObjectGetProperty(m_context, arg, methodsStr.get(), NULL);
 787
 788     if (!JSValueIsUndefined(m_context, absoluteDateData)) {
 789         result->setAbsoluteDate(toDateTimeT(absoluteDateData));
 790     }
 791     if (!JSValueIsUndefined(m_context, minutesData)) {
 792         result->setMinutes(toLong(minutesData));
 793     }
 794     if (!JSValueIsUndefined(m_context, daysData)) {
 795         result->setDays(toLong(daysData));
 796     }
 797     if (!JSValueIsUndefined(m_context, methodsData)) {
 798         result->setMethods(toVectorOfInts(methodsData));
 799     }
 800
 801     return result;
 802 }
 803
 804 EventAlarmListPtr CalendarConverter::toVectorOfEventAlarms(JSValueRef alarms)
 805 {
 806     LogDebug("entered");
 807     EventAlarmListPtr result(new EventAlarmList());
 808
 809     std::vector<EventAlarmPtr> resultVector;
 810     JSObjectRef objArg = toJSObjectRef(alarms);
 811     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
 812     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
 813         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
 814         resultVector.push_back(toEventAlarm(element));
 815     }
 816
 817     *result = resultVector;
 818     return result;
 819 }
 820
 821 CalendarEventPtr CalendarConverter::toEvent(const JSValueRef event)
 822 {
 823     LogDebug("entered");
 824     CalendarEventPtr result(new CalendarEvent());
 825     const ScopedJSStringRef descriptionStr(JSStringCreateWithUTF8CString("description"));
 826     const ScopedJSStringRef summaryStr(JSStringCreateWithUTF8CString("summary"));
 827     const ScopedJSStringRef startTimeStr(JSStringCreateWithUTF8CString("startDate"));
 828     const ScopedJSStringRef durationStr(JSStringCreateWithUTF8CString("duration"));
 829     const ScopedJSStringRef locationStr(JSStringCreateWithUTF8CString("location"));
 830     const ScopedJSStringRef categoriesStr(JSStringCreateWithUTF8CString("categories"));
 831     const ScopedJSStringRef statusStr(JSStringCreateWithUTF8CString("status"));
 832     const ScopedJSStringRef alarmsStr(JSStringCreateWithUTF8CString("alarms"));
 833     const ScopedJSStringRef isAllDayStr(JSStringCreateWithUTF8CString("isAllDay"));
 834     const ScopedJSStringRef organizerStr(JSStringCreateWithUTF8CString("organizer"));
 835     const ScopedJSStringRef attendeesStr(JSStringCreateWithUTF8CString("attendees"));
 836     const ScopedJSStringRef latitudeStr(JSStringCreateWithUTF8CString("latitude"));
 837     const ScopedJSStringRef longitudeStr(JSStringCreateWithUTF8CString("longitude"));
 838     const ScopedJSStringRef visibilityStr(JSStringCreateWithUTF8CString("visibility"));
 839     //const ScopedJSStringRef lastModifiedDateStr(JSStringCreateWithUTF8CString("lastModifiedDate")); // read only
 840     const ScopedJSStringRef availabilityStr(JSStringCreateWithUTF8CString("availability"));
 841     const ScopedJSStringRef recurrenceRuleStr(JSStringCreateWithUTF8CString("recurrenceRule"));
 842     //const ScopedJSStringRef isDetachedStr(JSStringCreateWithUTF8CString("isDetached")); //read only
 843     //const ScopedJSStringRef attributesOfInterestStr(JSStringCreateWithUTF8CString("attributesOfInterest"));
 844     const ScopedJSStringRef priorityStr(JSStringCreateWithUTF8CString("priority"));
 845     const ScopedJSStringRef dueDateStr(JSStringCreateWithUTF8CString("dueDate"));
 846     const ScopedJSStringRef completedDateStr(JSStringCreateWithUTF8CString("completedDate"));
 847     const ScopedJSStringRef progressStr(JSStringCreateWithUTF8CString("progress"));
 848
 849     JSObjectRef arg = toJSObjectRef(event);
 850
 851     JSValueRef descriptionData = JSObjectGetProperty(m_context, arg, descriptionStr.get(), NULL);
 852     JSValueRef summaryData = JSObjectGetProperty(m_context, arg, summaryStr.get(), NULL);
 853     JSValueRef startTimeData = JSObjectGetProperty(m_context, arg, startTimeStr.get(), NULL);
 854     JSValueRef durationData = JSObjectGetProperty(m_context, arg, durationStr.get(), NULL);
 855     JSValueRef locationData = JSObjectGetProperty(m_context, arg, locationStr.get(), NULL);
 856     JSValueRef categoriesData = JSObjectGetProperty(m_context, arg, categoriesStr.get(), NULL);
 857     JSValueRef statusData = JSObjectGetProperty(m_context, arg, statusStr.get(), NULL);
 858     JSValueRef alarmsData = JSObjectGetProperty(m_context, arg, alarmsStr.get(), NULL);
 859     JSValueRef isAllDayData = JSObjectGetProperty(m_context, arg, isAllDayStr.get(), NULL);
 860     JSValueRef organizerData = JSObjectGetProperty(m_context, arg, organizerStr.get(), NULL);
 861     JSValueRef attendeesData = JSObjectGetProperty(m_context, arg, attendeesStr.get(), NULL);
 862     JSValueRef latitudeData = JSObjectGetProperty(m_context, arg, latitudeStr.get(), NULL);
 863     JSValueRef longitudeData = JSObjectGetProperty(m_context, arg, longitudeStr.get(), NULL);
 864     JSValueRef visibilityData = JSObjectGetProperty(m_context, arg, visibilityStr.get(), NULL);
 865     //JSValueRef lastModifiedDateData = JSObjectGetProperty(m_context, arg, lastModifiedDateStr.get(), NULL); // read only
 866     JSValueRef availabilityData = JSObjectGetProperty(m_context, arg, availabilityStr.get(), NULL);
 867     JSValueRef recurrenceRuleData = JSObjectGetProperty(m_context, arg, recurrenceRuleStr.get(), NULL);
 868     //JSValueRef isDetachedData = JSObjectGetProperty(m_context, arg, isDetachedStr.get(), NULL); // read only
 869     //JSValueRef attributesOfInterestData = JSObjectGetProperty(m_context, arg, attributesOfInterestStr.get(), NULL);
 870     JSValueRef priorityData = JSObjectGetProperty(m_context, arg, priorityStr.get(), NULL);
 871     JSValueRef dueDateData = JSObjectGetProperty(m_context, arg, dueDateStr.get(), NULL);
 872     JSValueRef completedDateData = JSObjectGetProperty(m_context, arg, completedDateStr.get(), NULL);
 873     JSValueRef progressData = JSObjectGetProperty(m_context, arg, progressStr.get(), NULL);
 874
 875     TimeUtilConverter timeUtilConverter(m_context);
 876
 877     if (!JSValueIsUndefined(m_context, descriptionData)) {
 878         result->setDescription(toString(descriptionData));
 879     }
 880     if (!JSValueIsUndefined(m_context, summaryData)) {
 881         result->setSubject(toString(summaryData));
 882     }
 883     //It's important to set startTime before duration to set end date by time_t
 884     if (!JSValueIsUndefined(m_context, startTimeData)) {
 885         result->setStartTime(timeUtilConverter.toTZDateTimeT(startTimeData));
 886         result->setTimeZone(timeUtilConverter.getPropertiesInTZDate(startTimeData).timezone);
 887     } else {
 888         //set default value, current local time.
 889         if(m_calendarType == CalendarEvent::EVENT_TYPE) {
 890             result->setStartTime(std::time(NULL));
 891         }
 892     }
 893     if (!JSValueIsUndefined(m_context, durationData)) {
 894         long length = timeUtilConverter.getDurationLength(durationData, NULL);
 895         int unit = timeUtilConverter.getDurationUnit(durationData, NULL);
 896         LogInfo("duration length: "<<length<<", unit "<<unit);
 897         if (length < 0) {
 898             Throw(ConversionException);
 899         }
 900         if( SECONDS_UNIT==unit ) {
 901             result->setEndTime(result->getStartTime() + length);
 902         } else if ( MINUTES_UNIT==unit ) {
 903             result->setEndTime(result->getStartTime() + length*60);
 904         } else if ( HOURS_UNIT==unit ) {
 905             result->setEndTime(result->getStartTime() + length*60*60);
 906         } else if ( DAYS_UNIT==unit ) {
 907             result->setEndTime(result->getStartTime() + length*24*60*60);
 908         } else {
 909             Throw(ConversionException);
 910         }
 911     } else {
 912         //default duration is 3600 seconds, or 1 hour.
 913         LogInfo("duration length is 3600");
 914         result->setEndTime(result->getStartTime() + 3600);
 915     }
 916     if (!JSValueIsUndefined(m_context, locationData)) {
 917         result->setLocation(toString(locationData));
 918     }
 919     if (!JSValueIsUndefined(m_context, categoriesData)) {
 920         CategoryListPtr categories(new CategoryList());
 921         *categories = toVectorOfStrings(categoriesData);
 922         result->setCategories(categories);
 923     }
 924     if (!JSValueIsUndefined(m_context, statusData)) {
 925         result->setStatus(toEventStatus(toString(statusData)));
 926     } else {
 927         result->setStatus(CalendarEvent::CONFIRMED_STATUS);
 928     }
 929     if (!JSValueIsUndefined(m_context, alarmsData)) {
 930         EventAlarmListPtr alarms = toVectorOfEventAlarms(alarmsData);
 931         std::vector<CalendarEvent::EventAlarmType> alarmsType;
 932         std::vector<long> alarmsTick;
 933         // Set the multiple alarms.
 934         for( unsigned int i=0; i<alarms->size(); i++) {
 935             EventAlarmPtr theAlarm = alarms->at(i);
 936             alarmsType.push_back(toEventAlarmType(theAlarm->getMethods().at(0)));
 937             if( 0 < theAlarm->getAbsoluteDate() ) {
 938                 alarmsTick.push_back(theAlarm->getAbsoluteDate()/60); // minutes only in platform.
 939             } else {
 940                 alarmsTick.push_back(theAlarm->getMinutes() + theAlarm->getDays()*24*60);
 941             }
 942         }
 943         result->setAlarmsType(alarmsType);
 944         result->setAlarmsTick(alarmsTick);
 945     }
 946     if (!JSValueIsUndefined(m_context, isAllDayData)) {
 947         result->setIsAllDay(toBool(isAllDayData));
 948     }
 949     if (!JSValueIsUndefined(m_context, organizerData)) {
 950         result->setOrganizer(toString(organizerData));
 951     }
 952     if (!JSValueIsUndefined(m_context, attendeesData)) {
 953         EventAttendeeListPtr attendees = toVectorOfAttendees(attendeesData);
 954         result->setAttendees(attendees);
 955     }
 956     if (!JSValueIsUndefined(m_context, latitudeData)) {
 957         result->setLatitude(toDouble(latitudeData));
 958     }
 959     if (!JSValueIsUndefined(m_context, longitudeData)) {
 960         result->setLongitude(toDouble(longitudeData));
 961     }
 962     if (!JSValueIsUndefined(m_context, visibilityData)) {
 963         result->setVisibility(toEventVisibility(toString(visibilityData)));
 964     }
 965     /* This feature is read only.
 966     if (!JSValueIsUndefined(m_context, lastModifiedDateData)) {
 967         result->setLastModifiedDate(toDateTimeT(lastModifiedDateData));
 968     } */
 969     if (!JSValueIsUndefined(m_context, availabilityData)) {
 970         result->setAvailability(toEventAvailability(toString(availabilityData)));
 971     }
 972     if (!JSValueIsUndefined(m_context, recurrenceRuleData)) {
 973         result->setRecurrenceRule(toEventRecurrenceRule(recurrenceRuleData));
 974     }
 975     /* attributesOfInterest is not supported
 976     if (!JSValueIsUndefined(m_context, attributesOfInterestData)) {
 977         AttributeList alist = toVectorOfStrings(attributesOfInterestData);
 978         AttributeListPtr attributesOfInterest = AttributeListPtr(new AttributeList());
 979         *attributesOfInterest = alist;
 980         result->setAttributesOfInterest(attributesOfInterest);
 981     }*/
 982     if (!JSValueIsUndefined(m_context, priorityData)) {
 983         result->setPriority(toTaskPriority(toString(priorityData)));
 984     }
 985     if (!JSValueIsUndefined(m_context, dueDateData)) {
 986         result->setEndTime(timeUtilConverter.toTZDateTimeT(dueDateData));
 987     }
 988     if (!JSValueIsUndefined(m_context, completedDateData)) {
 989         result->setCompletedDate(timeUtilConverter.toTZDateTimeT(completedDateData));
 990     }
 991     if (!JSValueIsUndefined(m_context, progressData)) {
 992         result->setProgress(toInt(progressData));
 993     }
 994
 995     return result;
 996 }
 997
 998 CalendarEventListPtr CalendarConverter::toVectorOfEvents(JSValueRef events)
 999 {
1000     LogDebug("entered");
1001     CalendarEventListPtr result(new CalendarEventList());
1002
1003     std::vector<CalendarEventPtr> resultVector;
1004     JSObjectRef objArg = toJSObjectRef(events);
1005     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
1006     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
1007         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
1008         JSObjectRef arg = JSValueToObject(m_context, element, NULL);
1009         resultVector.push_back(JSCalendarItem::getPrivateObject(arg));
1010     }
1011
1012     *result = resultVector;
1013     return result;
1014 }
1015
1016 CalendarEventListPtr CalendarConverter::toVectorOfEventsFromProperty(JSValueRef events)
1017 {
1018     LogDebug("entered");
1019     CalendarEventListPtr result(new CalendarEventList());
1020
1021     std::vector<CalendarEventPtr> resultVector;
1022     JSObjectRef objArg = toJSObjectRef(events);
1023     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
1024     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
1025         resultVector.push_back(toEvent(JSGetArrayElement(m_context, objArg, i)));
1026     }
1027
1028     *result = resultVector;
1029     return result;
1030 }
1031
1032 EventIdPtr CalendarConverter::toEventId(JSValueRef eventId)
1033 {
1034     LogDebug("entered");
1035     EventIdPtr result(new EventId());
1036     const ScopedJSStringRef uidStr(JSStringCreateWithUTF8CString("uid"));
1037     const ScopedJSStringRef recurrenceIdStr(JSStringCreateWithUTF8CString("recurrenceId"));
1038
1039     JSObjectRef arg = toJSObjectRef(eventId);
1040
1041     JSValueRef uidData = JSObjectGetProperty(m_context, arg, uidStr.get(), NULL);
1042     JSValueRef recurrenceIdData = JSObjectGetProperty(m_context, arg, recurrenceIdStr.get(), NULL);
1043
1044     if (!JSValueIsUndefined(m_context, uidData)) {
1045         result->setUId(toString(uidData));
1046     }
1047     if (!JSValueIsUndefined(m_context, recurrenceIdData)) {
1048         TimeUtilConverter timeUtilConverter(m_context);
1049         result->setRecurrenceId(timeUtilConverter.toTZDateTimeT(recurrenceIdData));
1050    }
1051
1052     return result;
1053 }
1054
1055 EventIdListPtr CalendarConverter::toVectorOfEventIds(JSValueRef eventIds)
1056 {
1057     LogDebug("entered");
1058     EventIdListPtr result(new EventIdList());
1059
1060     std::vector<EventIdPtr> resultVector;
1061     JSObjectRef objArg = toJSObjectRef(eventIds);
1062     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
1063     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
1064         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
1065         resultVector.push_back(toEventId(element));
1066     }
1067
1068     *result = resultVector;
1069     return result;
1070 }
1071
1072 std::vector<time_t> CalendarConverter::toVectorOfTimeTFromTZDate(JSValueRef dates)
1073 {
1074     LogDebug("entered");
1075     std::vector<time_t>  result;
1076     TimeUtilConverter converter(m_context);
1077
1078     JSObjectRef objArg = toJSObjectRef(dates);
1079     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
1080     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
1081         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
1082         result.push_back(converter.toTZDateTimeT(element));
1083     }
1084
1085     return result;
1086 }
1087
1088 std::string CalendarConverter::toTizenValue(Api::Calendar::CalendarEvent::TaskPriority abstractValue) const
1089 {
1090     switch (abstractValue) {
1091     case CalendarEvent::HIGH_PRIORITY:
1092         return TIZEN_CALENDAR_PROPERTY_HIGH_PRIORITY;
1093     case CalendarEvent::MEDIUM_PRIORITY:
1094         return TIZEN_CALENDAR_PROPERTY_MEDIUM_PRIORITY;
1095     case CalendarEvent::LOW_PRIORITY:
1096         return TIZEN_CALENDAR_PROPERTY_LOW_PRIORITY;
1097     default:
1098         break;
1099     }
1100     return TIZEN_CALENDAR_PROPERTY_LOW_PRIORITY;
1101 }
1102
1103 CalendarEvent::TaskPriority CalendarConverter::toTaskPriority(std::string priority) const
1104 {
1105     if (!priority.compare(TIZEN_CALENDAR_PROPERTY_HIGH_PRIORITY))
1106         return CalendarEvent::HIGH_PRIORITY;
1107     else if (!priority.compare(TIZEN_CALENDAR_PROPERTY_MEDIUM_PRIORITY))
1108         return CalendarEvent::MEDIUM_PRIORITY;
1109     else if (!priority.compare(TIZEN_CALENDAR_PROPERTY_LOW_PRIORITY))
1110         return CalendarEvent::LOW_PRIORITY;
1111
1112     return CalendarEvent::LOW_PRIORITY;
1113 }
1114
1115 CalendarEvent::CalendarType CalendarConverter::toCalendarType(std::string type) const
1116 {
1117     if (!type.compare(TIZEN_CALENDAR_PROPERTY_TYPE_EVENT))
1118         return CalendarEvent::EVENT_TYPE;
1119     else if (!type.compare(TIZEN_CALENDAR_PROPERTY_TYPE_TASK))
1120         return CalendarEvent::TASK_TYPE;
1121     else
1122         Throw(ConversionException);
1123
1124     return CalendarEvent::EVENT_TYPE;
1125 }
1126
1127 CalendarEvent::VObjectFormat CalendarConverter::toVObjectFormat(std::string format) const
1128 {
1129     if (!format.compare(TIZEN_CALENDAR_PROPERTY_VCALENDAR_20_FORMAT))
1130         return CalendarEvent::ICALENDAR_20;
1131     else if (!format.compare(TIZEN_CALENDAR_PROPERTY_VCALENDAR_10_FORMAT))
1132         return CalendarEvent::VCALENDAR_10;
1133
1134     return CalendarEvent::ICALENDAR_20;
1135 }
1136
1137 }
1138 }
1139 }