ScheduleBean.java

package org.richfaces.sandbox.schedule;

import org.ajax4jsf.model.DataVisitor;
import org.ajax4jsf.model.ExtendedDataModel;
import org.ajax4jsf.model.Range;
import org.richfaces.component.AbstractSchedule;
import org.richfaces.component.event.*;
import org.richfaces.component.model.DateRange;

import javax.faces.application.FacesMessage;
import javax.faces.application.FacesMessage.Severity;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
import javax.faces.context.FacesContext;
import javax.faces.event.FacesEvent;
import java.io.Serializable;
import java.util.*;

@SessionScoped
@ManagedBean
public class ScheduleBean {
// ------------------------------ FIELDS ------------------------------

    private CustomScheduleListener additionalListener = new CustomScheduleListener();

    private boolean allDayByDefault;

    private boolean allDaySlot = true;

    private String allDayText = "All day";

    private List<ScheduleTask> allTasks = new ArrayList<ScheduleTask>();

    private boolean allowTaskMoving;

    private boolean allowTaskResizing;

    private Double aspectRatio = 1.;

    private String axisFormat = "h(:mm)tt";

    private String columnFormat = null;

    private Integer contentHeight = 400;

    private Integer defaultEventMinutes = 90;

    private Double dragOpacity = .2;

    private Integer dragRevertDuration = 2000;

    private Boolean editable = true;

    private int firstDay = Calendar.SUNDAY;

    private Integer firstHour = 8;

    private String headerCenter = "title";

    private String headerLeft = "prevYear,nextYear";

    private String headerRight = "basicDay,basicWeek agendaDay,agendaWeek month today prev,next";

    private Integer height = 400;

    private Date initialDate;

    private boolean isRTL;

    private ExtendedDataModel lazyDataModel = new MyDataModel();

    private String locale;

    private Integer maxTime = 17;

    private Integer minTime = 8;

    private Boolean selectHelper = true;

    private Boolean selectable = true;

    private String selectedEventId;

    private boolean showWeekends;

    private Integer slotMinutes = 30;

    private String switchType = "ajax";

    private int taskIdSequence = 1;

    private String text;

    private String timeFormat = null;

    private String titleFormat = null;

    private Boolean unselectAuto = true;

    private String unselectCancel = "";

    private String view = AbstractSchedule.VIEW_MONTH;

    private String weekMode = AbstractSchedule.WEEK_MODE_FIXED;

// --------------------------- CONSTRUCTORS ---------------------------

    public ScheduleBean() {
        Calendar instance = Calendar.getInstance();
        instance.setTime(getInitialDate());
        final String[] colors = new String[]{"#00ff00", "#ff0000", "#0000ff"};
        Random random = new Random();
        for (int i = -30; i < 60; i++) {
            instance.set(Calendar.HOUR, minTime + random.nextInt(maxTime - minTime));
            instance.set(Calendar.MINUTE, random.nextInt(59));
            instance.add(Calendar.DAY_OF_YEAR, 1);
            Map<String, Object> data = new HashMap<String, Object>();
            data.put("category", "category-" + (i % 3));
            int taskId = taskIdSequence++;

            allTasks.add(new ScheduleTask("" + taskId, "Title " + taskId, instance.getTime(), instance.getTime(), data, colors[random.nextInt(3)]));
        }
    }

// --------------------- GETTER / SETTER METHODS ---------------------

    public CustomScheduleListener getAdditionalListener() {
        return additionalListener;
    }

    public boolean getAllDayByDefault() {
        return allDayByDefault;
    }

    public void setAllDayByDefault(boolean allDayByDefault) {
        this.allDayByDefault = allDayByDefault;
    }

    public boolean getAllDaySlot() {
        return allDaySlot;
    }

    public void setAllDaySlot(boolean allDaySlot) {
        this.allDaySlot = allDaySlot;
    }

    public String getAllDayText() {
        return allDayText;
    }

