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

List of usage examples for com.liferay.portal.kernel.cal TZSRecurrence getInterval

  1. HOME
  2. Java
  3. com.liferay.portal
  4. com.liferay.portal.kernel.cal.*
  5. TZSRecurrence
  6. getInterval

Introduction

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

Prototype

public int getInterval()

Source Link

Document

Method getInterval

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;
    }//ww  w . j  a  va  2s  .  co m

    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 {/*from w  w  w .j  av a2 s  . 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 .  j  a  v  a2  s  . c  o  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;
}

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

License:Open Source License

protected TZSRecurrence toRecurrence(RRule rRule, Calendar startDate) {
    Recur recur = rRule.getRecur();// w w w  . j a v  a 2s.c  o  m

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

    recStartCal.setTime(startDate.getTime());

    TZSRecurrence recurrence = new TZSRecurrence(recStartCal,
            new com.liferay.portal.kernel.cal.Duration(1, 0, 0, 0));

    recurrence.setWeekStart(Calendar.SUNDAY);

    if (recur.getInterval() > 1) {
        recurrence.setInterval(recur.getInterval());
    }

    Calendar until = Calendar.getInstance(TimeZoneUtil.getTimeZone(StringPool.UTC));

    String frequency = recur.getFrequency();

    if (recur.getUntil() != null) {
        until.setTime(recur.getUntil());

        recurrence.setUntil(until);
    } else if (rRule.getValue().indexOf("COUNT") >= 0) {
        until.setTimeInMillis(startDate.getTimeInMillis());

        int addField = 0;

        if (Recur.DAILY.equals(frequency)) {
            addField = Calendar.DAY_OF_YEAR;
        } else if (Recur.WEEKLY.equals(frequency)) {
            addField = Calendar.WEEK_OF_YEAR;
        } else if (Recur.MONTHLY.equals(frequency)) {
            addField = Calendar.MONTH;
        } else if (Recur.YEARLY.equals(frequency)) {
            addField = Calendar.YEAR;
        }

        int addAmount = recurrence.getInterval() * recur.getCount();

        until.add(addField, addAmount);
        until.add(Calendar.DAY_OF_YEAR, -1);

        recurrence.setUntil(until);
    }

    if (Recur.DAILY.equals(frequency)) {
        recurrence.setFrequency(Recurrence.DAILY);

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

        Iterator<WeekDay> itr = recur.getDayList().iterator();

        while (itr.hasNext()) {
            WeekDay weekDay = itr.next();

            dayPosList.add(new DayAndPosition(toCalendarWeekDay(weekDay), 0));
        }

        if (!dayPosList.isEmpty()) {
            recurrence.setByDay(dayPosList.toArray(new DayAndPosition[dayPosList.size()]));
        }
    } else if (Recur.WEEKLY.equals(frequency)) {
        recurrence.setFrequency(Recurrence.WEEKLY);

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

        Iterator<WeekDay> itr = recur.getDayList().iterator();

        while (itr.hasNext()) {
            WeekDay weekDay = itr.next();

            dayPosList.add(new DayAndPosition(toCalendarWeekDay(weekDay), 0));
        }

        if (!dayPosList.isEmpty()) {
            recurrence.setByDay(dayPosList.toArray(new DayAndPosition[dayPosList.size()]));
        }
    } else if (Recur.MONTHLY.equals(frequency)) {
        recurrence.setFrequency(Recurrence.MONTHLY);

        Iterator<Integer> monthDayListItr = recur.getMonthDayList().iterator();

        if (monthDayListItr.hasNext()) {
            Integer monthDay = monthDayListItr.next();

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

        Iterator<WeekDay> dayListItr = recur.getDayList().iterator();

        if (dayListItr.hasNext()) {
            WeekDay weekDay = dayListItr.next();

            DayAndPosition[] dayPos = { new DayAndPosition(toCalendarWeekDay(weekDay), weekDay.getOffset()) };

            recurrence.setByDay(dayPos);
        }
    } else if (Recur.YEARLY.equals(frequency)) {
        recurrence.setFrequency(Recurrence.YEARLY);
    }

    return recurrence;
}