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