    public void setAllDayText(String allDayText) {
        this.allDayText = allDayText;
    }

    public Double getAspectRatio() {
        return aspectRatio;
    }

    public void setAspectRatio(Double aspectRatio) {
        this.aspectRatio = aspectRatio;
    }

    public String getAxisFormat() {
        return axisFormat;
    }

    public void setAxisFormat(String axisFormat) {
        this.axisFormat = axisFormat;
    }

    public String getColumnFormat() {
        return columnFormat;
    }

    public void setColumnFormat(String columnFormat) {
        this.columnFormat = columnFormat;
    }

    public Integer getContentHeight() {
        return contentHeight;
    }

    public void setContentHeight(Integer contentHeight) {
        this.contentHeight = contentHeight;
    }

    public Integer getDefaultEventMinutes() {
        return defaultEventMinutes;
    }

    public void setDefaultEventMinutes(Integer defaultEventMinutes) {
        this.defaultEventMinutes = defaultEventMinutes;
    }

    public Double getDragOpacity() {
        return dragOpacity;
    }

    public void setDragOpacity(Double dragOpacity) {
        this.dragOpacity = dragOpacity;
    }

    public Integer getDragRevertDuration() {
        return dragRevertDuration;
    }

    public void setDragRevertDuration(Integer dragRevertDuration) {
        this.dragRevertDuration = dragRevertDuration;
    }

    public Boolean getEditable() {
        return editable;
    }

    public void setEditable(Boolean editable) {
        this.editable = editable;
    }

    public int getFirstDay() {
        return firstDay;
    }

    public void setFirstDay(int firstDay) {
        this.firstDay = firstDay;
    }

    public Integer getFirstHour() {
        return firstHour;
    }

    public void setFirstHour(Integer firstHour) {
        this.firstHour = firstHour;
    }

    public String getHeaderCenter() {
        return headerCenter;
    }

    public void setHeaderCenter(String headerCenter) {
        this.headerCenter = headerCenter;
    }

    public String getHeaderLeft() {
        return headerLeft;
    }

    public void setHeaderLeft(String headerLeft) {
        this.headerLeft = headerLeft;
    }

    public String getHeaderRight() {
        return headerRight;
    }

    public void setHeaderRight(String headerRight) {
        this.headerRight = headerRight;
    }

    public Integer getHeight() {
        return height;
    }

    public void setHeight(Integer height) {
        this.height = height;
    }

    public Date getInitialDate() {
        if (initialDate == null) {
            Calendar instance = Calendar.getInstance();
            instance.set(Calendar.YEAR, 2012);
            instance.set(Calendar.MONTH, 7);
            instance.set(Calendar.DATE, 22);
            initialDate = instance.getTime();
        }
        return initialDate;
    }

    public void setInitialDate(Date initialDate) {
        this.initialDate = initialDate;
    }

    public Boolean getIsRTL() {
        return isRTL;
    }

    public void setIsRTL(Boolean isRTL) {
        this.isRTL = isRTL;
    }

    public ExtendedDataModel getLazyDataModel() {
        return lazyDataModel;
    }

    public String getLocale() {
        if (locale == null) {
            locale = FacesContext.getCurrentInstance().getViewRoot().getLocale().getLanguage();
        }
        return locale;
    }

    public void setLocale(String locale) {
        this.locale = locale;
    }

    public Integer getMaxTime() {
        return maxTime;
    }

    public void setMaxTime(Integer maxTime) {
        this.maxTime = maxTime;
    }

    public Integer getMinTime() {
        return minTime;
    }

    public void setMinTime(Integer minTime) {
        this.minTime = minTime;
    }

    public Boolean getSelectHelper() {
        return selectHelper;
    }

    public void setSelectHelper(Boolean selectHelper) {
        this.selectHelper = selectHelper;
    }

    public Boolean getSelectable() {
        return selectable;
    }

