processrowscallback.java

分页查询控件 分页查询控件

package org.extremecomponents.tree.callback;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.beanutils.BeanComparator;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.comparators.NullComparator;
import org.apache.commons.collections.comparators.ReverseComparator;
import org.extremecomponents.base.BaseModel;
import org.extremecomponents.table.bean.Table;
import org.extremecomponents.table.callback.FilterRowsCallback;
import org.extremecomponents.table.callback.RetrieveRowsCallback;
import org.extremecomponents.table.callback.SortRowsCallback;
import org.extremecomponents.table.core.ParameterRegistry;
import org.extremecomponents.table.handler.FilterPredicate;
import org.extremecomponents.table.handler.SortHandler;
import org.extremecomponents.tree.bean.TreeNode;
import org.extremecomponents.tree.core.TreeModel;
import org.extremecomponents.tree.core.TreeModelUtils;
import org.extremecomponents.util.ExtremeUtils;

public class ProcessRowsCallback implements RetrieveRowsCallback, FilterRowsCallback, SortRowsCallback {
    public Collection retrieveRows(BaseModel model)
            throws Exception {
        Table table = model.getTableHandler().getTable();

        List list = (List) ExtremeUtils.retrieveFromScope(model.getPageContext(), table.getCollection(), table
                .getScope());
        if (list == null) {
            throw new Exception(
                    "The eXtremeComponent could not find the List of Beans (or Map) identified by the collection and scope attributes.");
        }

        return list;
    }

    public Collection filterRows(BaseModel model, Collection rows)
            throws Exception {
        List results = new ArrayList();
        FilterPredicate filterPredicate = new FilterPredicate(model);
        CollectionUtils.select(rows, filterPredicate, results);
        
        //Add back the parents
        for (int i = 0; i < results.size(); i++) {
            Object bean = results.get(i);
            TreeModelUtils.findBeanParents((TreeModel) model, rows, results, bean);
        }

        return results;
    }

    public Collection sortRows(BaseModel model, Collection rows)
            throws Exception {
        List parents = new ArrayList();
        for (Iterator iter = rows.iterator(); iter.hasNext();) {
            TreeNode node = (TreeNode) iter.next();
            if (node.getParent() == null)
                parents.add(node);
        }

        List output = new ArrayList();
        String property = model.getSortHandler().getSortableProperty();
        String sortOrder = model.getRegistry().getParameter(ParameterRegistry.SORT + property);
        subSort(parents, property, sortOrder); // First sort the parents
        recursiveSort(output, parents, property, sortOrder);

        output.retainAll(rows); // Only keep the original nodes
        rows.clear();
        rows.addAll(output);

        return rows;
    }

    private void recursiveSort(List output, List rows, String property, String sortOrder) {
        for (Iterator iter = rows.iterator(); iter.hasNext();) {
            TreeNode node = (TreeNode) iter.next();

            output.add(node);

            if (node.getChildren() != null && node.getChildren().size() > 0) {
                subSort(node.getChildren(), property, sortOrder);
                recursiveSort(output, node.getChildren(), property, sortOrder);
            }
        }
    }

    private void subSort(List rows, String property, String sortOrder) {
        if (sortOrder.equals(SortHandler.SORT_ASC_)) {
            BeanComparator comparator = new BeanComparator(property, new NullComparator());
            Collections.sort(rows, comparator);
        } else if (sortOrder.equals(SortHandler.SORT_DESC_)) {
            BeanComparator reversedNaturalOrderBeanComparator = new BeanComparator(property, new ReverseComparator(
                    new NullComparator()));
            Collections.sort(rows, reversedNaturalOrderBeanComparator);
        }
    }
}