Example usage for com.liferay.portal.kernel.util TimeZoneUtil getTimeZone

List of usage examples for com.liferay.portal.kernel.util TimeZoneUtil getTimeZone

Introduction

In this page you can find the example usage for com.liferay.portal.kernel.util TimeZoneUtil getTimeZone.

Prototype

public static TimeZone getTimeZone(String timeZoneId) 

Source Link

Usage

From source file:com.liferay.calendar.model.impl.CalendarImpl.java

License:Open Source License

@Override
public TimeZone getTimeZone() throws PortalException {
    return TimeZoneUtil.getTimeZone(getTimeZoneId());
}

From source file:com.liferay.calendar.portlet.CalendarPortlet.java

License:Open Source License

protected TimeZone getTimeZone(PortletRequest portletRequest) {
    ThemeDisplay themeDisplay = (ThemeDisplay) portletRequest.getAttribute(WebKeys.THEME_DISPLAY);

    boolean allDay = ParamUtil.getBoolean(portletRequest, "allDay");

    if (allDay) {
        return TimeZoneUtil.getTimeZone(StringPool.UTC);
    }/*  w  w  w.ja v a 2 s.c o m*/

    PortletPreferences preferences = portletRequest.getPreferences();

    User user = themeDisplay.getUser();

    String timeZoneId = preferences.getValue("timeZoneId", user.getTimeZoneId());

    if (Validator.isNull(timeZoneId)) {
        timeZoneId = user.getTimeZoneId();
    }

    return TimeZone.getTimeZone(timeZoneId);
}

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

License:Open Source License

@Override
public CalendarBooking addCalendarBooking(long calendarId, long[] childCalendarIds,
        long parentCalendarBookingId, Map<Locale, String> titleMap, Map<Locale, String> descriptionMap,
        String location, int startTimeYear, int startTimeMonth, int startTimeDay, int startTimeHour,
        int startTimeMinute, int endTimeYear, int endTimeMonth, int endTimeDay, int endTimeHour,
        int endTimeMinute, String timeZoneId, boolean allDay, String recurrence, long firstReminder,
        String firstReminderType, long secondReminder, String secondReminderType, ServiceContext serviceContext)
        throws PortalException {

    TimeZone timeZone = TimeZoneUtil.getTimeZone(timeZoneId);

    if (allDay) {
        timeZone = TimeZone.getTimeZone(StringPool.UTC);
    }// ww  w  . j  a  v a2  s .  c  o  m

    java.util.Calendar startTimeJCalendar = JCalendarUtil.getJCalendar(startTimeYear, startTimeMonth,
            startTimeDay, startTimeHour, startTimeMinute, 0, 0, timeZone);
    java.util.Calendar endTimeJCalendar = JCalendarUtil.getJCalendar(endTimeYear, endTimeMonth, endTimeDay,
            endTimeHour, endTimeMinute, 0, 0, timeZone);

    return calendarBookingService.addCalendarBooking(calendarId, childCalendarIds, parentCalendarBookingId,
            titleMap, descriptionMap, location, startTimeJCalendar.getTimeInMillis(),
            endTimeJCalendar.getTimeInMillis(), allDay, recurrence, firstReminder, firstReminderType,
            secondReminder, secondReminderType, serviceContext);
}

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

License:Open Source License

