Beta merge 2

[profile/ivi/wrt-plugins-tizen.git] / src / standards / Tizen / Calendar / CalendarConverter.cpp

diff --git a/src/standards/Tizen/Calendar/CalendarConverter.cpp b/src/standards/Tizen/Calendar/CalendarConverter.cpp
index 36dd0df..7d76c41 100755 (executable)
--- a/src/standards/Tizen/Calendar/CalendarConverter.cpp
+++ b/src/standards/Tizen/Calendar/CalendarConverter.cpp
@@ -20,14 +20,14 @@
 #include <CommonsJavaScript/JSUtils.h>
 #include "JSCalendarItem.h"
 #include "JSCalendarItemProperties.h"
-#include "JSEventId.h"
+#include "JSCalendarEventId.h"
 #include "JSCalendarItemGeo.h"
 #include "CalendarConverter.h"
 #include "JSCalendar.h"
 #include "JSCalendarManager.h"
-#include "JSAttendee.h"
-#include "JSRecurrenceRule.h"
-#include "JSEventAlarm.h"
+#include "JSCalendarAttendee.h"
+#include "JSCalendarRecurrenceRule.h"
+#include "JSCalendarAlarm.h"
 #include <Tizen/TimeUtil/TimeUtilConverter.h>
 #include "API/TimeUtil/DurationProperties.h"
 
@@ -79,11 +79,6 @@ JSValueRef CalendarConverter::toJSValueRef(const CalendarEventListPtr &arg)
     return toJSValueRef_(*arg, &CalendarConverter::toJSValueRefItem, this);
 }
 
-JSValueRef CalendarConverter::toJSValueRefItemProperties(const CalendarEventPtr& arg)
-{
-    return JSUtils::makeObject(m_context, JSCalendarItemProperties::getClassRef(), arg);
-}
-
 JSValueRef CalendarConverter::toJSValueRefCalendar(const ICalendarPtr& arg)
 {
     CalendarPrivObject *priv = new CalendarPrivObject(m_context, arg);
@@ -95,20 +90,10 @@ JSValueRef CalendarConverter::toJSValueRef(const std::vector<ICalendarPtr> &arg)
     return toJSValueRef_(arg, &CalendarConverter::toJSValueRefCalendar, this);
 }
 
-JSValueRef CalendarConverter::toJSValueRef(const EventIdPtr& arg)
-{
-    return JSUtils::makeObject(m_context, JSEventId::getClassRef(), arg);
-}
-
-JSValueRef CalendarConverter::toJSValueRef(const CalendarItemGeoPtr& arg)
-{
-    return JSUtils::makeObject(m_context, JSCalendarItemGeo::getClassRef(), arg);
-}
-
 CalendarEvent::EventAlarmType CalendarConverter::toEventAlarmType(std::string alarmMethod)
 const
 {
-    if (!alarmMethod.compare(TIZEN_CALENDAR_PROPERTY_SILENT_ALARM))
+    if (!alarmMethod.compare(TIZEN_CALENDAR_PROPERTY_DISPLAY_ALARM))
         return CalendarEvent::SILENT_ALARM;
     else if (!alarmMethod.compare(TIZEN_CALENDAR_PROPERTY_SOUND_ALARM))
         return CalendarEvent::SOUND_ALARM;
@@ -122,7 +107,7 @@ std::string CalendarConverter::toTizenValue(CalendarEvent::EventAlarmType abstra
 {
     switch (abstractValue) {
     case CalendarEvent::SILENT_ALARM:
-        return TIZEN_CALENDAR_PROPERTY_SILENT_ALARM;
+        return TIZEN_CALENDAR_PROPERTY_DISPLAY_ALARM;
     case CalendarEvent::SOUND_ALARM:
         return TIZEN_CALENDAR_PROPERTY_SOUND_ALARM;
     default:
@@ -253,7 +238,7 @@ EventRecurrenceRulePtr CalendarConverter::toEventRecurrenceRule(JSValueRef rrule
         if (!JSValueIsNull(m_context, untilDateData)) {
             result->setEndDate(toDateTimeT(untilDateData));
         } else {
-            result->resetEndDate();
+            result->setEndDate(0);
         }
     }
     if (!JSValueIsUndefined(m_context, occurrenceCountData)) {
@@ -675,7 +660,7 @@ EventAttendeePtr CalendarConverter::toAttendee(JSValueRef attendee)
     const ScopedJSStringRef groupStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_GROUP));
     const ScopedJSStringRef delegatorURIStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_DELEGATORURI));
     const ScopedJSStringRef delegateURIStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_DELEGATEURI));
