src/Calendar/CalendarConverter.cpp

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