    public void setSelectable(Boolean selectable) {
        this.selectable = selectable;
    }

    public String getSelectedEventId() {
        return selectedEventId;
    }

    public Integer getSlotMinutes() {
        return slotMinutes;
    }

    public void setSlotMinutes(Integer slotMinutes) {
        this.slotMinutes = slotMinutes;
    }

    public String getSwitchType() {
        return switchType;
    }

    public void setSwitchType(String switchType) {
        this.switchType = switchType;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

    public String getTimeFormat() {
        return timeFormat;
    }

    public void setTimeFormat(String timeFormat) {
        this.timeFormat = timeFormat;
    }

    public String getTitleFormat() {
        return titleFormat;
    }

    public void setTitleFormat(String titleFormat) {
        this.titleFormat = titleFormat;
    }

    public Boolean getUnselectAuto() {
        return unselectAuto;
    }

    public void setUnselectAuto(Boolean unselectAuto) {
        this.unselectAuto = unselectAuto;
    }

    public String getUnselectCancel() {
        return unselectCancel;
    }

    public void setUnselectCancel(String unselectCancel) {
        this.unselectCancel = unselectCancel;
    }

    public String getView() {
        return view;
    }

    public void setView(String view) {
        this.view = view;
    }

    public String getWeekMode() {
        return weekMode;
    }

    public void setWeekMode(String weekMode) {
        this.weekMode = weekMode;
    }

    public boolean isAllowTaskMoving() {
        return allowTaskMoving;
    }

    public void setAllowTaskMoving(boolean allowTaskMoving) {
        this.allowTaskMoving = allowTaskMoving;
    }

    public boolean isAllowTaskResizing() {
        return allowTaskResizing;
    }

    public void setAllowTaskResizing(boolean allowTaskResizing) {
        this.allowTaskResizing = allowTaskResizing;
    }

    public boolean isShowWeekends() {
        return showWeekends;
    }

    public void setShowWeekends(boolean showWeekends) {
        this.showWeekends = showWeekends;
    }

// -------------------------- OTHER METHODS --------------------------

    public void dateRangeChanged(ScheduleDateRangeChangeEvent event) {
        FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("Date range changed", event.toString()));
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(event.getStartDate());
        if (AbstractSchedule.VIEW_MONTH.equals(getView())) {
            calendar.add(Calendar.DATE, 15);
        }
        setInitialDate(calendar.getTime());
    }

