2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the License);
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an AS IS BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include <dpl/log/log.h>
19 #include <CommonsJavaScript/Validator.h>
20 #include <CommonsJavaScript/JSUtils.h>
21 #include "JSCalendarItem.h"
22 #include "JSCalendarItemProperties.h"
23 #include "JSEventId.h"
24 #include "JSCalendarItemGeo.h"
25 #include "CalendarConverter.h"
26 #include "JSCalendar.h"
27 #include "JSCalendarManager.h"
28 #include "JSAttendee.h"
29 #include "JSRecurrenceRule.h"
30 #include "JSEventAlarm.h"
31 #include <Tizen/TimeUtil/TimeUtilConverter.h>
32 #include "API/TimeUtil/DurationProperties.h"
34 using namespace TizenApis::Api::Calendar;
35 using namespace WrtDeviceApis::Commons;
36 using namespace WrtDeviceApis::CommonsJavaScript;
39 const int DEFAULT_EVENT_INTERVAL = 1;
46 std::vector<std::string> CalendarConverter::m_allowedAttributes;
48 CalendarConverter::CalendarConverter(JSContextRef context, CalendarEvent::CalendarType calendarType) : Converter(context)
52 m_calendarType = calendarType;
54 // for WAC style search filter
55 if (m_allowedAttributes.size() == 0) {
56 m_allowedAttributes.push_back(TIZEN_CALENDAR_ITEM_ID);
57 m_allowedAttributes.push_back(TIZEN_CALENDAR_ITEM_SUMMARY);
58 m_allowedAttributes.push_back(TIZEN_CALENDAR_ITEM_DESCRIPTION);
59 m_allowedAttributes.push_back(TIZEN_CALENDAR_ITEM_LOCATION);
60 m_allowedAttributes.push_back("category");
61 m_allowedAttributes.push_back(TIZEN_CALENDAR_ITEM_STATUS);
62 m_allowedAttributes.push_back("initialStartDate");
63 m_allowedAttributes.push_back("endStartDate");
67 CalendarConverter::~CalendarConverter()
72 JSValueRef CalendarConverter::toJSValueRefItem(const CalendarEventPtr& arg)
74 return JSUtils::makeObject(m_context, JSCalendarItem::getClassRef(), arg);
77 JSValueRef CalendarConverter::toJSValueRef(const CalendarEventListPtr &arg)
79 return toJSValueRef_(*arg, &CalendarConverter::toJSValueRefItem, this);
82 JSValueRef CalendarConverter::toJSValueRefItemProperties(const CalendarEventPtr& arg)
84 return JSUtils::makeObject(m_context, JSCalendarItemProperties::getClassRef(), arg);
87 JSValueRef CalendarConverter::toJSValueRefCalendar(const ICalendarPtr& arg)
89 CalendarPrivObject *priv = new CalendarPrivObject(m_context, arg);
90 return JSObjectMake(m_context, JSCalendar::getClassRef(), priv);
93 JSValueRef CalendarConverter::toJSValueRef(const std::vector<ICalendarPtr> &arg)
95 return toJSValueRef_(arg, &CalendarConverter::toJSValueRefCalendar, this);
98 JSValueRef CalendarConverter::toJSValueRef(const EventIdPtr& arg)
100 return JSUtils::makeObject(m_context, JSEventId::getClassRef(), arg);
103 JSValueRef CalendarConverter::toJSValueRef(const CalendarItemGeoPtr& arg)
105 return JSUtils::makeObject(m_context, JSCalendarItemGeo::getClassRef(), arg);
108 CalendarEvent::EventAlarmType CalendarConverter::toEventAlarmType(std::string alarmMethod)
111 if (!alarmMethod.compare(TIZEN_CALENDAR_PROPERTY_SILENT_ALARM))
112 return CalendarEvent::SILENT_ALARM;
113 else if (!alarmMethod.compare(TIZEN_CALENDAR_PROPERTY_SOUND_ALARM))
114 return CalendarEvent::SOUND_ALARM;
116 Throw(ConversionException);
118 return CalendarEvent::SOUND_ALARM;
121 std::string CalendarConverter::toTizenValue(CalendarEvent::EventAlarmType abstractValue) const
123 switch (abstractValue) {
124 case CalendarEvent::SILENT_ALARM:
125 return TIZEN_CALENDAR_PROPERTY_SILENT_ALARM;
126 case CalendarEvent::SOUND_ALARM:
127 return TIZEN_CALENDAR_PROPERTY_SOUND_ALARM;
131 ThrowMsg(ConversionException, "Invalid alarm type");
134 CalendarEvent::EventStatus CalendarConverter::toEventStatus(std::string tizenValue) const
136 if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_TENTATIVE_STATUS))
137 return CalendarEvent::TENTATIVE_STATUS;
138 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CONFIRMED_STATUS))
139 return CalendarEvent::CONFIRMED_STATUS;
140 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CANCELLED_STATUS))
141 return CalendarEvent::CANCELLED_STATUS;
142 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_NEEDS_ACTION_STATUS))
143 return CalendarEvent::NEEDS_ACTION_STATUS;
144 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_IN_PROCESS_STATUS))
145 return CalendarEvent::IN_PROCESS_STATUS;
146 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS))
147 return CalendarEvent::COMPLETED_STATUS;
149 // default value setting.
150 if(m_calendarType == CalendarEvent::EVENT_TYPE) {
151 return CalendarEvent::TENTATIVE_STATUS;
153 return CalendarEvent::NEEDS_ACTION_STATUS;
157 std::string CalendarConverter::toTizenValue(CalendarEvent::EventStatus abstractValue)
160 switch (abstractValue) {
161 case CalendarEvent::TENTATIVE_STATUS:
162 return TIZEN_CALENDAR_PROPERTY_TENTATIVE_STATUS;
163 case CalendarEvent::CONFIRMED_STATUS:
164 return TIZEN_CALENDAR_PROPERTY_CONFIRMED_STATUS;
165 case CalendarEvent::CANCELLED_STATUS:
166 return TIZEN_CALENDAR_PROPERTY_CANCELLED_STATUS;
167 case CalendarEvent::NEEDS_ACTION_STATUS:
168 return TIZEN_CALENDAR_PROPERTY_NEEDS_ACTION_STATUS;
169 case CalendarEvent::IN_PROCESS_STATUS:
170 return TIZEN_CALENDAR_PROPERTY_IN_PROCESS_STATUS;
171 case CalendarEvent::COMPLETED_STATUS:
172 return TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS;
177 ThrowMsg(ConversionException, "Invalid status");
180 EventRecurrenceRule::EventRecurrence CalendarConverter::toRecurrenceFrequency(
181 std::string tizenValue) const
183 if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_DAILY_RECURRENCE))
184 return EventRecurrenceRule::DAILY_RECURRENCE;
185 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_WEEKLY_RECURRENCE))
186 return EventRecurrenceRule::WEEKLY_RECURRENCE;
187 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_MONTHLY_RECURRENCE))
188 return EventRecurrenceRule::MONTHLY_RECURRENCE;
189 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_YEARLY_RECURRENCE))
190 return EventRecurrenceRule::YEARLY_RECURRENCE;
192 return EventRecurrenceRule::NO_RECURRENCE;
195 std::string CalendarConverter::toTizenValue(
196 EventRecurrenceRule::EventRecurrence abstractValue) const
198 switch (abstractValue) {
199 case EventRecurrenceRule::DAILY_RECURRENCE:
200 return TIZEN_CALENDAR_PROPERTY_DAILY_RECURRENCE;
201 case EventRecurrenceRule::WEEKLY_RECURRENCE:
202 case EventRecurrenceRule::WEEKDAY_RECURRENCE:
203 return TIZEN_CALENDAR_PROPERTY_WEEKLY_RECURRENCE;
204 case EventRecurrenceRule::MONTHLY_RECURRENCE:
205 case EventRecurrenceRule::MONTHLY_ON_DAY_RECURRENCE:
206 return TIZEN_CALENDAR_PROPERTY_MONTHLY_RECURRENCE;
207 case EventRecurrenceRule::YEARLY_RECURRENCE:
208 return TIZEN_CALENDAR_PROPERTY_YEARLY_RECURRENCE;
209 case EventRecurrenceRule::NO_RECURRENCE:
216 EventRecurrenceRulePtr CalendarConverter::toEventRecurrenceRule(JSValueRef rrule)
219 EventRecurrenceRulePtr result(new EventRecurrenceRule());
220 const ScopedJSStringRef frequencyStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_FREQUENCY));
221 const ScopedJSStringRef intervalStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_INTERVAL));
222 const ScopedJSStringRef untilDateStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_UNTIL_DATE));
223 const ScopedJSStringRef occurrenceCountStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_OCCURRENCE_COUNT));
224 // const ScopedJSStringRef daysOfTheMonthStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_MONTH));
225 const ScopedJSStringRef daysOfTheWeekStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_WEEK));
226 // const ScopedJSStringRef daysOfTheYearStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_DAYS_OF_THE_YEAR));
227 // const ScopedJSStringRef weeksOfTheYearStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_WEEKS_OF_THE_YEAR));
228 const ScopedJSStringRef setPositionStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_SET_POSITION));
229 const ScopedJSStringRef exceptionsStr(JSStringCreateWithUTF8CString(TIZEN_RECURRENCE_RULE_EXCEPTIONS));
231 JSObjectRef arg = toJSObjectRef(rrule);
233 JSValueRef frequencyData = JSObjectGetProperty(m_context, arg, frequencyStr.get(), NULL);
234 JSValueRef intervalData = JSObjectGetProperty(m_context, arg, intervalStr.get(), NULL);
235 JSValueRef untilDateData = JSObjectGetProperty(m_context, arg, untilDateStr.get(), NULL);
236 JSValueRef occurrenceCountData = JSObjectGetProperty(m_context, arg, occurrenceCountStr.get(), NULL);
237 // JSValueRef daysOfTheMonthData = JSObjectGetProperty(m_context, arg, daysOfTheMonthStr.get(), NULL);
238 JSValueRef daysOfTheWeekData = JSObjectGetProperty(m_context, arg, daysOfTheWeekStr.get(), NULL);
239 // JSValueRef daysOfTheYearData = JSObjectGetProperty(m_context, arg, daysOfTheYearStr.get(), NULL);
240 // JSValueRef weeksOfTheYearData = JSObjectGetProperty(m_context, arg, weeksOfTheYearStr.get(), NULL);
241 JSValueRef setPositionData = JSObjectGetProperty(m_context, arg, setPositionStr.get(), NULL);
242 JSValueRef exceptionsData = JSObjectGetProperty(m_context, arg, exceptionsStr.get(), NULL);
244 if (!JSValueIsUndefined(m_context, frequencyData)) {
245 result->setFrequency(toRecurrenceFrequency(toString(frequencyData)));
247 if (!JSValueIsUndefined(m_context, intervalData)) {
248 result->setInterval(toInt(intervalData));
250 result->setInterval(DEFAULT_EVENT_INTERVAL);
252 if (!JSValueIsUndefined(m_context, untilDateData)) {
253 if (!JSValueIsNull(m_context, untilDateData)) {
254 result->setEndDate(toDateTimeT(untilDateData));
256 result->resetEndDate();
259 if (!JSValueIsUndefined(m_context, occurrenceCountData)) {
260 result->setOccurrenceCount(toLong(occurrenceCountData));
262 /* if (!JSValueIsUndefined(m_context, daysOfTheMonthData)) {
263 result->setDaysOfTheMonth(toVectorOfInts(daysOfTheMonthData));
265 if (!JSValueIsUndefined(m_context, daysOfTheWeekData)) {
266 result->setDaysOfTheWeek(toVectorOfStrings(daysOfTheWeekData));
268 /* if (!JSValueIsUndefined(m_context, daysOfTheYearData)) {
269 result->setDaysOfTheYear(toVectorOfInts(daysOfTheYearData));
271 if (!JSValueIsUndefined(m_context, weeksOfTheYearData)) {
272 result->setWeeksOfTheYear(toVectorOfInts(weeksOfTheYearData));
274 if (!JSValueIsUndefined(m_context, setPositionData)) {
275 Throw(UnsupportedException);
276 //result->setSetPosition(toBool(setPositionData));
278 if (!JSValueIsUndefined(m_context, exceptionsData)) {
279 result->setExceptions(toVectorOfTimeT(exceptionsData));
285 CalendarEvent::EventVisibility CalendarConverter::toEventVisibility(std::string tizenValue)
288 if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_PUBLIC_VISIBILITY))
289 return CalendarEvent::PUBLIC_VISIBILITY;
290 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_PRIVATE_VISIBILITY))
291 return CalendarEvent::PRIVATE_VISIBILITY;
292 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CONFIDENTIAL_VISIBILITY))
293 return CalendarEvent::CONFIDENTIAL_VISIBILITY;
295 return CalendarEvent::PUBLIC_VISIBILITY;
298 std::string CalendarConverter::toTizenValue(
299 CalendarEvent::EventVisibility abstractValue) const
301 switch (abstractValue) {
302 case CalendarEvent::PUBLIC_VISIBILITY:
303 return TIZEN_CALENDAR_PROPERTY_PUBLIC_VISIBILITY;
304 case CalendarEvent::PRIVATE_VISIBILITY:
305 return TIZEN_CALENDAR_PROPERTY_PRIVATE_VISIBILITY;
306 case CalendarEvent::CONFIDENTIAL_VISIBILITY:
307 return TIZEN_CALENDAR_PROPERTY_CONFIDENTIAL_VISIBILITY;
312 return TIZEN_CALENDAR_PROPERTY_PUBLIC_VISIBILITY;
315 CalendarEvent::EventAvailability CalendarConverter::toEventAvailability(std::string tizenValue)
318 if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_BUSY))
319 return CalendarEvent::BUSY_FB;
320 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_BUSY_UNAVAILABLE_FB))
321 return CalendarEvent::BUSY_UNAVAILABLE_FB;
322 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_FREE))
323 return CalendarEvent::FREE_FB;
324 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_BUSY_TENTATIVE))
325 return CalendarEvent::BUSY_TENTATIVE_FB;
327 return CalendarEvent::BUSY_FB;
330 std::string CalendarConverter::toTizenValue(
331 CalendarEvent::EventAvailability abstractValue) const
333 switch (abstractValue) {
334 case CalendarEvent::BUSY_FB:
335 return TIZEN_CALENDAR_PROPERTY_BUSY;
336 case CalendarEvent::BUSY_UNAVAILABLE_FB:
337 return TIZEN_CALENDAR_PROPERTY_BUSY_UNAVAILABLE_FB;
338 case CalendarEvent::FREE_FB:
339 return TIZEN_CALENDAR_PROPERTY_FREE;
340 case CalendarEvent::BUSY_TENTATIVE_FB:
341 return TIZEN_CALENDAR_PROPERTY_BUSY_TENTATIVE;
346 return TIZEN_CALENDAR_PROPERTY_BUSY;
349 EventAttendee::EventAttendeeRole CalendarConverter::toEventAttendeeRole(std::string tizenValue)
352 if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_REQ_PARTICIPANT_ROLE))
353 return EventAttendee::REQ_PARTICIPANT_ROLE;
354 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_OPT_PARTICIPANT_ROLE))
355 return EventAttendee::OPT_PARTICIPANT_ROLE;
356 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_NON_PARTICIPANT_ROLE))
357 return EventAttendee::NON_PARTICIPANT_ROLE;
358 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_CHAIR_ROLE))
359 return EventAttendee::CHAIR_ROLE;
361 return EventAttendee::REQ_PARTICIPANT_ROLE;
364 std::string CalendarConverter::toTizenValue(
365 EventAttendee::EventAttendeeRole abstractValue) const
367 switch (abstractValue) {
368 case EventAttendee::REQ_PARTICIPANT_ROLE:
369 return TIZEN_CALENDAR_PROPERTY_REQ_PARTICIPANT_ROLE;
370 case EventAttendee::OPT_PARTICIPANT_ROLE:
371 return TIZEN_CALENDAR_PROPERTY_OPT_PARTICIPANT_ROLE;
372 case EventAttendee::NON_PARTICIPANT_ROLE:
373 return TIZEN_CALENDAR_PROPERTY_NON_PARTICIPANT_ROLE;
374 case EventAttendee::CHAIR_ROLE:
375 return TIZEN_CALENDAR_PROPERTY_CHAIR_ROLE;
379 return TIZEN_CALENDAR_PROPERTY_REQ_PARTICIPANT_ROLE;
382 EventAttendee::EventAttendeeStatus CalendarConverter::toEventAttendeeStatus(std::string tizenValue)
385 if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_PENDING_STATUS))
386 return EventAttendee::PENDING_AT_STATUS;
387 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_ACCEPTED_STATUS))
388 return EventAttendee::ACCEPTED_AT_STATUS;
389 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_DECLINED_STATUS))
390 return EventAttendee::DECLINED_AT_STATUS;
391 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_TENTATIVE_STATUS))
392 return EventAttendee::TENTATIVE_AT_STATUS;
393 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_DELEGATED_STATUS))
394 return EventAttendee::DELEGATED_AT_STATUS;
395 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS))
396 return EventAttendee::COMPLETED_AT_STATUS;
397 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_IN_PROCESS_STATUS))
398 return EventAttendee::IN_PROCESS_AT_STATUS;
400 return EventAttendee::PENDING_AT_STATUS;
403 std::string CalendarConverter::toTizenValue(
404 EventAttendee::EventAttendeeStatus abstractValue) const
406 switch (abstractValue) {
407 case EventAttendee::PENDING_AT_STATUS:
408 return TIZEN_CALENDAR_PROPERTY_PENDING_STATUS;
409 case EventAttendee::ACCEPTED_AT_STATUS:
410 return TIZEN_CALENDAR_PROPERTY_ACCEPTED_STATUS;
411 case EventAttendee::DECLINED_AT_STATUS:
412 return TIZEN_CALENDAR_PROPERTY_DECLINED_STATUS;
413 case EventAttendee::TENTATIVE_AT_STATUS:
414 return TIZEN_CALENDAR_PROPERTY_TENTATIVE_STATUS;
415 case EventAttendee::DELEGATED_AT_STATUS:
416 return TIZEN_CALENDAR_PROPERTY_DELEGATED_STATUS;
417 case EventAttendee::COMPLETED_AT_STATUS:
418 return TIZEN_CALENDAR_PROPERTY_COMPLETED_STATUS;
419 case EventAttendee::IN_PROCESS_AT_STATUS:
420 return TIZEN_CALENDAR_PROPERTY_IN_PROCESS_STATUS;
424 return TIZEN_CALENDAR_PROPERTY_PENDING_STATUS;
427 EventAttendee::EventAttendeeType CalendarConverter::toEventAttendeeType(std::string tizenValue)
430 if(!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_INDIVIDUAL_TYPE))
431 return EventAttendee::INDIVIDUAL_TYPE;
432 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_GROUP_TYPE))
433 return EventAttendee::GROUP_TYPE;
434 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_RESOURCE_TYPE))
435 return EventAttendee::RESOURCE_TYPE;
436 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_ROOM_TYPE))
437 return EventAttendee::ROOM_TYPE;
438 else if (!tizenValue.compare(TIZEN_CALENDAR_PROPERTY_UNKNOWN_TYPE))
439 return EventAttendee::UNKNOWN_TYPE;
441 return EventAttendee::INDIVIDUAL_TYPE;
444 std::string CalendarConverter::toTizenValue(
445 EventAttendee::EventAttendeeType abstractValue) const
447 switch (abstractValue) {
448 case EventAttendee::INDIVIDUAL_TYPE:
449 return TIZEN_CALENDAR_PROPERTY_INDIVIDUAL_TYPE;
450 case EventAttendee::GROUP_TYPE:
451 return TIZEN_CALENDAR_PROPERTY_GROUP_TYPE;
452 case EventAttendee::RESOURCE_TYPE:
453 return TIZEN_CALENDAR_PROPERTY_RESOURCE_TYPE;
454 case EventAttendee::ROOM_TYPE:
455 return TIZEN_CALENDAR_PROPERTY_ROOM_TYPE;
456 case EventAttendee::UNKNOWN_TYPE:
457 return TIZEN_CALENDAR_PROPERTY_UNKNOWN_TYPE;
462 return TIZEN_CALENDAR_PROPERTY_INDIVIDUAL_TYPE;
465 JSValueRef CalendarConverter::toFunctionOrNull(const JSValueRef& arg)
467 if (Validator(m_context).isCallback(arg)) {
469 } else if (!JSValueIsNull(m_context,
470 arg) && !JSValueIsUndefined(m_context, arg)) {
471 ThrowMsg(InvalidArgumentException, "Not a function nor JS null.");
476 JSValueRef CalendarConverter::toFunction(const JSValueRef& arg)
478 if (Validator(m_context).isCallback(arg)) {
480 } else if (JSValueIsNull(m_context,
481 arg) || JSValueIsUndefined(m_context, arg)) {
482 ThrowMsg(ConversionException, "JS null passed as function.");
484 ThrowMsg(InvalidArgumentException, "Not a function nor JS null.");
487 void CalendarConverter::toEventFilterConvertId(
488 const EventFilterPtr &result,
489 const JSValueRef &filters)
491 const ScopedJSStringRef idStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_ID));
492 JSObjectRef filterObj = toJSObjectRef(filters);
493 if (JSObjectHasProperty(m_context, filterObj, idStr.get())) {
494 LogDebug("converting id");
495 JSValueRef value = JSObjectGetProperty(m_context, filterObj,
497 result->setIdFilter(toString(value));
501 void CalendarConverter::toEventFilterConvertSummary(
502 const EventFilterPtr &result,
503 const JSValueRef &filters)
505 const ScopedJSStringRef summaryStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_SUMMARY));
506 JSObjectRef filterObj = toJSObjectRef(filters);
507 if (JSObjectHasProperty(m_context, filterObj, summaryStr.get())) {
508 LogDebug("converting summary");
509 JSValueRef value = JSObjectGetProperty(m_context,
513 result->setSubjectFilter(toString(value));
517 void CalendarConverter::toEventFilterConvertDescription(
518 const EventFilterPtr &result,
519 const JSValueRef &filters)
521 const ScopedJSStringRef descriptionStr(JSStringCreateWithUTF8CString(
522 TIZEN_CALENDAR_ITEM_DESCRIPTION));
523 JSObjectRef filterObj = toJSObjectRef(filters);
524 if (JSObjectHasProperty(m_context, filterObj, descriptionStr.get())) {
525 LogDebug("converting description");
526 JSValueRef value = JSObjectGetProperty(m_context,
528 descriptionStr.get(),
530 result->setDescriptionFilter(toString(value));
534 void CalendarConverter::toEventFilterConvertLocation(
535 const EventFilterPtr &result,
536 const JSValueRef &filters)
538 const ScopedJSStringRef locationStr(JSStringCreateWithUTF8CString(
539 TIZEN_CALENDAR_ITEM_LOCATION));
540 JSObjectRef filterObj = toJSObjectRef(filters);
541 if (JSObjectHasProperty(m_context, filterObj, locationStr.get())) {
542 LogDebug("converting location");
543 JSValueRef value = JSObjectGetProperty(m_context,
547 result->setLocationFilter(toString(value));
551 void CalendarConverter::toEventFilterConvertCategory(
552 const EventFilterPtr &result,
553 const JSValueRef &filters)
555 const ScopedJSStringRef locationStr(JSStringCreateWithUTF8CString(
557 JSObjectRef filterObj = toJSObjectRef(filters);
558 if (JSObjectHasProperty(m_context, filterObj, locationStr.get())) {
559 LogDebug("converting category");
560 JSValueRef value = JSObjectGetProperty(m_context,
564 result->setCategoryFilter(toString(value));
568 void CalendarConverter::toEventFilterConvertStatus(
569 const EventFilterPtr &result,
570 const JSValueRef &filters)
572 const ScopedJSStringRef statusStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_STATUS));
573 JSObjectRef filterObj = toJSObjectRef(filters);
574 if (JSObjectHasProperty(m_context, filterObj, statusStr.get())) {
575 LogDebug("converting status");
576 JSValueRef value = JSObjectGetProperty(m_context,
580 std::vector<std::string> statuses = toVectorOfStrings(value);
581 for (std::size_t i = 0; i < statuses.size(); ++i) {
582 CalendarEvent::EventStatus status(toEventStatus(statuses[i]));
583 if (status == CalendarEvent::INVALID_STATUS) {
584 ThrowMsg(InvalidArgumentException,
585 "Status filter has wrong value");
587 result->addStatusFilter(status);
592 void CalendarConverter::toEventFilterConvertStartTime(
593 const EventFilterPtr &result,
594 const JSValueRef &filters)
596 const ScopedJSStringRef initialStartDateStr(JSStringCreateWithUTF8CString(
597 "initialStartDate"));
598 const ScopedJSStringRef endStartDateStr(JSStringCreateWithUTF8CString(
600 JSObjectRef filterObj = toJSObjectRef(filters);
601 if (JSObjectHasProperty(m_context, filterObj, initialStartDateStr.get()) ||
602 JSObjectHasProperty(m_context, filterObj, endStartDateStr.get())) {
603 LogDebug("converting startTime");
604 JSValueRef valueStart = JSObjectGetProperty(m_context,
606 initialStartDateStr.get(),
608 JSValueRef valueEnd = JSObjectGetProperty(m_context,
610 endStartDateStr.get(),
613 if ((JSValueIsNull(m_context,
615 JSValueIsUndefined(m_context, valueStart)) &&
616 (JSValueIsNull(m_context,
618 JSValueIsUndefined(m_context, valueEnd))) {
622 if (!JSValueIsNull(m_context, valueStart) &&
623 !JSValueIsUndefined(m_context, valueStart)) {
624 result->setStartTimeMinFilter(toDateTimeT(valueStart));
627 if (!JSValueIsNull(m_context, valueEnd) &&
628 !JSValueIsUndefined(m_context, valueEnd)) {
629 result->setStartTimeMaxFilter(toDateTimeT(valueEnd));
634 EventFilterPtr CalendarConverter::toEventFilter(const JSValueRef &filters)
637 EventFilterPtr result(new EventFilter());
638 Validator validator(m_context);
639 if (!JSValueIsObject(m_context, filters)) {
640 LogError("Wrong filter parameter");
641 Throw(InvalidArgumentException);
643 if (!validator.checkArrayKeys(m_allowedAttributes, filters)) {
644 LogError("Wrong filter's attribue");
645 Throw(ConversionException);
647 toEventFilterConvertId(result, filters);
648 toEventFilterConvertSummary(result, filters);
649 toEventFilterConvertDescription(result, filters);
650 toEventFilterConvertLocation(result, filters);
651 toEventFilterConvertCategory(result, filters);
652 toEventFilterConvertStatus(result, filters);
653 toEventFilterConvertStartTime(result, filters);
657 CategoryListPtr CalendarConverter::toCategories(JSValueRef categories)
660 CategoryListPtr result(new CategoryList());
661 *result = toVectorOfStrings(categories);
665 EventAttendeePtr CalendarConverter::toAttendee(JSValueRef attendee)
668 EventAttendeePtr result(new EventAttendee());
669 const ScopedJSStringRef nameStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_NAME));
670 const ScopedJSStringRef uriStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_URI));
671 const ScopedJSStringRef roleStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_ROLE));
672 const ScopedJSStringRef statusStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_STATUS));
673 const ScopedJSStringRef RSVPStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_RSVP));
674 const ScopedJSStringRef typeStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_TYPE));
675 const ScopedJSStringRef groupStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_GROUP));
676 const ScopedJSStringRef delegatorURIStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_DELEGATORURI));
677 const ScopedJSStringRef delegateURIStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_DELEGATEURI));
678 const ScopedJSStringRef uidStr(JSStringCreateWithUTF8CString(TIZEN_ATTENDEE_UID));
680 JSObjectRef arg = toJSObjectRef(attendee);
682 JSValueRef nameData = JSObjectGetProperty(m_context, arg, nameStr.get(), NULL);
683 JSValueRef uriData = JSObjectGetProperty(m_context, arg, uriStr.get(), NULL);
684 JSValueRef roleData = JSObjectGetProperty(m_context, arg, roleStr.get(), NULL);
685 JSValueRef statusData = JSObjectGetProperty(m_context, arg, statusStr.get(), NULL);
686 JSValueRef RSVPData = JSObjectGetProperty(m_context, arg, RSVPStr.get(), NULL);
687 JSValueRef typeData = JSObjectGetProperty(m_context, arg, typeStr.get(), NULL);
688 JSValueRef groupData = JSObjectGetProperty(m_context, arg, groupStr.get(), NULL);
689 JSValueRef delegatorURIData = JSObjectGetProperty(m_context, arg, delegatorURIStr.get(), NULL);
690 JSValueRef delegateURIData = JSObjectGetProperty(m_context, arg, delegateURIStr.get(), NULL);
691 JSValueRef uidData = JSObjectGetProperty(m_context, arg, uidStr.get(), NULL);
693 if (!JSValueIsUndefined(m_context, nameData)) {
694 result->setName(toString(nameData));
696 if (!JSValueIsUndefined(m_context, uriData)) {
697 result->setURI(toString(uriData));
699 if (!JSValueIsUndefined(m_context, roleData)) {
700 result->setRole(toEventAttendeeRole(toString(roleData)));
702 if (!JSValueIsUndefined(m_context, statusData)) {
703 result->setStatus(toEventAttendeeStatus(toString(statusData)));
705 if (!JSValueIsUndefined(m_context, RSVPData)) {
706 result->setRSVP(toBool(RSVPData));
708 if (!JSValueIsUndefined(m_context, typeData)) {
709 result->setType(toEventAttendeeType(toString(typeData)));
711 if (!JSValueIsUndefined(m_context, groupData)) {
712 result->setGroup(toString(groupData));
714 if (!JSValueIsUndefined(m_context, delegatorURIData)) {
715 result->setDelegatorURI(toString(delegatorURIData));
717 if (!JSValueIsUndefined(m_context, delegateURIData)) {
718 result->setDelegateURI(toString(delegateURIData));
720 if (!JSValueIsUndefined(m_context, uidData)) {
721 result->setPersonId(toString(uidData));
727 EventAttendeeListPtr CalendarConverter::toVectorOfAttendees(JSValueRef attendees)
730 EventAttendeeListPtr result(new EventAttendeeList());
732 std::vector<EventAttendeePtr> resultVector;
733 JSObjectRef objArg = toJSObjectRef(attendees);
734 LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
735 for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
736 JSValueRef element = JSGetArrayElement(m_context, objArg, i);
737 resultVector.push_back(toAttendee(element));
740 *result = resultVector;
744 EventAlarmPtr CalendarConverter::toEventAlarm(JSValueRef alarm)
747 EventAlarmPtr result(new EventAlarm());
748 const ScopedJSStringRef absoluteDateStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ALARM_ABSOLUTE_DATE));
749 const ScopedJSStringRef beforeStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ALARM_BEFORE));
750 const ScopedJSStringRef methodsStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ALARM_METHODS));
752 JSObjectRef arg = toJSObjectRef(alarm);
754 JSValueRef absoluteDateData = JSObjectGetProperty(m_context, arg, absoluteDateStr.get(), NULL);
755 JSValueRef beforeData = JSObjectGetProperty(m_context, arg, beforeStr.get(), NULL);
756 JSValueRef methodsData = JSObjectGetProperty(m_context, arg, methodsStr.get(), NULL);
758 if (!JSValueIsUndefined(m_context, absoluteDateData)) {
759 TimeUtilConverter timeConverter(m_context);
760 result->setAbsoluteDate(timeConverter.toTZDateTimeT(absoluteDateData));
762 if (!JSValueIsUndefined(m_context, beforeData)) {
763 TimeUtilConverter timeConverter(m_context);
764 result->setDuration(timeConverter.getDurationPropertis(beforeData));
766 if (!JSValueIsUndefined(m_context, methodsData)) {
767 std::vector<std::string> methods = toVectorOfStrings(methodsData);
768 std::vector<CalendarEvent::EventAlarmType> convertedMethods;
769 for (unsigned int i=0; i<methods.size(); i++) {
770 convertedMethods.push_back(toEventAlarmType(methods[i]));
772 result->setMethods(convertedMethods);
778 EventAlarmListPtr CalendarConverter::toVectorOfEventAlarms(JSValueRef alarms)
781 EventAlarmListPtr result(new EventAlarmList());
783 std::vector<EventAlarmPtr> resultVector;
784 JSObjectRef objArg = toJSObjectRef(alarms);
785 LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
786 for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
787 JSValueRef element = JSGetArrayElement(m_context, objArg, i);
788 resultVector.push_back(toEventAlarm(element));
791 *result = resultVector;
795 CalendarEventPtr CalendarConverter::toEvent(const JSValueRef event)
798 CalendarEventPtr result(new CalendarEvent());
799 const ScopedJSStringRef descriptionStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_DESCRIPTION));
800 const ScopedJSStringRef summaryStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_SUMMARY));
801 const ScopedJSStringRef startTimeStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_START_DATE));
802 const ScopedJSStringRef durationStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_DURATION));
803 const ScopedJSStringRef locationStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_LOCATION));
804 const ScopedJSStringRef categoriesStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_CATEGORIES));
805 const ScopedJSStringRef statusStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_STATUS));
806 const ScopedJSStringRef alarmsStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_ALARMS));
807 const ScopedJSStringRef isAllDayStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_IS_ALL_DAY));
808 const ScopedJSStringRef organizerStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_ORGANIZER));
809 const ScopedJSStringRef attendeesStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_ATTENDEES));
810 const ScopedJSStringRef geolocationStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_GEOLOCATION));
811 const ScopedJSStringRef visibilityStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_VISIBILITY));
812 const ScopedJSStringRef availabilityStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_EVENT_AVAILABILITY));
813 const ScopedJSStringRef recurrenceRuleStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_EVENT_RECURRENCE_RULE));
814 const ScopedJSStringRef priorityStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_ITEM_PRIORITY));
815 const ScopedJSStringRef dueDateStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_TASK_DUE_DATE));
816 const ScopedJSStringRef completedDateStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_TASK_COMPLETED_DATE));
817 const ScopedJSStringRef progressStr(JSStringCreateWithUTF8CString(TIZEN_CALENDAR_TASK_PROGRESS));
819 JSObjectRef arg = toJSObjectRef(event);
821 JSValueRef descriptionData = JSObjectGetProperty(m_context, arg, descriptionStr.get(), NULL);
822 JSValueRef summaryData = JSObjectGetProperty(m_context, arg, summaryStr.get(), NULL);
823 JSValueRef startTimeData = JSObjectGetProperty(m_context, arg, startTimeStr.get(), NULL);
824 JSValueRef durationData = JSObjectGetProperty(m_context, arg, durationStr.get(), NULL);
825 JSValueRef locationData = JSObjectGetProperty(m_context, arg, locationStr.get(), NULL);
826 JSValueRef categoriesData = JSObjectGetProperty(m_context, arg, categoriesStr.get(), NULL);
827 JSValueRef statusData = JSObjectGetProperty(m_context, arg, statusStr.get(), NULL);
828 JSValueRef alarmsData = JSObjectGetProperty(m_context, arg, alarmsStr.get(), NULL);
829 JSValueRef isAllDayData = JSObjectGetProperty(m_context, arg, isAllDayStr.get(), NULL);
830 JSValueRef organizerData = JSObjectGetProperty(m_context, arg, organizerStr.get(), NULL);
831 JSValueRef attendeesData = JSObjectGetProperty(m_context, arg, attendeesStr.get(), NULL);
832 JSValueRef geolocationData = JSObjectGetProperty(m_context, arg, geolocationStr.get(), NULL);
833 JSValueRef visibilityData = JSObjectGetProperty(m_context, arg, visibilityStr.get(), NULL);
834 JSValueRef availabilityData = JSObjectGetProperty(m_context, arg, availabilityStr.get(), NULL);
835 JSValueRef recurrenceRuleData = JSObjectGetProperty(m_context, arg, recurrenceRuleStr.get(), NULL);
836 JSValueRef priorityData = JSObjectGetProperty(m_context, arg, priorityStr.get(), NULL);
837 JSValueRef dueDateData = JSObjectGetProperty(m_context, arg, dueDateStr.get(), NULL);
838 JSValueRef completedDateData = JSObjectGetProperty(m_context, arg, completedDateStr.get(), NULL);
839 JSValueRef progressData = JSObjectGetProperty(m_context, arg, progressStr.get(), NULL);
841 TimeUtilConverter timeUtilConverter(m_context);
843 if (!JSValueIsUndefined(m_context, descriptionData)) {
844 result->setDescription(toString(descriptionData));
846 if (!JSValueIsUndefined(m_context, summaryData)) {
847 result->setSubject(toString(summaryData));
849 //It's important to set startTime before duration to set end date by time_t
850 if (!JSValueIsUndefined(m_context, startTimeData)) {
851 result->setStartTime(timeUtilConverter.toTZDateTimeT(startTimeData));
852 result->setTimeZone(timeUtilConverter.getPropertiesInTZDate(startTimeData).timezone);
853 LogInfo("start time converted from TZDate: "<<result->getStartTime()<<", time zone: "<<result->getTimeZone());
855 //set default value, current local time.
856 if(m_calendarType == CalendarEvent::EVENT_TYPE) {
857 //result->setStartTime(std::time(NULL));
860 if (!JSValueIsUndefined(m_context, durationData)) {
861 long length = timeUtilConverter.getDurationLength(durationData);
862 int unit = timeUtilConverter.getDurationUnit(durationData);
863 LogInfo("duration length: "<<length<<", unit "<<unit);
865 Throw(ConversionException);
867 if( SECONDS_UNIT==unit ) {
868 result->setEndTime(result->getStartTime() + length);
869 } else if ( MINUTES_UNIT==unit ) {
870 result->setEndTime(result->getStartTime() + length*60);
871 } else if ( HOURS_UNIT==unit ) {
872 result->setEndTime(result->getStartTime() + length*60*60);
873 } else if ( DAYS_UNIT==unit ) {
874 result->setEndTime(result->getStartTime() + length*24*60*60);
876 Throw(ConversionException);
879 if (!JSValueIsUndefined(m_context, locationData)) {
880 result->setLocation(toString(locationData));
882 if (!JSValueIsUndefined(m_context, categoriesData)) {
883 CategoryListPtr categories(new CategoryList());
884 *categories = toVectorOfStrings(categoriesData);
885 result->setCategories(categories);
887 if (!JSValueIsUndefined(m_context, statusData)) {
888 result->setStatus(toEventStatus(toString(statusData)));
890 result->setStatus(CalendarEvent::CONFIRMED_STATUS);
892 if (!JSValueIsUndefined(m_context, alarmsData)) {
893 EventAlarmListPtr alarms = toVectorOfEventAlarms(alarmsData);
894 std::vector<CalendarEvent::EventAlarmType> alarmsType;
895 std::vector<long> alarmsTick;
896 for( unsigned int i=0; i<alarms->size(); i++) {
897 EventAlarmPtr theAlarm = alarms->at(i);
898 alarmsType.push_back(theAlarm->getMethods().at(0));
899 if( 0 < theAlarm->getAbsoluteDate() ) {
900 alarmsTick.push_back(theAlarm->getAbsoluteDate()/60); // minutes only in platform.
903 long length = theAlarm->getDuration().length;
904 switch(theAlarm->getDuration().unit) {
905 case TizenApis::Api::TimeUtil::MSECS_UNIT:
906 tick = length/(1000*60);
908 case TizenApis::Api::TimeUtil::SECONDS_UNIT:
911 case TizenApis::Api::TimeUtil::MINUTES_UNIT:
914 case TizenApis::Api::TimeUtil::HOURS_UNIT:
917 case TizenApis::Api::TimeUtil::DAYS_UNIT:
921 ThrowMsg(ConversionException, "Wrong alarm unit type.");
924 alarmsTick.push_back(tick);
927 result->setAlarmsType(alarmsType);
928 result->setAlarmsTick(alarmsTick);
930 if (!JSValueIsUndefined(m_context, isAllDayData)) {
931 result->setIsAllDay(toBool(isAllDayData));
933 if (!JSValueIsUndefined(m_context, organizerData)) {
934 result->setOrganizer(toString(organizerData));
936 if (!JSValueIsUndefined(m_context, attendeesData)) {
937 EventAttendeeListPtr attendees = toVectorOfAttendees(attendeesData);
938 result->setAttendees(attendees);
940 if (!JSValueIsUndefined(m_context, geolocationData)) {
941 result->setGeolocation(toGeolocation(geolocationData));
943 if (!JSValueIsUndefined(m_context, visibilityData)) {
944 result->setVisibility(toEventVisibility(toString(visibilityData)));
946 if (!JSValueIsUndefined(m_context, availabilityData)) {
947 result->setAvailability(toEventAvailability(toString(availabilityData)));
949 if (!JSValueIsUndefined(m_context, recurrenceRuleData)) {
950 result->setRecurrenceRule(toEventRecurrenceRule(recurrenceRuleData));
952 if (!JSValueIsUndefined(m_context, priorityData)) {
953 result->setPriority(toTaskPriority(toString(priorityData)));
955 if (!JSValueIsUndefined(m_context, dueDateData)) {
956 result->setEndTime(timeUtilConverter.toTZDateTimeT(dueDateData));
958 if (!JSValueIsUndefined(m_context, completedDateData)) {
959 result->setCompletedDate(timeUtilConverter.toTZDateTimeT(completedDateData));
961 if (!JSValueIsUndefined(m_context, progressData)) {
962 result->setProgress(toInt(progressData));
968 CalendarEventListPtr CalendarConverter::toVectorOfEvents(JSValueRef events)
971 CalendarEventListPtr result(new CalendarEventList());
973 std::vector<CalendarEventPtr> resultVector;
974 JSObjectRef objArg = toJSObjectRef(events);
975 LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
976 for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
977 JSValueRef element = JSGetArrayElement(m_context, objArg, i);
978 JSObjectRef arg = JSValueToObject(m_context, element, NULL);
979 resultVector.push_back(JSCalendarItem::getPrivateObject(arg));
982 *result = resultVector;
986 CalendarEventListPtr CalendarConverter::toVectorOfEventsFromProperty(JSValueRef events)
989 CalendarEventListPtr result(new CalendarEventList());
991 std::vector<CalendarEventPtr> resultVector;
992 JSObjectRef objArg = toJSObjectRef(events);
993 LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
994 for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
995 resultVector.push_back(toEvent(JSGetArrayElement(m_context, objArg, i)));
998 *result = resultVector;
1002 EventIdPtr CalendarConverter::toEventId(JSValueRef eventId)
1004 LogDebug("entered");
1005 EventIdPtr result(new EventId());
1006 const ScopedJSStringRef uidStr(JSStringCreateWithUTF8CString("uid"));
1007 const ScopedJSStringRef recurrenceIdStr(JSStringCreateWithUTF8CString("recurrenceId"));
1009 JSObjectRef arg = toJSObjectRef(eventId);
1011 JSValueRef uidData = JSObjectGetProperty(m_context, arg, uidStr.get(), NULL);
1012 JSValueRef recurrenceIdData = JSObjectGetProperty(m_context, arg, recurrenceIdStr.get(), NULL);
1014 if (!JSValueIsUndefined(m_context, uidData)) {
1015 result->setUId(toString(uidData));
1017 if (!JSValueIsUndefined(m_context, recurrenceIdData)) {
1018 TimeUtilConverter timeUtilConverter(m_context);
1019 result->setRecurrenceId(timeUtilConverter.toTZDateTimeT(recurrenceIdData));
1025 CalendarItemGeoPtr CalendarConverter::toGeolocation(JSValueRef geoInfo)
1027 LogDebug("entered");
1028 CalendarItemGeoPtr result(new CalendarItemGeo());
1029 const ScopedJSStringRef latStr(JSStringCreateWithUTF8CString("latitude"));
1030 const ScopedJSStringRef lonStr(JSStringCreateWithUTF8CString("longitude"));
1032 JSObjectRef arg = toJSObjectRef(geoInfo);
1034 JSValueRef latData = JSObjectGetProperty(m_context, arg, latStr.get(), NULL);
1035 JSValueRef lonData = JSObjectGetProperty(m_context, arg, lonStr.get(), NULL);
1037 if (!JSValueIsUndefined(m_context, latData)) {
1038 result->setLatitude(toDouble(latData));
1040 if (!JSValueIsUndefined(m_context, lonData)) {
1041 result->setLongitude(toDouble(lonData));
1047 EventIdListPtr CalendarConverter::toVectorOfEventIds(JSValueRef eventIds)
1049 LogDebug("entered");
1050 EventIdListPtr result(new EventIdList());
1052 std::vector<EventIdPtr> resultVector;
1053 JSObjectRef objArg = toJSObjectRef(eventIds);
1054 LogDebug("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 resultVector.push_back(toEventId(element));
1060 *result = resultVector;
1064 std::vector<time_t> CalendarConverter::toVectorOfTimeTFromTZDate(JSValueRef dates)
1066 LogDebug("entered");
1067 std::vector<time_t> result;
1068 TimeUtilConverter converter(m_context);
1070 JSObjectRef objArg = toJSObjectRef(dates);
1071 LogDebug("array length "<<JSGetArrayLength(m_context, objArg));
1072 for (std::size_t i = 0; i < JSGetArrayLength(m_context, objArg); i++) {
1073 JSValueRef element = JSGetArrayElement(m_context, objArg, i);
1074 result.push_back(converter.toTZDateTimeT(element));
1080 std::string CalendarConverter::toTizenValue(Api::Calendar::CalendarEvent::TaskPriority abstractValue) const
1082 switch (abstractValue) {
1083 case CalendarEvent::HIGH_PRIORITY:
1084 return TIZEN_CALENDAR_PROPERTY_HIGH_PRIORITY;
1085 case CalendarEvent::MEDIUM_PRIORITY:
1086 return TIZEN_CALENDAR_PROPERTY_MEDIUM_PRIORITY;
1087 case CalendarEvent::LOW_PRIORITY:
1088 return TIZEN_CALENDAR_PROPERTY_LOW_PRIORITY;
1092 return TIZEN_CALENDAR_PROPERTY_LOW_PRIORITY;
1095 CalendarEvent::TaskPriority CalendarConverter::toTaskPriority(std::string priority) const
1097 if (!priority.compare(TIZEN_CALENDAR_PROPERTY_HIGH_PRIORITY))
1098 return CalendarEvent::HIGH_PRIORITY;
1099 else if (!priority.compare(TIZEN_CALENDAR_PROPERTY_MEDIUM_PRIORITY))
1100 return CalendarEvent::MEDIUM_PRIORITY;
1101 else if (!priority.compare(TIZEN_CALENDAR_PROPERTY_LOW_PRIORITY))
1102 return CalendarEvent::LOW_PRIORITY;
1104 Throw(ConversionException);
1106 return CalendarEvent::LOW_PRIORITY;
1109 CalendarEvent::CalendarType CalendarConverter::toCalendarType(std::string type) const
1111 if (!type.compare(TIZEN_CALENDAR_PROPERTY_TYPE_EVENT))
1112 return CalendarEvent::EVENT_TYPE;
1113 else if (!type.compare(TIZEN_CALENDAR_PROPERTY_TYPE_TASK))
1114 return CalendarEvent::TASK_TYPE;
1116 Throw(ConversionException);
1118 return CalendarEvent::EVENT_TYPE;
1121 CalendarEvent::VObjectFormat CalendarConverter::toVObjectFormat(std::string format) const
1123 if (!format.compare(TIZEN_CALENDAR_PROPERTY_VCALENDAR_20_FORMAT))
1124 return CalendarEvent::ICALENDAR_20;
1125 else if (!format.compare(TIZEN_CALENDAR_PROPERTY_VCALENDAR_10_FORMAT))
1126 return CalendarEvent::VCALENDAR_10;
1128 return CalendarEvent::ICALENDAR_20;