Example usage for com.liferay.portal.kernel.cal TZSRecurrence getFrequency

Introduction

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

Prototype

public int getFrequency() 

Source Link

Document

Method getFrequency

Usage

From source file:com.liferay.calendar.service.impl.CalendarImporterLocalServiceImpl.java

License:Open Source License

protected String getRecurrence(TZSRecurrence tzsRecurrence) {
    if (tzsRecurrence == null) {
        return null;
    }/*w w w.  ja v  a 2s .c  om*/

    Recurrence recurrence = new Recurrence();

    Frequency frequency = _frequencyMap.get(tzsRecurrence.getFrequency());

    int interval = tzsRecurrence.getInterval();

    List<PositionalWeekday> positionalWeekdays = new ArrayList<PositionalWeekday>();

    if ((frequency == Frequency.DAILY) && (interval == 0)) {
        frequency = Frequency.WEEKLY;

        interval = 1;

        positionalWeekdays.add(new PositionalWeekday(Weekday.MONDAY, 0));
        positionalWeekdays.add(new PositionalWeekday(Weekday.TUESDAY, 0));
        positionalWeekdays.add(new PositionalWeekday(Weekday.WEDNESDAY, 0));
        positionalWeekdays.add(new PositionalWeekday(Weekday.THURSDAY, 0));
        positionalWeekdays.add(new PositionalWeekday(Weekday.FRIDAY, 0));
    } else {
        DayAndPosition[] dayAndPositions = tzsRecurrence.getByDay();

        if (dayAndPositions != null) {
            for (DayAndPosition dayAndPosition : dayAndPositions) {
                Weekday weekday = _weekdayMap.get(dayAndPosition.getDayOfWeek());

                PositionalWeekday positionalWeekday = new PositionalWeekday(weekday,
                        dayAndPosition.getDayPosition());

                positionalWeekdays.add(positionalWeekday);
            }
        }

        int[] months = tzsRecurrence.getByMonth();

        if (ArrayUtil.isNotEmpty(months)) {
            List<Integer> monthsList = new ArrayList<Integer>();

            for (int month : months) {
                monthsList.add(month + 1);
            }

            recurrence.setMonths(monthsList);
        }
    }

    recurrence.setInterval(interval);
    recurrence.setFrequency(frequency);
    recurrence.setPositionalWeekdays(positionalWeekdays);

    Calendar untilJCalendar = tzsRecurrence.getUntil();

    int ocurrence = tzsRecurrence.getOccurrence();

    if (untilJCalendar != null) {
        recurrence.setUntilJCalendar(untilJCalendar);
    } else if (ocurrence > 0) {
        recurrence.setCount(ocurrence);
    }

    return RecurrenceSerializer.serialize(recurrence);
}

---

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 . j a v  a 2s.c o  m
            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;
}

---

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

License:Open Source License

protected Recur toICalRecurrence(TZSRecurrence recurrence) {
    Recur recur = null;//from w w w.jav  a 2  s  . co m

    int recurrenceType = recurrence.getFrequency();

    int interval = recurrence.getInterval();

    if (recurrenceType == Recurrence.DAILY) {
        recur = new Recur(Recur.DAILY, -1);

        if (interval >= 1) {
            recur.setInterval(interval);
        }

        DayAndPosition[] byDay = recurrence.getByDay();

        if (byDay != null) {
            for (int i = 0; i < byDay.length; i++) {
                WeekDay weekDay = toICalWeekDay(byDay[i].getDayOfWeek());

                recur.getDayList().add(weekDay);
            }
        }

    } else if (recurrenceType == Recurrence.WEEKLY) {
        recur = new Recur(Recur.WEEKLY, -1);

        recur.setInterval(interval);

        DayAndPosition[] byDay = recurrence.getByDay();

        if (byDay != null) {
            for (int i = 0; i < byDay.length; i++) {
                WeekDay weekDay = toICalWeekDay(byDay[i].getDayOfWeek());

                recur.getDayList().add(weekDay);
            }
        }
    } else if (recurrenceType == Recurrence.MONTHLY) {
        recur = new Recur(Recur.MONTHLY, -1);

        recur.setInterval(interval);

        int[] byMonthDay = recurrence.getByMonthDay();

        if (byMonthDay != null) {
            Integer monthDay = new Integer(byMonthDay[0]);

            recur.getMonthDayList().add(monthDay);
        } else if (recurrence.getByDay() != null) {
            DayAndPosition[] byDay = recurrence.getByDay();

            WeekDay weekDay = toICalWeekDay(byDay[0].getDayOfWeek());

            recur.getDayList().add(weekDay);

            Integer position = new Integer(byDay[0].getDayPosition());

            recur.getSetPosList().add(position);
        }
    } else if (recurrenceType == Recurrence.YEARLY) {
        recur = new Recur(Recur.YEARLY, -1);

        recur.setInterval(interval);
    }

    Calendar until = recurrence.getUntil();

    if (until != null) {
        DateTime dateTime = new DateTime(until.getTime());

        recur.setUntil(dateTime);
    }

    return recur;
}

---