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