@Override
public CalendarBooking updateCalendarBookingInstance(long calendarBookingId, int instanceIndex, long calendarId,
        Map<Locale, String> titleMap, Map<Locale, String> descriptionMap, String location, int startTimeYear,
        int startTimeMonth, int startTimeDay, int startTimeHour, int startTimeMinute, int endTimeYear,
        int endTimeMonth, int endTimeDay, int endTimeHour, int endTimeMinute, String timeZoneId, boolean allDay,
        String recurrence, boolean allFollowing, long firstReminder, String firstReminderType,
        long secondReminder, String secondReminderType, int status, ServiceContext serviceContext)
        throws PortalException {

    TimeZone timeZone = TimeZoneUtil.getTimeZone(timeZoneId);

    if (allDay) {
        timeZone = TimeZone.getTimeZone(StringPool.UTC);
    }/*from   w w w  .  j a va2  s  .c o m*/

    java.util.Calendar startTimeJCalendar = JCalendarUtil.getJCalendar(startTimeYear, startTimeMonth,
            startTimeDay, startTimeHour, startTimeMinute, 0, 0, timeZone);

    java.util.Calendar endTimeJCalendar = JCalendarUtil.getJCalendar(endTimeYear, endTimeMonth, endTimeDay,
            endTimeHour, endTimeMinute, 0, 0, timeZone);

    return calendarBookingService.updateCalendarBookingInstance(calendarBookingId, instanceIndex, calendarId,
            titleMap, descriptionMap, location, startTimeJCalendar.getTimeInMillis(),
            endTimeJCalendar.getTimeInMillis(), allDay, recurrence, allFollowing, firstReminder,
            firstReminderType, secondReminder, secondReminderType, status, serviceContext);
}

From source file:com.liferay.calendar.web.internal.portlet.CalendarPortlet.java

License:Open Source License

protected CalendarBooking updateCalendarBooking(long calendarBookingId, Calendar calendar,
        long[] childCalendarIds, Map<Locale, String> titleMap, Map<Locale, String> descriptionMap,
        String location, long startTime, long endTime, boolean allDay, Recurrence recurrence, long[] reminders,
        String[] remindersType, int instanceIndex, boolean updateInstance, boolean allFollowing,
        ServiceContext serviceContext) throws PortalException {

    CalendarBooking calendarBooking = _calendarBookingService.fetchCalendarBooking(calendarBookingId);

    TimeZone timeZone = TimeZoneUtil.getTimeZone(StringPool.UTC);

    if (!allDay) {
        timeZone = calendar.getTimeZone();
    }// ww w  . j a v  a 2 s  .  c  o m

    if (recurrence != null) {
        java.util.Calendar startTimeJCalendar = JCalendarUtil.getJCalendar(startTime, timeZone);

        recurrence = RecurrenceUtil.inTimeZone(recurrence, startTimeJCalendar, timeZone);
    }

    if (calendarBookingId <= 0) {
        calendarBooking = _calendarBookingService.addCalendarBooking(calendar.getCalendarId(), childCalendarIds,
                CalendarBookingConstants.RECURRING_CALENDAR_BOOKING_ID_DEFAULT,
                CalendarBookingConstants.PARENT_CALENDAR_BOOKING_ID_DEFAULT, titleMap, descriptionMap, location,
                startTime, endTime, allDay, RecurrenceSerializer.serialize(recurrence), reminders[0],
                remindersType[0], reminders[1], remindersType[1], serviceContext);
    } else {
        if (calendarBooking.isRecurring()) {
            if (updateInstance) {
                calendarBooking = _calendarBookingService.updateCalendarBookingInstance(calendarBookingId,
                        instanceIndex, calendar.getCalendarId(), childCalendarIds, titleMap, descriptionMap,
                        location, startTime, endTime, allDay, RecurrenceSerializer.serialize(recurrence),
                        allFollowing, reminders[0], remindersType[0], reminders[1], remindersType[1],
                        serviceContext);
            } else {
                calendarBooking = _calendarBookingService.updateRecurringCalendarBooking(calendarBookingId,
                        calendar.getCalendarId(), childCalendarIds, titleMap, descriptionMap, location,
                        startTime, endTime, allDay, RecurrenceSerializer.serialize(recurrence), reminders[0],
                        remindersType[0], reminders[1], remindersType[1], serviceContext);
            }
        } else {
            calendarBooking = _calendarBookingService.getCalendarBookingInstance(calendarBookingId,
                    instanceIndex);

            long duration = endTime - startTime;
            long offset = getOffset(calendarBooking, startTime, recurrence);

            calendarBooking = _calendarBookingService
                    .getNewStartTimeAndDurationCalendarBooking(calendarBookingId, offset, duration);

            calendarBooking = getFirstCalendarBookingInstance(calendarBooking, recurrence, timeZone);

            calendarBooking = _calendarBookingService.updateCalendarBooking(calendarBookingId,
                    calendar.getCalendarId(), childCalendarIds, titleMap, descriptionMap, location,
                    calendarBooking.getStartTime(), calendarBooking.getEndTime(), allDay,
                    RecurrenceSerializer.serialize(recurrence), reminders[0], remindersType[0], reminders[1],
                    remindersType[1], serviceContext);
        }
    }

    return calendarBooking;
}