-    const ScopedJSStringRef uidStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_UID));
+    const ScopedJSStringRef contactRefStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_CONTACT_REF));
 
     JSObjectRef arg = toJSObjectRef(attendee);
 
@@ -688,7 +673,7 @@ EventAttendeePtr CalendarConverter::toAttendee(JSValueRef attendee)
     JSValueRef groupData = JSObjectGetProperty(m_context, arg, groupStr.get(), NULL);
     JSValueRef delegatorURIData = JSObjectGetProperty(m_context, arg, delegatorURIStr.get(), NULL);
     JSValueRef delegateURIData = JSObjectGetProperty(m_context, arg, delegateURIStr.get(), NULL);
-    JSValueRef uidData = JSObjectGetProperty(m_context, arg, uidStr.get(), NULL);
+    JSValueRef contactRefData = JSObjectGetProperty(m_context, arg, contactRefStr.get(), NULL);
 
     if (!JSValueIsUndefined(m_context, nameData)) {
         result->setName(toString(nameData));
@@ -717,14 +702,14 @@ EventAttendeePtr CalendarConverter::toAttendee(JSValueRef attendee)
     if (!JSValueIsUndefined(m_context, delegateURIData)) {
         result->setDelegateURI(toString(delegateURIData));
     }
-    if (!JSValueIsUndefined(m_context, uidData)) {
-        result->setPersonId(toString(uidData));
+    if (!JSValueIsUndefined(m_context, contactRefData)) {
+        result->setPersonId(toString(contactRefData));
     }
 
     return result;
 }
 
-EventAttendeeListPtr CalendarConverter::toVectorOfAttendees(JSValueRef attendees)
+EventAttendeeListPtr CalendarConverter::toVectorOfAttendeesFromDictionary(JSValueRef attendees)
 {
     LogDebug("entered");
     EventAttendeeListPtr result(new EventAttendeeList());
@@ -741,19 +726,38 @@ EventAttendeeListPtr CalendarConverter::toVectorOfAttendees(JSValueRef attendees
     return result;
 }
 
+EventAttendeeListPtr CalendarConverter::toVectorOfAttendeesFromReference(JSValueRef attendees)
+{
+    LogDebug("entered");
+    EventAttendeeListPtr result(new EventAttendeeList());
+
+    std::vector<EventAttendeePtr> resultVector;
+    JSObjectRef objArg = toJSObjectRef(attendees);
+    LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
+    for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
+        JSValueRef element = JSGetArrayElement(m_context, objArg, i);
+        resultVector.push_back(JSCalendarAttendee::getPrivateObject(JSValueToObject(m_context, element, NULL)));
+    }
+
+    *result = resultVector;
+    return result;
+}
+
 EventAlarmPtr CalendarConverter::toEventAlarm(JSValueRef alarm)
 {
     LogDebug("entered");
     EventAlarmPtr result(new EventAlarm());
     const ScopedJSStringRef absoluteDateStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ALARM_ABSOLUTE_DATE));
     const ScopedJSStringRef beforeStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ALARM_BEFORE));
-    const ScopedJSStringRef methodsStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ALARM_METHODS));
+    const ScopedJSStringRef methodStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ALARM_METHOD));
+    const ScopedJSStringRef descriptionStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ALARM_DESCRIPTION));
 
     JSObjectRef arg = toJSObjectRef(alarm);
 
     JSValueRef absoluteDateData = JSObjectGetProperty(m_context, arg, absoluteDateStr.get(), NULL);
     JSValueRef beforeData = JSObjectGetProperty(m_context, arg, beforeStr.get(), NULL);
-    JSValueRef methodsData = JSObjectGetProperty(m_context, arg, methodsStr.get(), NULL);
+    JSValueRef methodData = JSObjectGetProperty(m_context, arg, methodStr.get(), NULL);
+    JSValueRef descriptionData = JSObjectGetProperty(m_context, arg, descriptionStr.get(), NULL);
 
     if (!JSValueIsUndefined(m_context, absoluteDateData)) {
         TimeUtilConverter timeConverter(m_context);
@@ -763,19 +767,20 @@ EventAlarmPtr CalendarConverter::toEventAlarm(JSValueRef alarm)
         TimeUtilConverter timeConverter(m_context);
         result->setDuration(timeConverter.getDurationPropertis(beforeData));
     }