    public void dateRangeSelected(ScheduleDateRangeSelectEvent event) {
        if (editable) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("Date range selected", event.toString()));
            int taskId = taskIdSequence++;
            allTasks.add(new ScheduleTask("" + taskId, "Title-" + taskId, event.getStartDate(), event.getEndDate(), event.isAllDay()));
        } else {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "Date range selected", "Cannot create item. Not in edit mode."));
        }
    }

    public void dateSelected(ScheduleDateSelectEvent event) {
        FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("Date selected", event.toString()));
        setInitialDate(event.getDate());
    }

    public List<ScheduleTask> getAllEvents() {
        return allTasks;
    }

    public ScheduleTask getSelectedTask() {
        return getTask(getSelectedEventId());
    }

    public Boolean taskMoved(ScheduleItemMoveEvent event) {
        System.out.println("taskMoved invoked " + event + " : " + isAllowTaskMoving());
        if (isAllowTaskMoving()) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("Item moved", event.toString()));
            ScheduleTask task = getTask(event.getEventId());
            selectedEventId = event.getEventId();
            if (task != null) {
                boolean endDateEqualsStartDate = task.getStartDate().equals(task.getEndDate());
                Calendar calendar = Calendar.getInstance();
                calendar.setTime(task.getStartDate());
                calendar.add(Calendar.DAY_OF_MONTH, event.getDayDelta());
                calendar.add(Calendar.MINUTE, event.getMinuteDelta());
                task.setStartDate(calendar.getTime());
                if (!event.isAllDay() && endDateEqualsStartDate) {
                    calendar.setTime(task.getStartDate());
                    calendar.add(Calendar.MINUTE, getDefaultEventMinutes());
                } else {
                    calendar.setTime(task.getEndDate());
                    calendar.add(Calendar.DAY_OF_MONTH, event.getDayDelta());
                    calendar.add(Calendar.MINUTE, event.getMinuteDelta());
                }
                task.setEndDate(calendar.getTime());
                task.setAllDay(event.isAllDay());
            }
        } else {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "It is not allowed to move this item", event.toString()));
        }
        return isAllowTaskMoving();
    }

    public Boolean taskResized(ScheduleItemResizeEvent event) {
        System.out.println("taskResized invoked " + event + " : " + isAllowTaskResizing());
        if (isAllowTaskResizing()) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("Item resized", event.toString()));
            ScheduleTask task = getTask(event.getEventId());
            selectedEventId = event.getEventId();
            if (task != null) {
                Calendar calendar = Calendar.getInstance();
                Date date = task.getEndDate() == null ? task.getStartDate() : task.getEndDate();
                calendar.setTime(date);
                calendar.add(Calendar.DAY_OF_MONTH, event.getDayDelta());
                calendar.add(Calendar.MINUTE, event.getMinuteDelta());
                task.setEndDate(calendar.getTime());
            }
        } else {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "It is not allowed to resize this item", event.toString()));
        }
        return isAllowTaskResizing();
    }

    public void taskSelected(ScheduleItemSelectEvent event) {
        FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("Task selected", event.toString()));
        selectedEventId = event.getEventId();
    }

    public void viewChanged(ScheduleViewChangeEvent event) {
        System.out.println("viewChanged invoked " + event);
        FacesContext.getCurrentInstance().addMessage(null, new FacesMessage("View changed", event.toString()));
        setView(event.getView());
    }

    protected ScheduleTask getTask(String id) {
        if (id == null) {
            return null;
        }
        for (ScheduleTask task : allTasks) {
            if (id.equals(task.getId())) {
                return task;
            }
        }
        return null;
    }

