Example usage for com.liferay.portal.kernel.cal Recurrence NO_RECURRENCE

List of usage examples for com.liferay.portal.kernel.cal Recurrence NO_RECURRENCE

Introduction

In this page you can find the example usage for com.liferay.portal.kernel.cal Recurrence NO_RECURRENCE.

Prototype

int NO_RECURRENCE

To view the source code for com.liferay.portal.kernel.cal Recurrence NO_RECURRENCE.

Click Source Link

Document

Field NO_RECURRENCE

Usage

From source file:com.liferay.portlet.calendar.action.EditEventAction.java

License:Open Source License

protected void updateEvent(ActionRequest actionRequest) throws Exception {
    long eventId = ParamUtil.getLong(actionRequest, "eventId");

    String title = ParamUtil.getString(actionRequest, "title");
    String description = ParamUtil.getString(actionRequest, "description");
    String location = ParamUtil.getString(actionRequest, "location");

    int startDateMonth = ParamUtil.getInteger(actionRequest, "startDateMonth");
    int startDateDay = ParamUtil.getInteger(actionRequest, "startDateDay");
    int startDateYear = ParamUtil.getInteger(actionRequest, "startDateYear");
    int startDateHour = ParamUtil.getInteger(actionRequest, "startDateHour");
    int startDateMinute = ParamUtil.getInteger(actionRequest, "startDateMinute");
    int startDateAmPm = ParamUtil.getInteger(actionRequest, "startDateAmPm");

    if (startDateAmPm == Calendar.PM) {
        startDateHour += 12;//from  w  w w . j  a v a  2s  .co  m
    }

    int durationHour = ParamUtil.getInteger(actionRequest, "durationHour");
    int durationMinute = ParamUtil.getInteger(actionRequest, "durationMinute");
    boolean allDay = ParamUtil.getBoolean(actionRequest, "allDay");
    boolean timeZoneSensitive = ParamUtil.getBoolean(actionRequest, "timeZoneSensitive");
    String type = ParamUtil.getString(actionRequest, "type");

    int endDateMonth = ParamUtil.getInteger(actionRequest, "endDateMonth");
    int endDateDay = ParamUtil.getInteger(actionRequest, "endDateDay");
    int endDateYear = ParamUtil.getInteger(actionRequest, "endDateYear");

    boolean repeating = false;

    int recurrenceType = ParamUtil.getInteger(actionRequest, "recurrenceType");

    if (recurrenceType != Recurrence.NO_RECURRENCE) {
        repeating = true;
    }

    Locale locale = null;
    TimeZone timeZone = null;

    if (timeZoneSensitive) {
        User user = PortalUtil.getUser(actionRequest);

        locale = user.getLocale();
        timeZone = user.getTimeZone();
    } else {
        locale = LocaleUtil.getDefault();
        timeZone = TimeZoneUtil.getDefault();
    }

    Calendar startDate = CalendarFactoryUtil.getCalendar(timeZone, locale);

    startDate.set(Calendar.MONTH, startDateMonth);
    startDate.set(Calendar.DATE, startDateDay);
    startDate.set(Calendar.YEAR, startDateYear);
    startDate.set(Calendar.HOUR_OF_DAY, startDateHour);
    startDate.set(Calendar.MINUTE, startDateMinute);
    startDate.set(Calendar.SECOND, 0);
    startDate.set(Calendar.MILLISECOND, 0);

    if (allDay) {
        startDate.set(Calendar.HOUR_OF_DAY, 0);
        startDate.set(Calendar.MINUTE, 0);
        startDate.set(Calendar.SECOND, 0);
        startDate.set(Calendar.MILLISECOND, 0);

        durationHour = 24;
        durationMinute = 0;
    }

    TZSRecurrence recurrence = null;

    if (repeating) {
        Calendar recStartCal = null;

        if (timeZoneSensitive) {
            recStartCal = CalendarFactoryUtil.getCalendar(TimeZoneUtil.getTimeZone(StringPool.UTC));

            recStartCal.setTime(startDate.getTime());
        } else {
            recStartCal = (Calendar) startDate.clone();
        }

        recurrence = new TZSRecurrence(recStartCal, new Duration(1, 0, 0, 0), recurrenceType);

        recurrence.setTimeZone(timeZone);

        recurrence.setWeekStart(Calendar.SUNDAY);

        if (recurrenceType == Recurrence.DAILY) {
            int dailyType = ParamUtil.getInteger(actionRequest, "dailyType");

            if (dailyType == 0) {
                int dailyInterval = ParamUtil.getInteger(actionRequest, "dailyInterval", 1);

                recurrence.setInterval(dailyInterval);
            } else {
                DayAndPosition[] dayPos = { new DayAndPosition(Calendar.MONDAY, 0),
                        new DayAndPosition(Calendar.TUESDAY, 0), new DayAndPosition(Calendar.WEDNESDAY, 0),
                        new DayAndPosition(Calendar.THURSDAY, 0), new DayAndPosition(Calendar.FRIDAY, 0) };

                recurrence.setByDay(dayPos);
            }
        } else if (recurrenceType == Recurrence.WEEKLY) {
            int weeklyInterval = ParamUtil.getInteger(actionRequest, "weeklyInterval", 1);

            recurrence.setInterval(weeklyInterval);

            List<DayAndPosition> dayPos = new ArrayList<DayAndPosition>();

            addWeeklyDayPos(actionRequest, dayPos, Calendar.SUNDAY);
            addWeeklyDayPos(actionRequest, dayPos, Calendar.MONDAY);
            addWeeklyDayPos(actionRequest, dayPos, Calendar.TUESDAY);
            addWeeklyDayPos(actionRequest, dayPos, Calendar.WEDNESDAY);
            addWeeklyDayPos(actionRequest, dayPos, Calendar.THURSDAY);
            addWeeklyDayPos(actionRequest, dayPos, Calendar.FRIDAY);
            addWeeklyDayPos(actionRequest, dayPos, Calendar.SATURDAY);

            if (dayPos.size() == 0) {
                dayPos.add(new DayAndPosition(Calendar.MONDAY, 0));
            }

            recurrence.setByDay(dayPos.toArray(new DayAndPosition[0]));
        } else if (recurrenceType == Recurrence.MONTHLY) {
            int monthlyType = ParamUtil.getInteger(actionRequest, "monthlyType");

            if (monthlyType == 0) {
                int monthlyDay = ParamUtil.getInteger(actionRequest, "monthlyDay0");

                recurrence.setByMonthDay(new int[] { monthlyDay });

                int monthlyInterval = ParamUtil.getInteger(actionRequest, "monthlyInterval0", 1);

                recurrence.setInterval(monthlyInterval);
            } else {
                int monthlyPos = ParamUtil.getInteger(actionRequest, "monthlyPos");
                int monthlyDay = ParamUtil.getInteger(actionRequest, "monthlyDay1");

                DayAndPosition[] dayPos = { new DayAndPosition(monthlyDay, monthlyPos) };

                recurrence.setByDay(dayPos);

                int monthlyInterval = ParamUtil.getInteger(actionRequest, "monthlyInterval1", 1);

                recurrence.setInterval(monthlyInterval);
            }
        } else if (recurrenceType == Recurrence.YEARLY) {
            int yearlyType = ParamUtil.getInteger(actionRequest, "yearlyType");

            if (yearlyType == 0) {
                int yearlyMonth = ParamUtil.getInteger(actionRequest, "yearlyMonth0");
                int yearlyDay = ParamUtil.getInteger(actionRequest, "yearlyDay0");

                recurrence.setByMonth(new int[] { yearlyMonth });
                recurrence.setByMonthDay(new int[] { yearlyDay });

                int yearlyInterval = ParamUtil.getInteger(actionRequest, "yearlyInterval0", 1);

                recurrence.setInterval(yearlyInterval);
            } else {
                int yearlyPos = ParamUtil.getInteger(actionRequest, "yearlyPos");
                int yearlyDay = ParamUtil.getInteger(actionRequest, "yearlyDay1");
                int yearlyMonth = ParamUtil.getInteger(actionRequest, "yearlyMonth1");

                DayAndPosition[] dayPos = { new DayAndPosition(yearlyDay, yearlyPos) };

                recurrence.setByDay(dayPos);

                recurrence.setByMonth(new int[] { yearlyMonth });

                int yearlyInterval = ParamUtil.getInteger(actionRequest, "yearlyInterval1", 1);

                recurrence.setInterval(yearlyInterval);
            }
        }

        int endDateType = ParamUtil.getInteger(actionRequest, "endDateType");

        if (endDateType == 1) {
            int endDateOccurrence = ParamUtil.getInteger(actionRequest, "endDateOccurrence");

            recurrence.setOccurrence(endDateOccurrence);
        } else if (endDateType == 2) {
            Calendar endDate = CalendarFactoryUtil.getCalendar(timeZone);

            endDate.set(Calendar.MONTH, endDateMonth);
            endDate.set(Calendar.DATE, endDateDay);
            endDate.set(Calendar.YEAR, endDateYear);
            endDate.set(Calendar.HOUR_OF_DAY, startDateHour);
            endDate.set(Calendar.MINUTE, startDateMinute);
            endDate.set(Calendar.SECOND, 0);
            endDate.set(Calendar.MILLISECOND, 0);

            Calendar recEndCal = null;

            if (timeZoneSensitive) {
                recEndCal = CalendarFactoryUtil.getCalendar(TimeZoneUtil.getTimeZone(StringPool.UTC));

                recEndCal.setTime(endDate.getTime());
            } else {
                recEndCal = (Calendar) endDate.clone();
            }

            recurrence.setUntil(recEndCal);
        }
    }

    int remindBy = ParamUtil.getInteger(actionRequest, "remindBy");
    int firstReminder = ParamUtil.getInteger(actionRequest, "firstReminder");
    int secondReminder = ParamUtil.getInteger(actionRequest, "secondReminder");

    ServiceContext serviceContext = ServiceContextFactory.getInstance(CalEvent.class.getName(), actionRequest);

    if (eventId <= 0) {

        // Add event

        CalEvent event = CalEventServiceUtil.addEvent(title, description, location, startDateMonth,
                startDateDay, startDateYear, startDateHour, startDateMinute, endDateMonth, endDateDay,
                endDateYear, durationHour, durationMinute, allDay, timeZoneSensitive, type, repeating,
                recurrence, remindBy, firstReminder, secondReminder, serviceContext);

        AssetPublisherUtil.addAndStoreSelection(actionRequest, CalEvent.class.getName(), event.getEventId(),
                -1);
    } else {

        // Update event

        CalEventServiceUtil.updateEvent(eventId, title, description, location, startDateMonth, startDateDay,
                startDateYear, startDateHour, startDateMinute, endDateMonth, endDateDay, endDateYear,
                durationHour, durationMinute, allDay, timeZoneSensitive, type, repeating, recurrence, remindBy,
                firstReminder, secondReminder, serviceContext);
    }
}

