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