#include <dpl/log/log.h>
#include <CommonsJavaScript/Validator.h>
#include <CommonsJavaScript/JSUtils.h>
-#include "JSCalendarItem.h"
#include "JSCalendarEvent.h"
#include "JSCalendarTask.h"
#include "JSCalendarItemProperties.h"
#include "JSCalendarEventId.h"
-#include "JSCalendarItemGeo.h"
#include "CalendarConverter.h"
#include "JSCalendar.h"
#include "JSCalendarManager.h"
#include "JSCalendarRecurrenceRule.h"
#include "JSCalendarAlarm.h"
#include <Tizen/TimeUtil/TimeUtilConverter.h>
-#include "API/TimeUtil/DurationProperties.h"
+#include <API/TimeUtil/DurationProperties.h>
+#include <Tizen/Tizen/JSSimpleCoordinates.h>
+#include <Tizen/Contact/ContactConverter.h>
using namespace TizenApis::Api::Calendar;
using namespace WrtDeviceApis::Commons;
namespace Tizen1_0 {
namespace Calendar {
-std::vector<std::string> CalendarConverter::m_allowedAttributes;
-
CalendarConverter::CalendarConverter(JSContextRef context, CalendarEvent::CalendarType calendarType) : Converter(context)
{
LogDebug("entered");
m_calendarType = calendarType;
-
- // for WAC style search filter
- if (m_allowedAttributes.size() == 0) {
- m_allowedAttributes.push_back(TIZEN_CALENDAR_ITEM_ID);
- m_allowedAttributes.push_back(TIZEN_CALENDAR_ITEM_SUMMARY);
- m_allowedAttributes.push_back(TIZEN_CALENDAR_ITEM_DESCRIPTION);
- m_allowedAttributes.push_back(TIZEN_CALENDAR_ITEM_LOCATION);
- m_allowedAttributes.push_back("category");
- m_allowedAttributes.push_back(TIZEN_CALENDAR_ITEM_STATUS);
- m_allowedAttributes.push_back("initialStartDate");
- m_allowedAttributes.push_back("endStartDate");
- }
}
CalendarConverter::~CalendarConverter()
LogDebug("entered");
}
-JSValueRef CalendarConverter::toJSValueRefItem(const CalendarEventPtr& arg)
-{
- return JSUtils::makeObject(m_context, JSCalendarItem::getClassRef(), arg);
-}
-
JSValueRef CalendarConverter::toJSValueRefEvent(const CalendarEventPtr& arg)
{
return JSUtils::makeObject(m_context, JSCalendarEvent::getClassRef(), arg);
return JSUtils::makeObject(m_context, JSCalendarTask::getClassRef(), arg);
}
-JSValueRef CalendarConverter::toJSValueRefItemArray(const CalendarEventListPtr &arg)
-{
- return toJSValueRef_(*arg, &CalendarConverter::toJSValueRefItem, this);
-}
-
JSValueRef CalendarConverter::toJSValueRefEventArray(const CalendarEventListPtr &arg)
{
return toJSValueRef_(*arg, &CalendarConverter::toJSValueRefEvent, this);
else if (!alarmMethod.compare(TIZEN_CALENDAR_PROPERTY_SOUND_ALARM))
return CalendarEvent::SOUND_ALARM;
else
- Throw(ConversionException);
+ ThrowMsg(ConversionException, "Invalid alarm type.");
- return CalendarEvent::SOUND_ALARM;
+ return CalendarEvent::UNDEFINED_ALARM_TYPE;
}
std::string CalendarConverter::toTizenValue(CalendarEvent::EventAlarmType abstractValue) const
return CalendarEvent::IN_PROCESS_STATUS;
else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS))
return CalendarEvent::COMPLETED_STATUS;
+ else
+ ThrowMsg(ConversionException, "Invalid status type.");
- // default value setting.
- if(m_calendarType == CalendarEvent::EVENT_TYPE) {
- return CalendarEvent::TENTATIVE_STATUS;
- } else {
- return CalendarEvent::NEEDS_ACTION_STATUS;
- }
+ return CalendarEvent::UNDEFINED_STATUS;
}
std::string CalendarConverter::toTizenValue(CalendarEvent::EventStatus abstractValue)
case CalendarEvent::COMPLETED_STATUS:
return TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS;
default:
- break;
+ {
+ if (CalendarEvent::TASK_TYPE==m_calendarType) {
+ return TIZEN_CALENDAR_PROPERTY_NEEDS_ACTION_STATUS;
+ } else {
+ return TIZEN_CALENDAR_PROPERTY_CONFIRMED_STATUS;
+ }
+ break;
+ }
}
ThrowMsg(ConversionException, "Invalid status");
return EventRecurrenceRule::MONTHLY_RECURRENCE;
else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_YEARLY_RECURRENCE))
return EventRecurrenceRule::YEARLY_RECURRENCE;
+ else
+ ThrowMsg(ConversionException, "Invalid recurrence frequency type.");
- return EventRecurrenceRule::NO_RECURRENCE;
+ return EventRecurrenceRule::UNDEFINED_RECURRENCE;
}
std::string CalendarConverter::toTizenValue(
const ScopedJSStringRef intervalStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_INTERVAL));
const ScopedJSStringRef untilDateStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_UNTIL_DATE));
const ScopedJSStringRef occurrenceCountStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_OCCURRENCE_COUNT));
-// const ScopedJSStringRef daysOfTheMonthStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_MONTH));
+ //const ScopedJSStringRef daysOfTheMonthStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_MONTH));
const ScopedJSStringRef daysOfTheWeekStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_WEEK));
-// const ScopedJSStringRef daysOfTheYearStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_YEAR));
-// const ScopedJSStringRef weeksOfTheYearStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_WEEKS_OF_THE_YEAR));
+ //const ScopedJSStringRef daysOfTheYearStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_YEAR));
+ //const ScopedJSStringRef weeksOfTheYearStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_WEEKS_OF_THE_YEAR));
const ScopedJSStringRef setPositionStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_SET_POSITION));
const ScopedJSStringRef exceptionsStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_EXCEPTIONS));
JSValueRef intervalData = JSObjectGetProperty(m_context, arg, intervalStr.get(), NULL);
JSValueRef untilDateData = JSObjectGetProperty(m_context, arg, untilDateStr.get(), NULL);
JSValueRef occurrenceCountData = JSObjectGetProperty(m_context, arg, occurrenceCountStr.get(), NULL);
-// JSValueRef daysOfTheMonthData = JSObjectGetProperty(m_context, arg, daysOfTheMonthStr.get(), NULL);
+ //JSValueRef daysOfTheMonthData = JSObjectGetProperty(m_context, arg, daysOfTheMonthStr.get(), NULL);
JSValueRef daysOfTheWeekData = JSObjectGetProperty(m_context, arg, daysOfTheWeekStr.get(), NULL);
-// JSValueRef daysOfTheYearData = JSObjectGetProperty(m_context, arg, daysOfTheYearStr.get(), NULL);
-// JSValueRef weeksOfTheYearData = JSObjectGetProperty(m_context, arg, weeksOfTheYearStr.get(), NULL);
+ //JSValueRef daysOfTheYearData = JSObjectGetProperty(m_context, arg, daysOfTheYearStr.get(), NULL);
+ //JSValueRef weeksOfTheYearData = JSObjectGetProperty(m_context, arg, weeksOfTheYearStr.get(), NULL);
JSValueRef setPositionData = JSObjectGetProperty(m_context, arg, setPositionStr.get(), NULL);
JSValueRef exceptionsData = JSObjectGetProperty(m_context, arg, exceptionsStr.get(), NULL);
}
if (!JSValueIsUndefined(m_context, untilDateData)) {
if (!JSValueIsNull(m_context, untilDateData)) {
- result->setEndDate(toDateTimeT(untilDateData));
+ TimeUtilConverter timeUtilConverter(m_context);
+ result->setEndDate(timeUtilConverter.toTZDateTimeT(untilDateData));
} else {
result->setEndDate(0);
}
if (!JSValueIsUndefined(m_context, occurrenceCountData)) {
result->setOccurrenceCount(toLong(occurrenceCountData));
}
-/* if (!JSValueIsUndefined(m_context, daysOfTheMonthData)) {
+ /*if (!JSValueIsUndefined(m_context, daysOfTheMonthData)) {
result->setDaysOfTheMonth(toVectorOfInts(daysOfTheMonthData));
}*/
if (!JSValueIsUndefined(m_context, daysOfTheWeekData)) {
result->setDaysOfTheWeek(toVectorOfStrings(daysOfTheWeekData));
}
-/* if (!JSValueIsUndefined(m_context, daysOfTheYearData)) {
+ /*if (!JSValueIsUndefined(m_context, daysOfTheYearData)) {
result->setDaysOfTheYear(toVectorOfInts(daysOfTheYearData));
}
if (!JSValueIsUndefined(m_context, weeksOfTheYearData)) {
result->setWeeksOfTheYear(toVectorOfInts(weeksOfTheYearData));
}*/
if (!JSValueIsUndefined(m_context, setPositionData)) {
- Throw(UnsupportedException);
+ ThrowMsg(UnsupportedException, "setPositions not supported yet.");
//result->setSetPosition(toBool(setPositionData));
}
if (!JSValueIsUndefined(m_context, exceptionsData)) {
- result->setExceptions(toVectorOfTimeT(exceptionsData));
+ result->setExceptions(toVectorOfTimeTFromTZDate(exceptionsData));
}
return result;
return CalendarEvent::PRIVATE_VISIBILITY;
else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CONFIDENTIAL_VISIBILITY))
return CalendarEvent::CONFIDENTIAL_VISIBILITY;
+ else
+ ThrowMsg(ConversionException, "Invalid visibility type.");
- return CalendarEvent::PUBLIC_VISIBILITY;
+ return CalendarEvent::UNDEFINED_VISIBILITY;
}
std::string CalendarConverter::toTizenValue(
return CalendarEvent::FREE_FB;
else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_BUSY_TENTATIVE))
return CalendarEvent::BUSY_TENTATIVE_FB;
-
- return CalendarEvent::BUSY_FB;
+ else
+ ThrowMsg(ConversionException, "Invalid availability type.");
+
+ return CalendarEvent::UNDEFINED_AVAILABILITY;
}
std::string CalendarConverter::toTizenValue(
return EventAttendee::NON_PARTICIPANT_ROLE;
else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CHAIR_ROLE))
return EventAttendee::CHAIR_ROLE;
+ else
+ ThrowMsg(ConversionException, "Invalid attendee role type.");
- return EventAttendee::REQ_PARTICIPANT_ROLE;
+ return EventAttendee::UNDEFINED_ATTENDEE_ROLE;
}
std::string CalendarConverter::toTizenValue(
return EventAttendee::COMPLETED_AT_STATUS;
else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_IN_PROCESS_STATUS))
return EventAttendee::IN_PROCESS_AT_STATUS;
+ else
+ ThrowMsg(ConversionException, "Invalid attendee status type.");
- return EventAttendee::PENDING_AT_STATUS;
+ return EventAttendee::UNDEFINED_ATTENDEE_STATUS;
}
std::string CalendarConverter::toTizenValue(
return arg;
} else if (!JSValueIsNull(m_context,
arg) && !JSValueIsUndefined(m_context, arg)) {
- ThrowMsg(InvalidArgumentException, "Not a function nor JS null.");
+ ThrowMsg(ConversionException, "Not a function nor JS null.");
}
return NULL;
}
{
if (Validator(m_context).isCallback(arg)) {
return arg;
- } else if (JSValueIsNull(m_context,
- arg) || JSValueIsUndefined(m_context, arg)) {
- ThrowMsg(ConversionException, "JS null passed as function.");
- }
- ThrowMsg(InvalidArgumentException, "Not a function nor JS null.");
-}
-
-void CalendarConverter::toEventFilterConvertId(
- const EventFilterPtr &result,
- const JSValueRef &filters)
-{
- const ScopedJSStringRef idStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_ID));
- JSObjectRef filterObj = toJSObjectRef(filters);
- if (JSObjectHasProperty(m_context, filterObj, idStr.get())) {
- LogDebug("converting id");
- JSValueRef value = JSObjectGetProperty(m_context, filterObj,
- idStr.get(), NULL);
- result->setIdFilter(toString(value));
- }
-}
-
-void CalendarConverter::toEventFilterConvertSummary(
- const EventFilterPtr &result,
- const JSValueRef &filters)
-{
- const ScopedJSStringRef summaryStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_SUMMARY));
- JSObjectRef filterObj = toJSObjectRef(filters);
- if (JSObjectHasProperty(m_context, filterObj, summaryStr.get())) {
- LogDebug("converting summary");
- JSValueRef value = JSObjectGetProperty(m_context,
- filterObj,
- summaryStr.get(),
- NULL);
- result->setSubjectFilter(toString(value));
- }
-}
-
-void CalendarConverter::toEventFilterConvertDescription(
- const EventFilterPtr &result,
- const JSValueRef &filters)
-{
- const ScopedJSStringRef descriptionStr(JSStringCreateWithUTF8CString(
- TIZEN_CALENDAR_ITEM_DESCRIPTION));
- JSObjectRef filterObj = toJSObjectRef(filters);
- if (JSObjectHasProperty(m_context, filterObj, descriptionStr.get())) {
- LogDebug("converting description");
- JSValueRef value = JSObjectGetProperty(m_context,
- filterObj,
- descriptionStr.get(),
- NULL);
- result->setDescriptionFilter(toString(value));
}
-}
-
-void CalendarConverter::toEventFilterConvertLocation(
- const EventFilterPtr &result,
- const JSValueRef &filters)
-{
- const ScopedJSStringRef locationStr(JSStringCreateWithUTF8CString(
- TIZEN_CALENDAR_ITEM_LOCATION));
- JSObjectRef filterObj = toJSObjectRef(filters);
- if (JSObjectHasProperty(m_context, filterObj, locationStr.get())) {
- LogDebug("converting location");
- JSValueRef value = JSObjectGetProperty(m_context,
- filterObj,
- locationStr.get(),
- NULL);
- result->setLocationFilter(toString(value));
- }
-}
-
-void CalendarConverter::toEventFilterConvertCategory(
- const EventFilterPtr &result,
- const JSValueRef &filters)
-{
- const ScopedJSStringRef locationStr(JSStringCreateWithUTF8CString(
- "category"));
- JSObjectRef filterObj = toJSObjectRef(filters);
- if (JSObjectHasProperty(m_context, filterObj, locationStr.get())) {
- LogDebug("converting category");
- JSValueRef value = JSObjectGetProperty(m_context,
- filterObj,
- locationStr.get(),
- NULL);
- result->setCategoryFilter(toString(value));
- }
-}
-
-void CalendarConverter::toEventFilterConvertStatus(
- const EventFilterPtr &result,
- const JSValueRef &filters)
-{
- const ScopedJSStringRef statusStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_STATUS));
- JSObjectRef filterObj = toJSObjectRef(filters);
- if (JSObjectHasProperty(m_context, filterObj, statusStr.get())) {
- LogDebug("converting status");
- JSValueRef value = JSObjectGetProperty(m_context,
- filterObj,
- statusStr.get(),
- NULL);
- std::vector<std::string> statuses = toVectorOfStrings(value);
- for (std::size_t i = 0; i < statuses.size(); ++i) {
- CalendarEvent::EventStatus status(toEventStatus(statuses[i]));
- if (status == CalendarEvent::INVALID_STATUS) {
- ThrowMsg(InvalidArgumentException,
- "Status filter has wrong value");
- }
- result->addStatusFilter(status);
- }
- }
-}
-
-void CalendarConverter::toEventFilterConvertStartTime(
- const EventFilterPtr &result,
- const JSValueRef &filters)
-{
- const ScopedJSStringRef initialStartDateStr(JSStringCreateWithUTF8CString(
- "initialStartDate"));
- const ScopedJSStringRef endStartDateStr(JSStringCreateWithUTF8CString(
- "endStartDate"));
- JSObjectRef filterObj = toJSObjectRef(filters);
- if (JSObjectHasProperty(m_context, filterObj, initialStartDateStr.get()) ||
- JSObjectHasProperty(m_context, filterObj, endStartDateStr.get())) {
- LogDebug("converting startTime");
- JSValueRef valueStart = JSObjectGetProperty(m_context,
- filterObj,
- initialStartDateStr.get(),
- NULL);
- JSValueRef valueEnd = JSObjectGetProperty(m_context,
- filterObj,
- endStartDateStr.get(),
- NULL);
- //no filters
- if ((JSValueIsNull(m_context,
- valueStart) ||
- JSValueIsUndefined(m_context, valueStart)) &&
- (JSValueIsNull(m_context,
- valueEnd) ||
- JSValueIsUndefined(m_context, valueEnd))) {
- return;
- }
- //start
- if (!JSValueIsNull(m_context, valueStart) &&
- !JSValueIsUndefined(m_context, valueStart)) {
- result->setStartTimeMinFilter(toDateTimeT(valueStart));
- }
- //end
- if (!JSValueIsNull(m_context, valueEnd) &&
- !JSValueIsUndefined(m_context, valueEnd)) {
- result->setStartTimeMaxFilter(toDateTimeT(valueEnd));
- }
- }
-}
-
-EventFilterPtr CalendarConverter::toEventFilter(const JSValueRef &filters)
-{
- LogDebug("entered");
- EventFilterPtr result(new EventFilter());
- Validator validator(m_context);
- if (!JSValueIsObject(m_context, filters)) {
- LogError("Wrong filter parameter");
- Throw(InvalidArgumentException);
- }
- if (!validator.checkArrayKeys(m_allowedAttributes, filters)) {
- LogError("Wrong filter's attribue");
- Throw(ConversionException);
- }
- toEventFilterConvertId(result, filters);
- toEventFilterConvertSummary(result, filters);
- toEventFilterConvertDescription(result, filters);
- toEventFilterConvertLocation(result, filters);
- toEventFilterConvertCategory(result, filters);
- toEventFilterConvertStatus(result, filters);
- toEventFilterConvertStartTime(result, filters);
- return result;
+ ThrowMsg(ConversionException, "Not a function.");
}
CategoryListPtr CalendarConverter::toCategories(JSValueRef categories)
result->setDelegateURI(toString(delegateURIData));
}
if (!JSValueIsUndefined(m_context, contactRefData)) {
- result->setContactId(toString(contactRefData));
+ TizenApis::Tizen1_0::Contact::ContactConverter contactConverter(m_context);
+ result->setContactId(contactConverter.toContactRef(contactRefData)->getContactId());
+ result->setAddressBookId(contactConverter.toContactRef(contactRefData)->getAddressBookId());
}
return result;
const ScopedJSStringRef availabilityStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_EVENT_AVAILABILITY));
const ScopedJSStringRef recurrenceRuleStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_EVENT_RECURRENCE_RULE));
const ScopedJSStringRef priorityStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_PRIORITY));
+ const ScopedJSStringRef endDateStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_EVENT_END_DATE));
const ScopedJSStringRef dueDateStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_TASK_DUE_DATE));
const ScopedJSStringRef completedDateStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_TASK_COMPLETED_DATE));
const ScopedJSStringRef progressStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_TASK_PROGRESS));
JSValueRef availabilityData = JSObjectGetProperty(m_context, arg, availabilityStr.get(), NULL);
JSValueRef recurrenceRuleData = JSObjectGetProperty(m_context, arg, recurrenceRuleStr.get(), NULL);
JSValueRef priorityData = JSObjectGetProperty(m_context, arg, priorityStr.get(), NULL);
+ JSValueRef endDateData = JSObjectGetProperty(m_context, arg, endDateStr.get(), NULL);
JSValueRef dueDateData = JSObjectGetProperty(m_context, arg, dueDateStr.get(), NULL);
JSValueRef completedDateData = JSObjectGetProperty(m_context, arg, completedDateStr.get(), NULL);
JSValueRef progressData = JSObjectGetProperty(m_context, arg, progressStr.get(), NULL);
result->setAttendees(attendees);
}
if (!JSValueIsUndefined(m_context, geolocationData)) {
- result->setGeolocation(toGeolocation(geolocationData));
+ TizenApis::Api::Tizen::SimpleCoordinatesPtr geoLocation =
+ TizenApis::Tizen1_0::Tizen::JSSimpleCoordinates::getSimpleCoordinates(m_context, geolocationData);
+ result->setLatitude(geoLocation->getLatitude());
+ result->setLongitude(geoLocation->getLongitude());
}
if (!JSValueIsUndefined(m_context, visibilityData)) {
result->setVisibility(toEventVisibility(toString(visibilityData)));
if (!JSValueIsUndefined(m_context, priorityData)) {
result->setPriority(toTaskPriority(toString(priorityData)));
}
+ if (!JSValueIsUndefined(m_context, endDateData)) {
+ result->setEndTime(timeUtilConverter.toTZDateTimeT(endDateData));
+ }
if (!JSValueIsUndefined(m_context, dueDateData)) {
result->setEndTime(timeUtilConverter.toTZDateTimeT(dueDateData));
}
for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
JSValueRef element = JSGetArrayElement(m_context, objArg, i);
JSObjectRef arg = JSValueToObject(m_context, element, NULL);
- resultVector.push_back(JSCalendarItem::getPrivateObject(arg));
+ resultVector.push_back(JSCalendarEvent::getPrivateObject(arg));
}
*result = resultVector;
{
LogDebug("entered");
EventIdPtr result(new EventId());
- const ScopedJSStringRef uidStr(JSStringCreateWithUTF8CString("uid"));
- const ScopedJSStringRef recurrenceIdStr(JSStringCreateWithUTF8CString("recurrenceId"));
+ const ScopedJSStringRef uidStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_EVENT_ID_UID));
+ const ScopedJSStringRef recurrenceIdStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_EVENT_ID_RECURRENCEID));
JSObjectRef arg = toJSObjectRef(eventId);
result->setUId(toString(uidData));
}
if (!JSValueIsUndefined(m_context, recurrenceIdData)) {
- TimeUtilConverter timeUtilConverter(m_context);
- result->setRecurrenceId(timeUtilConverter.toTZDateTimeT(recurrenceIdData));
- }
-
- return result;
-}
-
-CalendarItemGeoPtr CalendarConverter::toGeolocation(JSValueRef geoInfo)
-{
- LogDebug("entered");
- CalendarItemGeoPtr result(new CalendarItemGeo());
- const ScopedJSStringRef latStr(JSStringCreateWithUTF8CString("latitude"));
- const ScopedJSStringRef lonStr(JSStringCreateWithUTF8CString("longitude"));
-
- JSObjectRef arg = toJSObjectRef(geoInfo);
-
- JSValueRef latData = JSObjectGetProperty(m_context, arg, latStr.get(), NULL);
- JSValueRef lonData = JSObjectGetProperty(m_context, arg, lonStr.get(), NULL);
-
- if (!JSValueIsUndefined(m_context, latData)) {
- result->setLatitude(toDouble(latData));
- }
- if (!JSValueIsUndefined(m_context, lonData)) {
- result->setLongitude(toDouble(lonData));
+ result->setRecurrenceId(toString(recurrenceIdData));
}
return result;
else if (!priority.compare(TIZEN_CALENDAR_PROPERTY_LOW_PRIORITY))
return CalendarEvent::LOW_PRIORITY;
else
- Throw(ConversionException);
+ ThrowMsg(ConversionException, "Invalid priority type.");
- return CalendarEvent::LOW_PRIORITY;
+ return CalendarEvent::UNDEFINED_PRIORITY;
}
CalendarEvent::CalendarType CalendarConverter::toCalendarType(std::string type) const
else if (!type.compare(TIZEN_CALENDAR_PROPERTY_TYPE_TASK))
return CalendarEvent::TASK_TYPE;
else
- Throw(ConversionException);
+ ThrowMsg(ConversionException, "Invalid calendar type.");
- return CalendarEvent::EVENT_TYPE;
+ return CalendarEvent::UNDEFINED_TYPE;
}
CalendarEvent::VObjectFormat CalendarConverter::toVObjectFormat(std::string format) const
return CalendarEvent::ICALENDAR_20;
else if (!format.compare(TIZEN_CALENDAR_PROPERTY_VCALENDAR_10_FORMAT))
return CalendarEvent::VCALENDAR_10;
+ else
+ ThrowMsg(ConversionException, "Invalid format type.");
- return CalendarEvent::ICALENDAR_20;
+ return CalendarEvent::UNDEFINED_FORMAT;
}
}
projects / profile / ivi / wrt-plugins-tizen.git / blobdiff