From source file:com.liferay.dynamic.data.mapping.internal.util.DDMImpl.java

License:Open Source License

protected List<Serializable> getFieldValues(DDMStructure ddmStructure, String fieldName, String fieldNamespace,
        ServiceContext serviceContext) throws PortalException {

    DDMFormField ddmFormField = ddmStructure.getDDMFormField(fieldName);

    String fieldDataType = ddmFormField.getDataType();
    String fieldType = ddmFormField.getType();

    LocalizedValue predefinedValue = ddmFormField.getPredefinedValue();

    List<String> fieldNames = getFieldNames(fieldNamespace, fieldName, serviceContext);

    List<Serializable> fieldValues = new ArrayList<>(fieldNames.size());

    for (String fieldNameValue : fieldNames) {
        Serializable fieldValue = serviceContext.getAttribute(fieldNameValue);

        if (Validator.isNull(fieldValue)) {
            fieldValue = predefinedValue.getString(serviceContext.getLocale());
        }// w  ww .j  a va2s  .c o m

        if (fieldType.equals(DDMImpl.TYPE_CHECKBOX) && Validator.isNull(fieldValue)) {

            fieldValue = "false";
        } else if (fieldDataType.equals(FieldConstants.DATE)) {
            Date fieldValueDate = null;

            if (Validator.isNull(fieldValue)) {
                int fieldValueMonth = GetterUtil
                        .getInteger(serviceContext.getAttribute(fieldNameValue + "Month"));
                int fieldValueDay = GetterUtil.getInteger(serviceContext.getAttribute(fieldNameValue + "Day"));
                int fieldValueYear = GetterUtil
                        .getInteger(serviceContext.getAttribute(fieldNameValue + "Year"));

                fieldValueDate = _portal.getDate(fieldValueMonth, fieldValueDay, fieldValueYear,
                        TimeZoneUtil.getTimeZone("UTC"), null);
            } else {
                try {
                    fieldValueDate = DateUtil.parseDate(String.valueOf(fieldValue), serviceContext.getLocale());
                } catch (ParseException pe) {
                    _log.error("Unable to parse date " + fieldValue);
                }
            }

            if (fieldValueDate != null) {
                fieldValue = String.valueOf(fieldValueDate.getTime());
            }
        } else if (fieldDataType.equals(FieldConstants.IMAGE) && Validator.isNull(fieldValue)) {

            HttpServletRequest request = serviceContext.getRequest();

            if (request instanceof UploadRequest) {
                String imageFieldValue = getImageFieldValue((UploadRequest) request, fieldNameValue);

                if (Validator.isNotNull(imageFieldValue)) {
                    fieldValue = imageFieldValue;
                }
            }
        }

        if (Validator.isNull(fieldValue)) {
            return null;
        }

        if (DDMImpl.TYPE_SELECT.equals(fieldType)) {
            String predefinedValueString = predefinedValue.getString(serviceContext.getLocale());

            if (!fieldValue.equals(predefinedValueString) && (fieldValue instanceof String)) {

                fieldValue = new String[] { String.valueOf(fieldValue) };

                fieldValue = JSONFactoryUtil.serialize(fieldValue);
            }
        }

        Serializable fieldValueSerializable = FieldConstants.getSerializable(fieldDataType,
                GetterUtil.getString(fieldValue));

        fieldValues.add(fieldValueSerializable);
    }

    return fieldValues;
}

From source file:com.liferay.meeting.portlet.action.AddMeetingMVCActionCommand.java

License:Open Source License