// -------------------------- INNER CLASSES --------------------------

    public static class CustomScheduleListener implements ScheduleDateRangeChangeListener, ScheduleDateSelectListener, ScheduleItemMoveListener, ScheduleItemResizeListener, ScheduleItemSelectListener, ScheduleViewChangeListener, ScheduleDateRangeSelectListener, Serializable {
// ------------------------------ FIELDS ------------------------------

        private static FacesEvent recentlyProcessedEvent;

// ------------------------ INTERFACE METHODS ------------------------


// --------------------- Interface ScheduleDateRangeChangeListener ---------------------

        public void dateRangeChanged(ScheduleDateRangeChangeEvent event) {
            if (event != recentlyProcessedEvent) {
                recentlyProcessedEvent = event;
                addMessage(event.toString(), FacesMessage.SEVERITY_INFO);
            }
        }

// --------------------- Interface ScheduleDateRangeSelectListener ---------------------

        public void dateRangeSelected(ScheduleDateRangeSelectEvent event) {
            if (event != recentlyProcessedEvent) {
                recentlyProcessedEvent = event;
                addMessage(event.toString(), FacesMessage.SEVERITY_INFO);
            }
        }

// --------------------- Interface ScheduleDateSelectListener ---------------------

        public void dateSelected(ScheduleDateSelectEvent event) {
            if (event != recentlyProcessedEvent) {
                recentlyProcessedEvent = event;
                addMessage(event.toString(), FacesMessage.SEVERITY_INFO);
            }
        }

// --------------------- Interface ScheduleItemMoveListener ---------------------

        public void itemMove(ScheduleItemMoveEvent event) {
            if (event != recentlyProcessedEvent) {
                recentlyProcessedEvent = event;
                addMessage("I'd like to veto moving, but nobody cares!", FacesMessage.SEVERITY_WARN);
            }
        }

// --------------------- Interface ScheduleItemResizeListener ---------------------

        public void itemResize(ScheduleItemResizeEvent event) {
            if (event != recentlyProcessedEvent) {
                recentlyProcessedEvent = event;
                addMessage("I'd like to veto resizing, but nobody cares!", FacesMessage.SEVERITY_WARN);
            }
        }

// --------------------- Interface ScheduleItemSelectListener ---------------------

        public void itemSelected(ScheduleItemSelectEvent event) {
            if (event != recentlyProcessedEvent) {
                recentlyProcessedEvent = event;
                addMessage(event.toString(), FacesMessage.SEVERITY_INFO);
            }
        }

// --------------------- Interface ScheduleViewChangeListener ---------------------

        public void viewChanged(ScheduleViewChangeEvent event) {
            if (event != recentlyProcessedEvent) {
                recentlyProcessedEvent = event;
                addMessage(event.toString(), FacesMessage.SEVERITY_INFO);
            }
        }

        private void addMessage(String text, Severity severity) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(severity, "Additional listener", text));
        }
    }

    private class MyDataModel extends ExtendedDataModel implements Serializable {
// ------------------------------ FIELDS ------------------------------

        java.util.Map indexToRowKey = new HashMap();

        int rowCount = -1;

        int rowIndex = -1;

        Object rowKey;

        java.util.Map rowKeyToIndex = new HashMap();

        java.util.Map wrappedDataMap = new HashMap();

// --------------------- GETTER / SETTER METHODS ---------------------

        @Override
        public int getRowCount() {
            if (rowCount == -1) {
                rowCount = wrappedDataMap.size();
            }
            return rowCount;
        }

        @Override
        public int getRowIndex() {
            return rowIndex;
        }

        @Override
        public Object getRowKey() {
            return rowKey;
        }

// -------------------------- OTHER METHODS --------------------------

        @Override
        public Object getRowData() {
            if (getRowKey() == null) {
                return null;
            } else {
                return wrappedDataMap.get(getRowKey());
            }
        }

        @Override
        public Object getWrappedData() {
            throw new UnsupportedOperationException("Not supported yet.");
        }

        @Override
        public boolean isRowAvailable() {
            if (getRowKey() == null) {
                return false;
            } else {
                return null != wrappedDataMap.get(getRowKey());
            }
        }

        @Override
        public void setRowIndex(int rowIndex) {
            this.rowIndex = rowIndex;
            Object key = indexToRowKey.get(rowIndex);
            if ((key != null && !key.equals(getRowKey())) || (key == null && getRowKey() != null)) {
                setRowKey(key);
            }
        }

        @Override
        public void setRowKey(Object key) {
            this.rowKey = key;
            Integer index = (Integer) rowKeyToIndex.get(key);
            if (index == null) {
                index = -1;
            }
            if (index != getRowIndex()) {
                setRowIndex(rowIndex);
            }
        }

        @Override
        public void setWrappedData(Object data) {
            throw new UnsupportedOperationException("Not supported yet.");
        }

        @Override
        public void walk(FacesContext context, DataVisitor visitor, Range range, Object argument) {
            Date startDate = ((DateRange) range).getStartDate();
            Date endDate = ((DateRange) range).getEndDate();
            wrappedDataMap.clear();
            indexToRowKey.clear();
            rowKeyToIndex.clear();
            int i = 0;
            for (ScheduleTask task : allTasks) {
                if ((startDate == null || task.getStartDate().compareTo(startDate) >= 0) && (endDate == null || task.getStartDate().compareTo(endDate) < 0)) {
                    wrappedDataMap.put(task.getId(), task);
                    int index = i++;
                    indexToRowKey.put(index, task.getId());
                    rowKeyToIndex.put(task.getId(), index);
                    visitor.process(context, task.getId(), argument);
                }
            }
            rowCount = -1;
        }
    }
}