-    if (!JSValueIsUndefined(m_context, methodsData)) {
-        std::vector<std::string> methods = toVectorOfStrings(methodsData);
+    if (!JSValueIsUndefined(m_context, methodData)) {
+        std::string method = toString(methodData);
         std::vector<CalendarEvent::EventAlarmType> convertedMethods;
-        for (unsigned int i=0; i<methods.size(); i++) {
-            convertedMethods.push_back(toEventAlarmType(methods[i]));
-        }
+        convertedMethods.push_back(toEventAlarmType(method));
         result->setMethods(convertedMethods);
     }
+    if (!JSValueIsUndefined(m_context, descriptionData)) {
+        result->setDescription(toString(descriptionData));
+    }
 
     return result;
 }
 
-EventAlarmListPtr CalendarConverter::toVectorOfEventAlarms(JSValueRef alarms)
+EventAlarmListPtr CalendarConverter::toVectorOfEventAlarmsFromDictionary(JSValueRef alarms)
 {
     LogDebug("entered");
     EventAlarmListPtr result(new EventAlarmList());
@@ -792,6 +797,23 @@ EventAlarmListPtr CalendarConverter::toVectorOfEventAlarms(JSValueRef alarms)
     return result;
 }
 
+EventAlarmListPtr CalendarConverter::toVectorOfEventAlarmsFromReference(JSValueRef alarms)
+{
+    LogDebug("entered");
+    EventAlarmListPtr result(new EventAlarmList());
+
+    std::vector<EventAlarmPtr> resultVector;
+    JSObjectRef objArg = toJSObjectRef(alarms);
+    LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
+    for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
+        JSValueRef element = JSGetArrayElement(m_context, objArg, i);
+        resultVector.push_back(JSCalendarAlarm::getPrivateObject(JSValueToObject(m_context, element, NULL)));
+    }
+
+    *result = resultVector;
+    return result;
+}
+
 CalendarEventPtr CalendarConverter::toEvent(const JSValueRef event)
 {
     LogDebug("entered");
@@ -890,12 +912,16 @@ CalendarEventPtr CalendarConverter::toEvent(const JSValueRef event)
         result->setStatus(CalendarEvent::CONFIRMED_STATUS);
     }
     if (!JSValueIsUndefined(m_context, alarmsData)) {
-        EventAlarmListPtr alarms = toVectorOfEventAlarms(alarmsData);
+        EventAlarmListPtr alarms = toVectorOfEventAlarmsFromReference(alarmsData);
         std::vector<CalendarEvent::EventAlarmType> alarmsType;
         std::vector<long> alarmsTick;
+        std::vector<std::string> alarmsDescription;
+
         for( unsigned int i=0; i<alarms->size(); i++) {
             EventAlarmPtr theAlarm = alarms->at(i);
             alarmsType.push_back(theAlarm->getMethods().at(0));
+            alarmsDescription.push_back(theAlarm->getDescription());
+
             if( 0 < theAlarm->getAbsoluteDate() ) {
                 alarmsTick.push_back(theAlarm->getAbsoluteDate()/60); // minutes only in platform.
             } else {
@@ -934,7 +960,7 @@ CalendarEventPtr CalendarConverter::toEvent(const JSValueRef event)
         result->setOrganizer(toString(organizerData));
     }
     if (!JSValueIsUndefined(m_context, attendeesData)) {
-        EventAttendeeListPtr attendees = toVectorOfAttendees(attendeesData);
+        EventAttendeeListPtr attendees = toVectorOfAttendeesFromReference(attendeesData);
         result->setAttendees(attendees);
     }
     if (!JSValueIsUndefined(m_context, geolocationData)) {
@@ -947,7 +973,7 @@ CalendarEventPtr CalendarConverter::toEvent(const JSValueRef event)
         result->setAvailability(toEventAvailability(toString(availabilityData)));
     }
     if (!JSValueIsUndefined(m_context, recurrenceRuleData)) {
-        result->setRecurrenceRule(toEventRecurrenceRule(recurrenceRuleData));
+        result->setRecurrenceRule(JSCalendarRecurrenceRule::getPrivateObject(JSValueToObject(m_context, recurrenceRuleData, NULL)));
     }
     if (!JSValueIsUndefined(m_context, priorityData)) {
         result->setPriority(toTaskPriority(toString(priorityData)));
@@ -1054,7 +1080,9 @@ EventIdListPtr CalendarConverter::toVectorOfEventIds(JSValueRef eventIds)
     LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
     for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
         JSValueRef element = JSGetArrayElement(m_context, objArg, i);
-        resultVector.push_back(toEventId(element));
+        EventIdPtr idPtr = JSCalendarEventId::getPrivateObject(JSValueToObject(m_context, element, NULL));
+        idPtr->setCalendarType(CalendarEvent::EVENT_TYPE);
+        resultVector.push_back(idPtr);
     }
 
     *result = resultVector;