protected Calendar getStartCalendar(ActionRequest actionRequest) {
    ThemeDisplay themeDisplay = (ThemeDisplay) actionRequest.getAttribute(WebKeys.THEME_DISPLAY);

    Calendar startCalendar = CalendarFactoryUtil.getCalendar(TimeZoneUtil.getTimeZone("GMT"),
            themeDisplay.getLocale());/*from  w w w.j av a 2 s.  c o  m*/

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

    startCalendar.set(Calendar.MONTH, startDateMonth);

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

    startCalendar.set(Calendar.DATE, startDateDay);

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

    startCalendar.set(Calendar.YEAR, startDateYear);

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

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

    if (startDateAmPm == Calendar.PM) {
        startDateHour += 12;
    }

    startCalendar.set(Calendar.HOUR_OF_DAY, startDateHour);

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

    startCalendar.set(Calendar.MINUTE, startDateMinute);

    startCalendar.set(Calendar.SECOND, 0);
    startCalendar.set(Calendar.MILLISECOND, 0);

    return startCalendar;
}

From source file:com.liferay.portlet.blogs.lar.WordPressImporter.java

License:Open Source License

public static void importData(PortletDataContext context) throws PortalException, SystemException {

    Map<String, Long> userMap = getWordPressUserMap(context);

    String path = getWordPressPath(context, _EXPORT_FILE);

    String fileData = context.getZipEntryAsString(path);

    if (Validator.isNull(fileData)) {
        return;//from  www  .j a  va  2  s .co  m
    }

    Document wordPressDoc = null;

    try {
        wordPressDoc = SAXReaderUtil.read(fileData);
    } catch (DocumentException de) {
        _log.error("Reading " + path, de);

        return;
    }

    User defaultUser = UserLocalServiceUtil.getDefaultUser(context.getCompanyId());

    Element root = wordPressDoc.getRootElement();

    List<Element> entryEls = root.element("channel").elements("item");

    DateFormat dateFormat = DateFormatFactoryUtil.getSimpleDateFormat(_DATE_FORMAT);

    dateFormat.setTimeZone(TimeZoneUtil.getTimeZone(StringPool.UTC));

    for (Element entryEl : entryEls) {
        importEntry(context, defaultUser, userMap, dateFormat, entryEl);
    }
}

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 a2 s.com
    }

    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 void checkEvents() throws PortalException, SystemException {
    List<CalEvent> events = calEventFinder.findByFutureReminders();

    for (CalEvent event : events) {
        User user = userPersistence.fetchByPrimaryKey(event.getUserId());

        if (user == null) {
            deleteEvent(event);/*  www .j  a  v a 2s.  com*/

            continue;
        }

        Calendar now = CalendarFactoryUtil.getCalendar(user.getTimeZone(), user.getLocale());

        if (!event.isTimeZoneSensitive()) {
            Calendar temp = CalendarFactoryUtil.getCalendar();

            temp.setTime(Time.getDate(now));

            now = temp;
        }

        Calendar startDate = null;

        if (event.isTimeZoneSensitive()) {
            startDate = CalendarFactoryUtil.getCalendar(user.getTimeZone(), user.getLocale());
        } else {
            startDate = CalendarFactoryUtil.getCalendar();
        }

        if (event.isRepeating()) {
            double daysToCheck = Math
                    .ceil(CalEventConstants.REMINDERS[CalEventConstants.REMINDERS.length - 1] / Time.DAY);

            Calendar cal = (Calendar) now.clone();

            for (int i = 0; i <= daysToCheck; i++) {
                Recurrence recurrence = event.getRecurrenceObj();

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

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

                Calendar recurrenceCal = getRecurrenceCal(cal, tzICal, event);

                if (recurrence.isInRecurrence(recurrenceCal)) {
                    remindUser(event, user, recurrenceCal, now);
                }

                cal.add(Calendar.DAY_OF_YEAR, 1);
            }
        } else {
            startDate.setTime(event.getStartDate());

            remindUser(event, user, startDate, now);
        }
    }
}