#include "JSCalendarAttendee.h"
#include "JSCalendarRecurrenceRule.h"
#include "JSCalendarAlarm.h"
+#include "JSStringArray.h"
+#include "JSNumberArray.h"
+
#include <Tizen/TimeUtil/TimeUtilConverter.h>
#include <API/TimeUtil/DurationProperties.h>
#include <Tizen/Tizen/JSSimpleCoordinates.h>
return toJSValueRef_(arg, &CalendarConverter::toJSValueRefCalendar, this);
}
-CalendarEvent::EventAlarmType CalendarConverter::toEventAlarmType(std::string alarmMethod)
+JSValueRef CalendarConverter::toJSValueRef(const StringArrayPtr &arg)
+{
+ return JSStringArray::createArray(m_context, arg);
+}
+
+JSValueRef CalendarConverter::toJSValueRef(const NumberArrayPtr &arg)
+{
+ return JSNumberArray::createArray(m_context, arg);
+}
+
+StringArrayPtr CalendarConverter::toStringArray(const JSValueRef &jsValue)
+{
+ if(JSStringArray::isObjectOfClass(m_context, jsValue))
+ return JSStringArray::getStringArray(m_context, jsValue);
+
+ if(!JSIsArrayValue(m_context, jsValue))
+ ThrowMsg(WrtDeviceApis::Commons::ConversionException, "StringArray is not array.");
+
+ StringArrayPtr result = StringArrayPtr(new StringArray());
+ JSObjectRef jsObject = toJSObjectRef(jsValue);
+ for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
+ JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
+ result->push_back(toString(element));
+ }
+ return result;
+}
+
+NumberArrayPtr CalendarConverter::toNumberArray(const JSValueRef &jsValue)
+{
+ LogDebug("entered");
+ if(JSNumberArray::isObjectOfClass(m_context, jsValue))
+ return JSNumberArray::getNumberArray(m_context, jsValue);
+
+ if(!JSIsArrayValue(m_context, jsValue))
+ ThrowMsg(WrtDeviceApis::Commons::ConversionException, "NumberArray is not array.");
+
+ TimeUtilConverter timeConverter(m_context);
+
+ NumberArrayPtr result = NumberArrayPtr(new NumberArray());
+ JSObjectRef jsObject = toJSObjectRef(jsValue);
+ for (std::size_t i = 0; i < JSGetArrayLength(m_context, jsObject); ++i) {
+ JSValueRef element = JSGetArrayElement(m_context, jsObject, i);
+ result->push_back((long long int) (timeConverter.getTimeInMilliseconds(element)/1000));
+ }
+ LogInfo("First exception: "<<result->at(0));
+ return result;
+}
+
+EventAlarm::EventAlarmType CalendarConverter::toEventAlarmType(std::string alarmMethod)
const
{
if (!alarmMethod.compare(TIZEN_CALENDAR_PROPERTY_DISPLAY_ALARM))
- return CalendarEvent::SILENT_ALARM;
+ return EventAlarm::SILENT_ALARM;
else if (!alarmMethod.compare(TIZEN_CALENDAR_PROPERTY_SOUND_ALARM))
- return CalendarEvent::SOUND_ALARM;
+ return EventAlarm::SOUND_ALARM;
else
ThrowMsg(ConversionException, "Invalid alarm type.");
- return CalendarEvent::UNDEFINED_ALARM_TYPE;
+ return EventAlarm::UNDEFINED_ALARM_TYPE;
}
-std::string CalendarConverter::toTizenValue(CalendarEvent::EventAlarmType abstractValue) const
+std::string CalendarConverter::toTizenValue(EventAlarm::EventAlarmType abstractValue) const
{
switch (abstractValue) {
- case CalendarEvent::SILENT_ALARM:
+ case EventAlarm::SILENT_ALARM:
return TIZEN_CALENDAR_PROPERTY_DISPLAY_ALARM;
- case CalendarEvent::SOUND_ALARM:
+ case EventAlarm::SOUND_ALARM:
return TIZEN_CALENDAR_PROPERTY_SOUND_ALARM;
default:
break;
result->setDaysOfTheMonth(toVectorOfInts(daysOfTheMonthData));
}*/
if (!JSValueIsUndefined(m_context, daysOfTheWeekData)) {
- result->setDaysOfTheWeek(toVectorOfStrings(daysOfTheWeekData));
+ result->setDaysOfTheWeek(toStringArray(daysOfTheWeekData));
}
/*if (!JSValueIsUndefined(m_context, daysOfTheYearData)) {
result->setDaysOfTheYear(toVectorOfInts(daysOfTheYearData));
//result->setSetPosition(toBool(setPositionData));
}
if (!JSValueIsUndefined(m_context, exceptionsData)) {
- result->setExceptions(toVectorOfTimeFromTZDate(exceptionsData));
+ result->setExceptions(toNumberArray(exceptionsData));
}
return result;
ThrowMsg(ConversionException, "Not a function.");
}
-CategoryListPtr CalendarConverter::toCategories(JSValueRef categories)
+StringArrayPtr CalendarConverter::toCategories(JSValueRef categories)
{
LogDebug("entered");
- CategoryListPtr result(new CategoryList());
+ StringArrayPtr result(new StringArray());
*result = toVectorOfStrings(categories);
return result;
}
}
if (!JSValueIsUndefined(m_context, methodData)) {
std::string method = toString(methodData);
- std::vector<CalendarEvent::EventAlarmType> convertedMethods;
+ std::vector<EventAlarm::EventAlarmType> convertedMethods;
convertedMethods.push_back(toEventAlarmType(method));
result->setMethods(convertedMethods);
}
if (!JSValueIsUndefined(m_context, descriptionData)) {
result->setDescription(toString(descriptionData));
}
+
if (!JSValueIsUndefined(m_context, summaryData)) {
result->setSubject(toString(summaryData));
}
+
//It's important to set startTime before duration to set end date
if (!JSValueIsUndefined(m_context, startTimeData)) {
result->setStartTime((long long int) (timeUtilConverter.getTimeInMilliseconds(startTimeData)/1000));
result->setTimeZone(timeUtilConverter.getPropertiesInTZDate(startTimeData).timezone);
LogInfo("start time converted from TZDate: "<<result->getStartTime()<<", time zone: "<<result->getTimeZone());
} else {
+
//set default value, current local time.
if(m_calendarType == CalendarEvent::EVENT_TYPE) {
//result->setStartTime(std::time(NULL));
}
}
+
if (!JSValueIsUndefined(m_context, durationData)) {
long length = timeUtilConverter.getDurationLength(durationData);
int unit = timeUtilConverter.getDurationUnit(durationData);
result->setLocation(toString(locationData));
}
if (!JSValueIsUndefined(m_context, categoriesData)) {
- CategoryListPtr categories(new CategoryList());
+ StringArrayPtr categories(new StringArray());
*categories = toVectorOfStrings(categoriesData);
result->setCategories(categories);
}
+
if (!JSValueIsUndefined(m_context, statusData)) {
result->setStatus(toEventStatus(toString(statusData)));
} else {
}
if (!JSValueIsUndefined(m_context, 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 {
- long tick;
- long length = theAlarm->getDuration().length;
- switch(theAlarm->getDuration().unit) {
- case TizenApis::Api::TimeUtil::MSECS_UNIT:
- tick = length/(1000*60);
- break;
- case TizenApis::Api::TimeUtil::SECONDS_UNIT:
- tick = length/60;
- break;
- case TizenApis::Api::TimeUtil::MINUTES_UNIT:
- tick = length;
- break;
- case TizenApis::Api::TimeUtil::HOURS_UNIT:
- tick = length*60;
- break;
- case TizenApis::Api::TimeUtil::DAYS_UNIT:
- tick = length*60*24;
- break;
- default:
- ThrowMsg(ConversionException, "Wrong alarm unit type.");
- }
-
- alarmsTick.push_back(tick);
- }
- }
- result->setAlarmsType(alarmsType);
- result->setAlarmsTick(alarmsTick);
- result->setAlarmsDescription(alarmsDescription);
+ result->setAlarms(alarms);
}
if (!JSValueIsUndefined(m_context, isAllDayData)) {
result->setIsAllDay(toBool(isAllDayData));
result->setPriority(toTaskPriority(toString(priorityData)));
}
if (!JSValueIsUndefined(m_context, endDateData)) {
+ if( result->getTimeZone().empty() ) {
+ result->setTimeZone(timeUtilConverter.getPropertiesInTZDate(endDateData).timezone);
+ }
result->setEndTime((long long int) (timeUtilConverter.getTimeInMilliseconds(endDateData)/1000));
}
if (!JSValueIsUndefined(m_context, dueDateData)) {
+ if( result->getTimeZone().empty() ) {
+ result->setTimeZone(timeUtilConverter.getPropertiesInTZDate(dueDateData).timezone);
+ }
result->setEndTime((long long int) (timeUtilConverter.getTimeInMilliseconds(dueDateData)/1000));
}
if (!JSValueIsUndefined(m_context, completedDateData)) {
+ if( result->getTimeZone().empty() ) {
+ result->setTimeZone(timeUtilConverter.getPropertiesInTZDate(completedDateData).timezone);
+ }
result->setCompletedDate((long long int) (timeUtilConverter.getTimeInMilliseconds(completedDateData)/1000));
}
if (!JSValueIsUndefined(m_context, progressData)) {
result->setProgress(toInt(progressData));
}
+ LogDebug("timezone: "<<result->getTimeZone());
return result;
}
projects / framework / web / wrt-plugins-tizen.git / blobdiff