From source file:com.liferay.portlet.calendar.service.impl.CalEventLocalServiceImpl.java

License:Open Source License

public List<CalEvent> getRepeatingEvents(long groupId, Calendar cal, String[] types) throws SystemException {

    Map<String, List<CalEvent>> eventsPool = CalEventLocalUtil.getEventsPool(groupId);

    String key = "recurrence".concat(CalUtil.toString(null, types));

    List<CalEvent> events = eventsPool.get(key);

    if (events == null) {
        if ((types != null) && (types.length > 0) && ((types.length > 1) || Validator.isNotNull(types[0]))) {

            events = calEventPersistence.findByG_T_R(groupId, types, true);
        } else {// w  w w .  jav a2 s .  com
            events = calEventPersistence.findByG_R(groupId, true);
        }

        events = new UnmodifiableList<CalEvent>(events);

        eventsPool.put(key, events);
    }

    if (cal != null) {

        // Time zone insensitive

        Calendar tzICal = CalendarFactoryUtil.getCalendar(TimeZoneUtil.getTimeZone(StringPool.UTC));

        tzICal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DATE));

        Iterator<CalEvent> itr = events.iterator();

        List<CalEvent> repeatingEvents = new ArrayList<CalEvent>();

        while (itr.hasNext()) {
            CalEvent event = itr.next();

            TZSRecurrence recurrence = event.getRecurrenceObj();

            try {

                // LEP-3468

                if ((recurrence.getFrequency() != Recurrence.NO_RECURRENCE)
                        && (recurrence.getInterval() <= 0)) {

                    recurrence.setInterval(1);

                    event.setRecurrenceObj(recurrence);

                    event = calEventPersistence.update(event, false);

                    recurrence = event.getRecurrenceObj();
                }

                if (recurrence.isInRecurrence(getRecurrenceCal(cal, tzICal, event))) {

                    repeatingEvents.add(event);
                }
            } catch (Exception e) {
                _log.error(e, e);
            }
        }

        events = new UnmodifiableList<CalEvent>(repeatingEvents);
    }

    return events;
}