/**
* Licensed under the Artistic License; you may not use this file
* except in compliance with the License.
* You may obtain a copy of the License at
*
* http://displaytag.sourceforge.net/license.html
*
* THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
package org.displaytag.tags;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.JspWriter;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.collections.IteratorUtils;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.LongRange;
import org.apache.commons.lang.math.NumberUtils;
import org.apache.commons.lang.math.Range;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.displaytag.Messages;
import org.displaytag.decorator.TableDecorator;
import org.displaytag.exception.ExportException;
import org.displaytag.exception.FactoryInstantiationException;
import org.displaytag.exception.InvalidTagAttributeValueException;
import org.displaytag.exception.WrappedRuntimeException;
import org.displaytag.export.BinaryExportView;
import org.displaytag.export.ExportView;
import org.displaytag.export.ExportViewFactory;
import org.displaytag.export.TextExportView;
import org.displaytag.model.Cell;
import org.displaytag.model.Column;
import org.displaytag.model.HeaderCell;
import org.displaytag.model.Row;
import org.displaytag.model.TableModel;
import org.displaytag.pagination.PaginatedList;
import org.displaytag.pagination.PaginatedListSmartListHelper;
import org.displaytag.pagination.SmartListHelper;
import org.displaytag.properties.MediaTypeEnum;
import org.displaytag.properties.SortOrderEnum;
import org.displaytag.properties.TableProperties;
import org.displaytag.render.HtmlTableWriter;
import org.displaytag.util.CollectionUtil;
import org.displaytag.util.DependencyChecker;
import org.displaytag.util.Href;
import org.displaytag.util.ParamEncoder;
import org.displaytag.util.RequestHelper;
import org.displaytag.util.RequestHelperFactory;
import org.displaytag.util.TagConstants;
/**
* This tag takes a list of objects and creates a table to display those objects. With the help of column tags, you
* simply provide the name of properties (get Methods) that are called against the objects in your list that gets
* displayed. This tag works very much like the struts iterator tag, most of the attributes have the same name and
* functionality as the struts tag.
* @author mraible
* @author Fabrizio Giustina
* @version $Revision: 1081 $ ($Author: fgiust $)
*/
public class TableTag extends HtmlTableTag
{
/**
* name of the attribute added to page scope when exporting, containing an MediaTypeEnum this can be used in column
* content to detect the output type and to return different data when exporting.
*/
public static final String PAGE_ATTRIBUTE_MEDIA = "mediaType"; //$NON-NLS-1$
/**
* If this variable is found in the request, assume the export filter is enabled.
*/
public static final String FILTER_CONTENT_OVERRIDE_BODY = //
"org.displaytag.filter.ResponseOverrideFilter.CONTENT_OVERRIDE_BODY"; //$NON-NLS-1$
/**
* D1597A17A6.
*/
private static final long serialVersionUID = 899149338534L;
/**
* logger.
*/
private static Log log = LogFactory.getLog(TableTag.class);
/**
* RequestHelperFactory instance used for link generation.
*/
private static RequestHelperFactory rhf;
/**
* Object (collection, list) on which the table is based. This is not set directly using a tag attribute and can be
* cleaned.
*/
protected Object list;
// -- start tag attributes --
/**
* Object (collection, list) on which the table is based. Set directly using the "list" attribute or evaluated from
* expression.
*/
protected Object listAttribute;
/**
* actual row number, updated during iteration.
*/
private int rowNumber = 1;
/**
* name of the object to use for iteration. Can contain expressions.
*/
private String name;
/**
* length of list to display.
*/
private int length;
/**
* table decorator class name.
*/
private String decoratorName;
/**
* page size.
*/
private int pagesize;
/**
* list contains only viewable data.
*/
private boolean partialList;
/**
* add export links.
*/
private boolean export;
/**
* list offset.
*/
private int offset;
/**
* Integer containing total size of the data displaytag is paginating
*/
private Object size;
/**
* Name of the Integer in some scope containing the size of the data displaytag is paginating
*/
private String sizeObjectName;
/**
* sort the full list?
*/
private Boolean sortFullTable;
/**
* are we doing any local sorting? (defaults to True)
*/
private boolean localSort = true;
/**
* Request uri.
*/
private String requestUri;
/**
* Prepend application context to generated links.
*/
private boolean dontAppendContext;
/**
* the index of the column sorted by default.
*/
private int defaultSortedColumn = -1;
/**
* the sorting order for the sorted column.
*/
private SortOrderEnum defaultSortOrder;
/**
* Name of parameter which should not be forwarded during sorting or pagination.
*/
private String excludedParams;
/**
* Unique table id.
*/
private String uid;
/**
* The variable name to store totals in.
*/
private String varTotals;
// -- end tag attributes --
/**
* table model - initialized in doStartTag().
*/
private TableModel tableModel;
/**
* current row.
*/
private Row currentRow;
/**
* next row.
*/
/**
* Used by various functions when the person wants to do paging - cleaned in doEndTag().
*/
private SmartListHelper listHelper;
/**
* base href used for links - set in initParameters().
*/
private Href baseHref;
/**
* table properties - set in doStartTag().
*/
private TableProperties properties;
/**
* page number - set in initParameters().
*/
private int pageNumber = 1;
/**
* Iterator on collection.
*/
private Iterator tableIterator;
/**
* export type - set in initParameters().
*/
private MediaTypeEnum currentMediaType;
/**
* daAfterBody() has been executed at least once?
*/
private boolean doAfterBodyExecuted;
/**
* The param encoder used to generate unique parameter names. Initialized at the first use of encodeParameter().
*/
private ParamEncoder paramEncoder;
/**
* Static footer added using the footer tag.
*/
private String footer;
/**
* Is this the last iteration we will be performing? We only output the footer on the last iteration.
*/
private boolean lastIteration;
/**
* Static caption added using the footer tag.
*/
private String caption;
/**
* Child caption tag.
*/
private CaptionTag captionTag;
/**
* Included row range. If no rows can be skipped the range is from 0 to Long.MAX_VALUE. Range check should be always
* done using containsLong(). This is an instance of org.apache.commons.lang.math.Range, but it's declared as Object
* to avoid runtime errors while Jasper tries to compile the page and commons lang 2.0 is not available. Commons
* lang version will be checked in the doStartTag() method in order to provide a more user friendly message.
*/
private Object filteredRows;
/**
* The paginated list containing the external pagination and sort parameters The presence of this paginated list is
* what determines if external pagination and sorting is used or not.
*/
private PaginatedList paginatedList;
/**
* Is this the last iteration?
* @return boolean <code>true</code> if this is the last iteration
*/
protected boolean isLastIteration()
{
return this.lastIteration;
}
/**
* Sets the list of parameter which should not be forwarded during sorting or pagination.
* @param value whitespace separated list of parameters which should not be included (* matches all parameters)
*/
public void setExcludedParams(String value)
{
this.excludedParams = value;
}
/**
* Sets the content of the footer. Called by a nested footer tag.
* @param string footer content
*/
public void setFooter(String string)
{
this.footer = string;
this.tableModel.setFooter(this.footer);
}
/**
* Sets the content of the caption. Called by a nested caption tag.
* @param string caption content
*/
public void setCaption(String string)
{
this.caption = string;
this.tableModel.setCaption(this.caption);
}
/**
* Set the child caption tag.
* @param captionTag Child caption tag
*/
public void setCaptionTag(CaptionTag captionTag)
{
this.captionTag = captionTag;
}
/**
* Obtain the child caption tag.
* @return The child caption tag
*/
public CaptionTag getCaptionTag()
{
return this.captionTag;
}
/**
* Is the current row empty?
* @return true if the current row is empty
*/
protected boolean isEmpty()
{
return this.currentRow == null;
}
/**
* set the Integer containing the total size of the data displaytag is paginating
* @param size Integer containing the total size of the data
*/
public void setSize(Object size)
{
if (size instanceof String)
{
this.sizeObjectName = (String) size;
}
else
{
this.size = size;
}
}
/**
* set the name of the Integer in some scope containing the total size of the data to be paginated
* @param sizeObjectName name of the Integer containing the total size of the data to be paginated
*/
public void setSizeObjectName(String sizeObjectName)
{
this.sizeObjectName = sizeObjectName;
}
/**
* setter for the "sort" attribute.
* @param value "page" (sort a single page) or "list" (sort the full list)
* @throws InvalidTagAttributeValueException if value is not "page" or "list"
*/
public void setSort(String value) throws InvalidTagAttributeValueException
{
if (TableTagParameters.SORT_AMOUNT_PAGE.equals(value))
{
this.sortFullTable = Boolean.FALSE;
}
else if (TableTagParameters.SORT_AMOUNT_LIST.equals(value))
{
this.sortFullTable = Boolean.TRUE;
}
else if (TableTagParameters.SORT_AMOUNT_EXTERNAL.equals(value))
{
this.localSort = false;
}
else
{
throw new InvalidTagAttributeValueException(getClass(), "sort", value); //$NON-NLS-1$
}
}
/**
* setter for the "requestURI" attribute. Context path is automatically added to path starting with "/".
* @param value base URI for creating links
*/
public void setRequestURI(String value)
{
this.requestUri = value;
}
/**
* Setter for the "requestURIcontext" attribute.
* @param value base URI for creating links
*/
public void setRequestURIcontext(boolean value)
{
this.dontAppendContext = !value;
}
/**
* Used to directly set a list (or any object you can iterate on).
* @param value Object
* @deprecated use setName() to get the object from the page or request scope instead of setting it directly here
*/
public void setList(Object value)
{
this.listAttribute = value;
}
/**
* Sets the name of the object to use for iteration.
* @param value name of the object to use for iteration (can contain expression). It also supports direct setting of
* a list, for jsp 2.0 containers where users can set up a data source here using EL expressions.
*/
public void setName(Object value)
{
if (value instanceof String)
{
// ok, assuming this is the name of the object
this.name = (String) value;
}
else
{
// is this the list?
this.list = value;
}
}
/**
* Sets the name of the object to use for iteration. This setter is needed for jsp 1.1 container which doesn't
* support the String - Object conversion. The bean info class will swith to this setter.
* @param value name of the object
*/
public void setNameString(String value)
{
this.name = value;
}
/**
* sets the sorting order for the sorted column.
* @param value "ascending" or "descending"
* @throws InvalidTagAttributeValueException if value is not one of "ascending" or "descending"
*/
public void setDefaultorder(String value) throws InvalidTagAttributeValueException
{
this.defaultSortOrder = SortOrderEnum.fromName(value);
if (this.defaultSortOrder == null)
{
throw new InvalidTagAttributeValueException(getClass(), "defaultorder", value); //$NON-NLS-1$
}
}
/**
* Setter for the decorator class name.
* @param decorator fully qualified name of the table decorator to use
*/
public void setDecorator(String decorator)
{
this.decoratorName = decorator;
}
/**
* Is export enabled?
* @param value <code>true</code> if export should be enabled
*/
public void setExport(boolean value)
{
this.export = value;
}
/**
* The variable name in which the totals map is stored.
* @param varTotalsName the value
*/
public void setVarTotals(String varTotalsName)
{
this.varTotals = varTotalsName;
}
/**
* Get the name that the totals should be stored under.
* @return the var name in pageContext
*/
public String getVarTotals()
{
return this.varTotals;
}
/**
* sets the number of items to be displayed in the page.
* @param value number of items to display in a page
*/
public void setLength(int value)
{
this.length = value;
}
/**
* sets the index of the default sorted column.
* @param value index of the column to sort
*/
public void setDefaultsort(int value)
{
// subtract one (internal index is 0 based)
this.defaultSortedColumn = value - 1;
}
/**
* sets the number of items that should be displayed for a single page.
* @param value number of items that should be displayed for a single page
*/
public void setPagesize(int value)
{
this.pagesize = value;
}
/**
* tells display tag that the values contained in the list are the viewable data only, there may be more results not
* given to displaytag
* @param partialList boolean value telling us there may be more data not given to displaytag
*/
public void setPartialList(boolean partialList)
{
this.partialList = partialList;
}
/**
* Setter for the list offset attribute.
* @param value String
*/
public void setOffset(int value)
{
if (value < 1)
{
// negative values has no meaning, simply treat them as 0
this.offset = 0;
}
else
{
this.offset = value - 1;
}
}
/**
* Sets the unique id used to identify for this table.
* @param value String
*/
public void setUid(String value)
{
this.uid = value;
}
/**
* Returns the unique id used to identify for this table.
* @return id for this table
*/
public String getUid()
{
return this.uid;
}
/**
* Returns the properties.
* @return TableProperties
*/
protected TableProperties getProperties()
{
return this.properties;
}
/**
* Returns the base href with parameters. This is the instance used for links, need to be cloned before being
* modified.
* @return base Href with parameters
*/
protected Href getBaseHref()
{
return this.baseHref;
}
/**
* Called by interior column tags to help this tag figure out how it is supposed to display the information in the
* List it is supposed to display.
* @param column an internal tag describing a column in this tableview
*/
public void addColumn(HeaderCell column)
{
if (log.isDebugEnabled())
{
log.debug("[" + getUid() + "] addColumn " + column);
}
if ((this.paginatedList != null) && (column.getSortable()))
{
String sortCriterion = paginatedList.getSortCriterion();
String sortProperty = column.getSortProperty();
if (sortProperty == null)
{
sortProperty = column.getBeanPropertyName();
}
if ((sortCriterion != null) && sortCriterion.equals(sortProperty))
{
this.tableModel.setSortedColumnNumber(this.tableModel.getNumberOfColumns());
column.setAlreadySorted();
}
}
this.tableModel.addColumnHeader(column);
}
/**
* Adds a cell to the current row. This method is usually called by a contained ColumnTag
* @param cell Cell to add to the current row
*/
public void addCell(Cell cell)
{
// check if null: could be null if list is empty, we don't need to fill rows
if (this.currentRow != null)
{
int columnNumber = this.currentRow.getCellList().size();
this.currentRow.addCell(cell);
// just be sure that the number of columns has not been altered by conditionally including column tags in
// different rows. This is not supported, but better avoid IndexOutOfBounds...
if (columnNumber < tableModel.getHeaderCellList().size())
{
HeaderCell header = (HeaderCell) tableModel.getHeaderCellList().get(columnNumber);
header.addCell(new Column(header, cell, currentRow));
}
}
}
/**
* Is this the first iteration?
* @return boolean <code>true</code> if this is the first iteration
*/
protected boolean isFirstIteration()
{
if (log.isDebugEnabled())
{
log.debug("["
+ getUid()
+ "] first iteration="
+ (this.rowNumber == 1)
+ " (row number="
+ this.rowNumber
+ ")");
}
// in first iteration this.rowNumber is 1
// (this.rowNumber is incremented in doAfterBody)
return this.rowNumber == 1;
}
/**
* When the tag starts, we just initialize some of our variables, and do a little bit of error checking to make sure
* that the user is not trying to give us parameters that we don't expect.
* @return int
* @throws JspException generic exception
* @see javax.servlet.jsp.tagext.Tag#doStartTag()
*/
public int doStartTag() throws JspException
{
DependencyChecker.check();
// needed before column processing, elsewhere registered views will not be added
ExportViewFactory.getInstance();
if (log.isDebugEnabled())
{
log.debug("[" + getUid() + "] doStartTag called");
}
this.properties = TableProperties.getInstance((HttpServletRequest) pageContext.getRequest());
this.tableModel = new TableModel(this.properties, pageContext.getResponse().getCharacterEncoding(), pageContext);
// copying id to the table model for logging
this.tableModel.setId(getUid());
initParameters();
this.tableModel.setMedia(this.currentMediaType);
Object previousMediaType = this.pageContext.getAttribute(PAGE_ATTRIBUTE_MEDIA);
// set the PAGE_ATTRIBUTE_MEDIA attribute in the page scope
if (previousMediaType == null || MediaTypeEnum.HTML.equals(previousMediaType))
{
if (log.isDebugEnabled())
{
log.debug("[" + getUid() + "] setting media [" + this.currentMediaType + "] in this.pageContext");
}
this.pageContext.setAttribute(PAGE_ATTRIBUTE_MEDIA, this.currentMediaType);
}
doIteration();
// always return EVAL_BODY_TAG to get column headers also if the table is empty
// using int to avoid deprecation error in compilation using j2ee 1.3
return 2;
}
/**
* @see javax.servlet.jsp.tagext.BodyTag#doAfterBody()
*/
public int doAfterBody()
{
// doAfterBody() has been called, body is not empty
this.doAfterBodyExecuted = true;
if (log.isDebugEnabled())
{
log.debug("[" + getUid() + "] doAfterBody called - iterating on row " + this.rowNumber);
}
// increment this.rowNumber
this.rowNumber++;
// Call doIteration() to do the common work
return doIteration();
}
/**
* Utility method that is used by both doStartTag() and doAfterBody() to perform an iteration.
* @return <code>int</code> either EVAL_BODY_TAG or SKIP_BODY depending on whether another iteration is desired.
*/
protected int doIteration()
{
if (log.isDebugEnabled())
{
log.debug("[" + getUid() + "] doIteration called");
}
// Row already filled?
if (this.currentRow != null)
{
// if yes add to table model and remove
this.tableModel.addRow(this.currentRow);
this.currentRow = null;
}
if (this.tableIterator.hasNext())
{
Object iteratedObject = this.tableIterator.next();
if (getUid() != null)
{
if ((iteratedObject != null))
{
// set object into this.pageContext
if (log.isDebugEnabled())
{
log.debug("[" + getUid() + "] setting attribute \"" + getUid() + "\" in pageContext");
}
this.pageContext.setAttribute(getUid(), iteratedObject);
}
else
{
// if row is null remove previous object
this.pageContext.removeAttribute(getUid());
}
// set the current row number into this.pageContext
this.pageContext.setAttribute(getUid() + TableTagExtraInfo.ROWNUM_SUFFIX, new Integer(this.rowNumber));
}
// Row object for Cell values
this.currentRow = new Row(iteratedObject, this.rowNumber);
this.lastIteration = !this.tableIterator.hasNext();
// new iteration
// using int to avoid deprecation error in compilation using j2ee 1.3
return 2;
}
this.lastIteration = true;
if (log.isDebugEnabled())
{
log.debug("[" + getUid() + "] doIteration() - iterator ended after " + (this.rowNumber - 1) + " rows");
}
// end iteration
return SKIP_BODY;
}
/**
* Reads parameters from the request and initialize all the needed table model attributes.
* @throws FactoryInstantiationException for problems in instantiating a RequestHelperFactory
*/
private void initParameters() throws JspTagException, FactoryInstantiationException
{
if (rhf == null)
{
// first time initialization
rhf = this.properties.getRequestHelperFactoryInstance();
}
String fullName = getFullObjectName();
// only evaluate if needed, else use list attribute
if (fullName != null)
{
this.list = evaluateExpression(fullName);
}
else if (this.list == null)
{
// needed to allow removing the collection of objects if not set directly
this.list = this.listAttribute;
}
if (this.list instanceof PaginatedList)
{
this.paginatedList = (PaginatedList) this.list;
this.list = this.paginatedList.getList();
}
// set the table model to perform in memory local sorting
this.tableModel.setLocalSort(this.localSort && (this.paginatedList == null));
RequestHelper requestHelper = rhf.getRequestHelperInstance(this.pageContext);
initHref(requestHelper);
Integer pageNumberParameter = requestHelper.getIntParameter(encodeParameter(TableTagParameters.PARAMETER_PAGE));
this.pageNumber = (pageNumberParameter == null) ? 1 : pageNumberParameter.intValue();
int sortColumn = -1;
if (!this.tableModel.isLocalSort())
{
// our sort column parameter may be a string, check that first
String sortColumnName = requestHelper.getParameter(encodeParameter(TableTagParameters.PARAMETER_SORT));
// if usename is not null, sortColumnName is the name, if not is the column index
String usename = requestHelper.getParameter(encodeParameter(TableTagParameters.PARAMETER_SORTUSINGNAME));
if (sortColumnName == null)
{
this.tableModel.setSortedColumnNumber(this.defaultSortedColumn);
}
else
{
if (usename != null)
{
this.tableModel.setSortedColumnName(sortColumnName); // its a string, set as string
}
else if (NumberUtils.isNumber(sortColumnName))
{
sortColumn = Integer.parseInt(sortColumnName);
this.tableModel.setSortedColumnNumber(sortColumn); // its an int set as normal
}
}
}
else if (this.paginatedList == null)
{
Integer sortColumnParameter = requestHelper
.getIntParameter(encodeParameter(TableTagParameters.PARAMETER_SORT));
sortColumn = (sortColumnParameter == null) ? this.defaultSortedColumn : sortColumnParameter.intValue();
this.tableModel.setSortedColumnNumber(sortColumn);
}
else
{
sortColumn = defaultSortedColumn;
}
// default value
boolean finalSortFull = this.properties.getSortFullList();
// user value for this single table
if (this.sortFullTable != null)
{
finalSortFull = this.sortFullTable.booleanValue();
}
// if a partial list is used and sort="list" is specified, assume the partial list is already sorted
if (!this.partialList || !finalSortFull)
{
this.tableModel.setSortFullTable(finalSortFull);
}
if (this.paginatedList == null)
{
SortOrderEnum paramOrder = SortOrderEnum.fromCode(requestHelper
.getIntParameter(encodeParameter(TableTagParameters.PARAMETER_ORDER)));
// if no order parameter is set use default
if (paramOrder == null)
{
paramOrder = this.defaultSortOrder;
}
boolean order = SortOrderEnum.DESCENDING != paramOrder;
this.tableModel.setSortOrderAscending(order);
}
else
{
SortOrderEnum direction = paginatedList.getSortDirection();
this.tableModel.setSortOrderAscending(direction == SortOrderEnum.ASCENDING);
}
Integer exportTypeParameter = requestHelper
.getIntParameter(encodeParameter(TableTagParameters.PARAMETER_EXPORTTYPE));
this.currentMediaType = (MediaTypeEnum) ObjectUtils.defaultIfNull(
MediaTypeEnum.fromCode(exportTypeParameter),
MediaTypeEnum.HTML);
// if we are doing partialLists then ensure we have our size object
if (this.partialList)
{
if ((this.sizeObjectName == null) && (this.size == null))
{
// ?
}
if (this.sizeObjectName != null)
{
// retrieve the object from scope
this.size = evaluateExpression(this.sizeObjectName);
}
if (size == null)
{
throw new JspTagException(Messages.getString("MissingAttributeException.msg", new Object[]{"size"}));
}
else if (!(size instanceof Integer))
{
throw new JspTagException(Messages.getString(
"InvalidTypeException.msg",
new Object[]{"size", "Integer"}));
}
}
// do we really need to skip any row?
boolean wishOptimizedIteration = ((this.pagesize > 0 // we are paging
|| this.offset > 0 // or we are skipping some records using offset
|| this.length > 0 // or we are limiting the records using length
) && !partialList); // only optimize if we have the full list
// can we actually skip any row?
if (wishOptimizedIteration && (this.list instanceof Collection) // we need to know the size
&& ((sortColumn == -1 // and we are not sorting
|| !finalSortFull // or we are sorting with the "page" behaviour
) && (this.currentMediaType == MediaTypeEnum.HTML // and we are not exporting
|| !this.properties.getExportFullList()) // or we are exporting a single page
))
{
int start = 0;
int end = 0;
if (this.offset > 0)
{
start = this.offset;
}
if (length > 0)
{
end = start + this.length;
}
if (this.pagesize > 0)
{
int fullSize = ((Collection) this.list).size();
start = (this.pageNumber - 1) * this.pagesize;
// invalid page requested, go back to last page
if (start > fullSize)
{
int div = fullSize / this.pagesize;
start = (fullSize % this.pagesize == 0) ? div : div + 1;
}
end = start + this.pagesize;
}
// rowNumber starts from 1
filteredRows = new LongRange(start + 1, end);
}
else
{
filteredRows = new LongRange(1, Long.MAX_VALUE);
}
this.tableIterator = IteratorUtils.getIterator(this.list);
}
/**
* Is the current row included in the "to-be-evaluated" range? Called by nested ColumnTags. If <code>false</code>
* column body is skipped.
* @return <code>true</code> if the current row must be evaluated because is included in output or because is
* included in sorting.
*/
protected boolean isIncludedRow()
{
return ((Range) filteredRows).containsLong(this.rowNumber);
}
/**
* Create a complete string for compatibility with previous version before expression evaluation. This approach is
* optimized for new expressions, not for previous property/scope parameters.
* @return Expression composed by scope + name + property
*/
private String getFullObjectName()
{
// only evaluate if needed, else preserve original list
if (this.name == null)
{
return null;
}
return this.name;
}
/**
* init the href object used to generate all the links for pagination, sorting, exporting.
* @param requestHelper request helper used to extract the base Href
*/
protected void initHref(RequestHelper requestHelper)
{
// get the href for this request
this.baseHref = requestHelper.getHref();
if (this.excludedParams != null)
{
String[] splittedExcludedParams = StringUtils.split(this.excludedParams);
// handle * keyword
if (splittedExcludedParams.length == 1 && "*".equals(splittedExcludedParams[0]))
{
// @todo cleanup: paramEncoder initialization should not be done here
if (this.paramEncoder == null)
{
this.paramEncoder = new ParamEncoder(getUid());
}
Iterator paramsIterator = baseHref.getParameterMap().keySet().iterator();
while (paramsIterator.hasNext())
{
String key = (String) paramsIterator.next();
// don't remove parameters added by the table tag
if (!this.paramEncoder.isParameterEncoded(key))
{
baseHref.removeParameter(key);
}
}
}
else
{
for (int j = 0; j < splittedExcludedParams.length; j++)
{
baseHref.removeParameter(splittedExcludedParams[j]);
}
}
}
if (this.requestUri != null)
{
// if user has added a requestURI create a new href
String fullURI = requestUri;
if (!this.dontAppendContext)
{
String contextPath = ((HttpServletRequest) this.pageContext.getRequest()).getContextPath();
// prepend the context path if any.
// actually checks if context path is already there for people which manually add it
if (!StringUtils.isEmpty(contextPath)
&& requestUri != null
&& requestUri.startsWith("/")
&& !requestUri.startsWith(contextPath))
{
fullURI = contextPath + this.requestUri;
}
}
// call encodeURL to preserve session id when cookies are disabled
fullURI = ((HttpServletResponse) this.pageContext.getResponse()).encodeURL(fullURI);
baseHref.setFullUrl(fullURI);
// // ... and copy parameters from the current request
// Map parameterMap = normalHref.getParameterMap();
// this.baseHref.addParameterMap(parameterMap);
}
}
/**
* Draw the table. This is where everything happens, we figure out what values we are supposed to be showing, we
* figure out how we are supposed to be showing them, then we draw them.
* @return int
* @throws JspException generic exception
* @see javax.servlet.jsp.tagext.Tag#doEndTag()
*/
public int doEndTag() throws JspException
{
if (log.isDebugEnabled())
{
log.debug("[" + getUid() + "] doEndTag called");
}
if (!this.doAfterBodyExecuted)
{
if (log.isDebugEnabled())
{
log.debug("[" + getUid() + "] tag body is empty.");
}
// first row (created in doStartTag)
if (this.currentRow != null)
{
// if yes add to table model and remove
this.tableModel.addRow(this.currentRow);
}
// other rows
while (this.tableIterator.hasNext())
{
Object iteratedObject = this.tableIterator.next();
this.rowNumber++;
// Row object for Cell values
this.currentRow = new Row(iteratedObject, this.rowNumber);
this.tableModel.addRow(this.currentRow);
}
}
// if no rows are defined automatically get all properties from bean
if (this.tableModel.isEmpty())
{
describeEmptyTable();
}
TableDecorator tableDecorator = this.properties.getDecoratorFactoryInstance().
loadTableDecorator(this.pageContext, getConfiguredDecoratorName());
if (tableDecorator != null)
{
tableDecorator.init(this.pageContext, this.list, this.tableModel);
this.tableModel.setTableDecorator(tableDecorator);
}
setupViewableData();
// Figure out how we should sort this data, typically we just sort
// the data being shown, but the programmer can override this behavior
if (this.paginatedList == null && this.tableModel.isLocalSort())
{
if (!this.tableModel.isSortFullTable())
{
this.tableModel.sortPageList();
}
}
// Get the data back in the representation that the user is after, do they want HTML/XML/CSV/EXCEL/etc...
int returnValue = EVAL_PAGE;
// check for nested tables
// Object previousMediaType = this.pageContext.getAttribute(PAGE_ATTRIBUTE_MEDIA);
Object previousMediaType = this.pageContext.getAttribute(PAGE_ATTRIBUTE_MEDIA);
if (MediaTypeEnum.HTML.equals(this.currentMediaType)
&& (previousMediaType == null || MediaTypeEnum.HTML.equals(previousMediaType)))
{
writeHTMLData();
}
else if (!MediaTypeEnum.HTML.equals(this.currentMediaType))
{
if (log.isDebugEnabled())
{
log.debug("[" + getUid() + "] doEndTag - exporting");
}
returnValue = doExport();
}
// do not remove media attribute! if the table is nested in other tables this is still needed
// this.pageContext.removeAttribute(PAGE_ATTRIBUTE_MEDIA);
if (log.isDebugEnabled())
{
log.debug("[" + getUid() + "] doEndTag - end");
}
cleanUp();
return returnValue;
}
/**
* Returns the name of the table decorator that should be applied to this table,
* which is either the decorator configured in the property "decorator", or if
* none is configured in said property, a decorator configured with the
* "decorator.media.[media type]" property, or null if none is configured.
*
* @return Name of the table decorator that should be applied to this table.
*/
private String getConfiguredDecoratorName()
{
String
tableDecoratorName = (this.decoratorName == null) ?
this.properties.getMediaTypeDecoratorName(this.currentMediaType) :
this.decoratorName;
tableDecoratorName = (tableDecoratorName == null) ?
this.properties.getExportDecoratorName(this.currentMediaType) :
tableDecoratorName;
return tableDecoratorName;
}
/**
* clean up instance variables, but not the ones representing tag attributes.
*/
private void cleanUp()
{
// reset instance variables (non attributes)
this.currentMediaType = null;
this.baseHref = null;
this.caption = null;
this.captionTag = null;
this.currentRow = null;
this.doAfterBodyExecuted = false;
this.footer = null;
this.listHelper = null;
this.pageNumber = 0;
this.paramEncoder = null;
this.properties = null;
this.rowNumber = 1;
this.tableIterator = null;
this.tableModel = null;
this.list = null;
}
/**
* If no columns are provided, automatically add them from bean properties. Get the first object in the list and get
* all the properties (except the "class" property which is automatically skipped). Of course this isn't possible
* for empty lists.
*/
private void describeEmptyTable()
{
this.tableIterator = IteratorUtils.getIterator(this.list);
if (this.tableIterator.hasNext())
{
Object iteratedObject = this.tableIterator.next();
Map objectProperties = new HashMap();
// if it's a String don't add the "Bytes" column
if (iteratedObject instanceof String)
{
return;
}
// if it's a map already use key names for column headers
if (iteratedObject instanceof Map)
{
objectProperties = (Map) iteratedObject;
}
else
{
try
{
objectProperties = BeanUtils.describe(iteratedObject);
}
catch (Exception e)
{
log.warn("Unable to automatically add columns: " + e.getMessage(), e);
}
}
// iterator on properties names
Iterator propertiesIterator = objectProperties.keySet().iterator();
while (propertiesIterator.hasNext())
{
// get the property name
String propertyName = (String) propertiesIterator.next();
// dont't want to add the standard "class" property
if (!"class".equals(propertyName)) //$NON-NLS-1$
{
// creates a new header and add to the table model
HeaderCell headerCell = new HeaderCell();
headerCell.setBeanPropertyName(propertyName);
// handle title i18n
headerCell.setTitle(this.properties.geResourceProvider().getResource(
null,
propertyName,
this,
this.pageContext));
this.tableModel.addColumnHeader(headerCell);
}
}
}
}
/**
* Called when data are not displayed in a html page but should be exported.
* @return int SKIP_PAGE
* @throws JspException generic exception
*/
protected int doExport() throws JspException
{
boolean exportFullList = this.properties.getExportFullList();
if (log.isDebugEnabled())
{
log.debug("[" + getUid() + "] currentMediaType=" + this.currentMediaType);
}
boolean exportHeader = this.properties.getExportHeader(this.currentMediaType);
boolean exportDecorated = this.properties.getExportDecorated();
ExportView exportView = ExportViewFactory.getInstance().getView(
this.currentMediaType,
this.tableModel,
exportFullList,
exportHeader,
exportDecorated);
try
{
writeExport(exportView);
}
catch (IOException e)
{
throw new WrappedRuntimeException(getClass(), e);
}
return SKIP_PAGE;
}
/**
* Will write the export. The default behavior is to write directly to the response. If the ResponseOverrideFilter
* is configured for this request, will instead write the exported content to a map in the Request object.
* @param exportView export view
* @throws JspException for problem in clearing the response or for invalid export views
* @throws IOException exception thrown when writing content to the response
*/
protected void writeExport(ExportView exportView) throws IOException, JspException
{
String filename = properties.getExportFileName(this.currentMediaType);
HttpServletResponse response = (HttpServletResponse) this.pageContext.getResponse();
HttpServletRequest request = (HttpServletRequest) this.pageContext.getRequest();
Map bean = (Map) request.getAttribute(FILTER_CONTENT_OVERRIDE_BODY);
boolean usingFilter = bean != null;
String mimeType = exportView.getMimeType();
// original encoding, be sure to add it back after reset()
String characterEncoding = response.getCharacterEncoding();
if (usingFilter)
{
if (!bean.containsKey(TableTagParameters.BEAN_BUFFER))
{
// We are running under the export filter, call it
log.debug("Exportfilter enabled in unbuffered mode, setting headers");
response.addHeader(TableTagParameters.PARAMETER_EXPORTING, TagConstants.EMPTY_STRING);
}
else
{
// We are running under the export filter in buffered mode
bean.put(TableTagParameters.BEAN_CONTENTTYPE, mimeType);
bean.put(TableTagParameters.BEAN_FILENAME, filename);
if (exportView instanceof TextExportView)
{
StringWriter writer = new StringWriter();
((TextExportView) exportView).doExport(writer);
bean.put(TableTagParameters.BEAN_BODY, writer.toString());
}
else if (exportView instanceof BinaryExportView)
{
ByteArrayOutputStream stream = new ByteArrayOutputStream();
((BinaryExportView) exportView).doExport(stream);
bean.put(TableTagParameters.BEAN_BODY, stream.toByteArray());
}
else
{
throw new JspTagException("Export view "
+ exportView.getClass().getName()
+ " must implement TextExportView or BinaryExportView");
}
return;
}
}
else
{
log.debug("Exportfilter NOT enabled");
// response can't be already committed at this time
if (response.isCommitted())
{
throw new ExportException(getClass());
}
try
{
response.reset();
pageContext.getOut().clearBuffer();
}
catch (Exception e)
{
throw new ExportException(getClass());
}
}
if (!usingFilter && characterEncoding != null && mimeType.indexOf("charset") == -1) //$NON-NLS-1$
{
mimeType += "; charset=" + characterEncoding; //$NON-NLS-1$
}
response.setContentType(mimeType);
if (StringUtils.isNotEmpty(filename))
{
response.setHeader("Content-Disposition", //$NON-NLS-1$
"attachment; filename=\"" + filename + "\""); //$NON-NLS-1$ //$NON-NLS-2$
}
if (exportView instanceof TextExportView)
{
Writer writer;
if (usingFilter)
{
writer = response.getWriter();
}
else
{
writer = pageContext.getOut();
}
((TextExportView) exportView).doExport(writer);
}
else if (exportView instanceof BinaryExportView)
{
// dealing with binary content
// note that this is not assured to work on any application server if the filter is not enabled. According
// to the jsp specs response.getOutputStream() should no be called in jsps.
((BinaryExportView) exportView).doExport(response.getOutputStream());
}
else
{
throw new JspTagException("Export view "
+ exportView.getClass().getName()
+ " must implement TextExportView or BinaryExportView");
}
log.debug("Export completed");
}
/**
* This sets the list of all of the data that will be displayed on the page via the table tag. This might include
* just a subset of the total data in the list due to to paging being active, or the user asking us to just show a
* subset, etc...
*/
protected void setupViewableData()
{
// If the user has changed the way our default behavior works, then we need to look for it now, and resort
// things if needed before we ask for the viewable part. (this is a bad place for this, this should be
// refactored and moved somewhere else).
if (this.paginatedList == null || this.tableModel.isLocalSort())
{
if (this.tableModel.isSortFullTable())
{
// Sort the total list...
this.tableModel.sortFullList();
}
}
Object originalData = this.tableModel.getRowListFull();
// If they have asked for a subset of the list via the length
// attribute, then only fetch those items out of the master list.
List fullList = CollectionUtil.getListFromObject(originalData, this.offset, this.length);
int pageOffset = this.offset;
// If they have asked for just a page of the data, then use the
// SmartListHelper to figure out what page they are after, etc...
if (this.paginatedList == null && this.pagesize > 0)
{
this.listHelper = new SmartListHelper(fullList, (this.partialList) ? ((Integer) size).intValue() : fullList
.size(), this.pagesize, this.properties, this.partialList);
this.listHelper.setCurrentPage(this.pageNumber);
pageOffset = this.listHelper.getFirstIndexForCurrentPage();
fullList = this.listHelper.getListForCurrentPage();
}
else if (this.paginatedList != null)
{
this.listHelper = new PaginatedListSmartListHelper(this.paginatedList, this.properties);
}
this.tableModel.setRowListPage(fullList);
this.tableModel.setPageOffset(pageOffset);
}
/**
* Uses HtmlTableWriter to write table called when data have to be displayed in a html page.
* @throws JspException generic exception
*/
private void writeHTMLData() throws JspException
{
JspWriter out = this.pageContext.getOut();
String css = this.properties.getCssTable();
if (StringUtils.isNotBlank(css))
{
this.addClass(css);
}
// use HtmlTableWriter to write table
new HtmlTableWriter(
this.tableModel,
this.properties,
this.baseHref,
this.export,
out,
getCaptionTag(),
this.paginatedList,
this.listHelper,
this.pagesize,
getAttributeMap(),
this.uid).writeTable(this.tableModel, this.getUid());
if (this.varTotals != null)
{
pageContext.setAttribute(this.varTotals, getTotals());
}
}
/**
* Get the column totals Map. If there is no varTotals defined, there are no totals.
* @return a Map of totals where the key is the column number and the value is the total for that column
*/
public Map getTotals()
{
Map totalsMap = new HashMap();
if (this.varTotals != null)
{
List headers = this.tableModel.getHeaderCellList();
for (Iterator iterator = headers.iterator(); iterator.hasNext();)
{
HeaderCell headerCell = (HeaderCell) iterator.next();
if (headerCell.isTotaled())
{
totalsMap.put("column" + (headerCell.getColumnNumber() + 1), new Double(headerCell.getTotal()));
}
}
}
return totalsMap;
}
/**
* Get the table model for this tag. Sometimes required by local tags that cooperate with DT. USE THIS METHOD WITH
* EXTREME CAUTION; IT PROVIDES ACCESS TO THE INTERNALS OF DISPLAYTAG, WHICH ARE NOT TO BE CONSIDERED STABLE PUBLIC
* INTERFACES.
* @return the TableModel
*/
public TableModel getTableModel()
{
return this.tableModel;
}
/**
* Called by the setProperty tag to override some default behavior or text String.
* @param propertyName String property name
* @param propertyValue String property value
*/
public void setProperty(String propertyName, String propertyValue)
{
this.properties.setProperty(propertyName, propertyValue);
}
/**
* @see javax.servlet.jsp.tagext.Tag#release()
*/
public void release()
{
if (log.isDebugEnabled())
{
log.debug("[" + getUid() + "] release() called");
}
super.release();
// tag attributes
this.decoratorName = null;
this.defaultSortedColumn = -1;
this.defaultSortOrder = null;
this.export = false;
this.length = 0;
this.listAttribute = null;
this.localSort = true;
this.name = null;
this.offset = 0;
this.pagesize = 0;
this.partialList = false;
this.requestUri = null;
this.dontAppendContext = false;
this.sortFullTable = null;
this.excludedParams = null;
this.filteredRows = null;
this.uid = null;
this.paginatedList = null;
}
/**
* Returns the name.
* @return String
*/
protected String getName()
{
return this.name;
}
/**
* encode a parameter name to be unique in the page using ParamEncoder.
* @param parameterName parameter name to encode
* @return String encoded parameter name
*/
private String encodeParameter(String parameterName)
{
// paramEncoder has been already instantiated?
if (this.paramEncoder == null)
{
// use the id attribute to get the unique identifier
this.paramEncoder = new ParamEncoder(getUid());
}
return this.paramEncoder.encodeParameterName(parameterName);
}
}