Java tutorial
/* * Weblounge: Web Content Management System * Copyright (c) 2003 - 2011 The Weblounge Team * http://entwinemedia.com/weblounge * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software Foundation * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ package ch.entwine.weblounge.common.impl.request; import static ch.entwine.weblounge.common.editor.EditingState.STATE_COOKIE; import static ch.entwine.weblounge.common.editor.EditingState.WORKBENCH_PARAM; import static ch.entwine.weblounge.common.editor.EditingState.WORKBENCH_PREVIEW_PARAM; import static ch.entwine.weblounge.common.impl.security.SystemRole.EDITOR; import static java.lang.Boolean.TRUE; import ch.entwine.weblounge.common.editor.EditingState; import ch.entwine.weblounge.common.impl.security.SecurityUtils; import ch.entwine.weblounge.common.impl.site.ActionSupport; import ch.entwine.weblounge.common.impl.site.PrecompileHttpServletRequest; import ch.entwine.weblounge.common.impl.testing.MockHttpServletRequest; import ch.entwine.weblounge.common.request.WebloungeRequest; import ch.entwine.weblounge.common.site.Action; import org.apache.commons.lang.StringUtils; import org.apache.commons.lang.time.DateUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.net.URLDecoder; import java.text.ParseException; import java.util.ArrayList; import java.util.Date; import java.util.Enumeration; import java.util.List; import javax.servlet.ServletRequest; import javax.servlet.http.Cookie; import javax.servlet.http.HttpServletRequestWrapper; /** * Utility implementation to deal with <code>HttpRequest</code> objects. */ public final class RequestUtils { /** Logging facility */ private static final Logger logger = LoggerFactory.getLogger(ActionSupport.class); /** * RequestSupport is a static class and therefore has no constructor. */ private RequestUtils() { } /** * Returns true if an action is set as request attribute * <code>WebloungeRequest.ACTION</code>. * * @param request * the request * @return true if an action is found as request attribute */ public static boolean containsAction(WebloungeRequest request) { Action action = (Action) request.getAttribute(WebloungeRequest.ACTION); return action != null; } /** * Returns a string representation of the request headers. * * @param request * the request * @return the headers */ public static String dumpHeaders(WebloungeRequest request) { Enumeration<?> hn = request.getHeaderNames(); String headers = "Request headers:"; while (hn.hasMoreElements()) { String header = (String) hn.nextElement(); String value = request.getHeader(header); headers = headers.concat(header).concat(": ").concat(value); } return headers; } /** * Returns a string representation of the request parameters. * * @param request * the request * @return the request parameters */ public static String dumpParameters(WebloungeRequest request) { StringBuffer params = new StringBuffer(); Enumeration<?> e = request.getParameterNames(); while (e.hasMoreElements()) { String param = (String) e.nextElement(); String value = request.getParameter(param); if (params.length() > 0) { params.append(";"); } params.append(param); params.append("="); params.append(value); } return (params.length() > 0) ? params.toString() : "-"; } /** * Returns the extension part of the requested url. For example, if an action * is mounted to <code>/test</code> and the url is <code>/test/a</code> then * this method will return <code>/a</code>. For the mount point itself, the * method will return <code>/</code>. * * @param request * the weblounge request * @param action * the action * @return the path extension relative to the action's mount point */ public static String getRequestedUrlExtension(WebloungeRequest request, Action action) { if (request == null) throw new IllegalStateException("Request has not started"); return request.getRequestedUrl().getPath().substring(action.getPath().length()); } /** * Returns a list of parameters found in the path extension requested url * (split by '/'). For example, if an action is mounted to <code>/test</code> * and the url is <code>/test/a/b/c</code> then this method will return a list * with the values 'a', 'b' and 'c'. For the mount point itself, the method * will return an empty list. * * @param request * the weblounge request * @param action * the action * @return a list with parameters found in the path extension of the action's * mount point */ public static List<String> getRequestedUrlParams(WebloungeRequest request, Action action) { // load parameter values from url extension List<String> urlparams = new ArrayList<String>(); String path = request.getRequestedUrl().getPath(); String actionMountpoint = action.getPath(); String[] params = path.substring(actionMountpoint.length()).split("/"); for (int i = 0; i < params.length; i++) { urlparams.add(params[i]); } return urlparams; } /** * Returns the extension part of the target url. For example, if an action is * mounted to <code>/test</code> and the url is <code>/test/a</code> then this * method will return <code>/a</code>. For the mount point itself, the method * will return <code>/</code>. * * @param request * the weblounge request * @param action * the action * @return the path extension relative to the action's mount point */ public static String getUrlExtension(WebloungeRequest request, Action action) { if (request == null) throw new IllegalStateException("Request has not started"); return request.getUrl().getPath().substring(action.getPath().length()); } /** * Returns a list of parameters found in the extension part of the targeted * url (split by '/'). For example, if an action is mounted to * <code>/test</code> and the url is <code>/test/a/b/c</code> then this method * will return a list with the values 'a', 'b' and 'c'. For the mount point * itself, the method will return an empty list. * * @param request * the weblounge request * @param action * the action * @return a list with parameters found in the path extension of the action's * mount point */ public static List<String> getUrlParams(WebloungeRequest request, Action action) { // load parameter values from url extension List<String> urlparams = new ArrayList<String>(); String path = request.getUrl().getPath(); String actionMountpoint = action.getPath(); String[] params = path.substring(actionMountpoint.length()).split("/"); for (int i = 0; i < params.length; i++) { urlparams.add(params[i]); } return urlparams; } /** * Checks if the parameter <code>parameter</code> is present in the request * and is not equal to the empty string. In this case, the parameter itself is * returned, <code>null</code> otherwise. * <p> * Note that this method includes the check for <tt>hidden</tt> parameters. * * @param request * the weblounge request * @param parameter * the parameter name * @return the parameter value or <code>null</code> if the parameter is not * available */ public static String getParameter(WebloungeRequest request, String parameter) { String p = request.getParameter(parameter); if (p != null) { try { p = decode(p, "utf-8"); } catch (UnsupportedEncodingException e) { logger.error("Encoding 'utf-8' is not supported on this platform"); } } return StringUtils.trimToNull(p); } /** * Checks a parameter <code>parameter</code> is present in the url of the * request at the indicated position, starting with the action's mountpoint. * In this case, the parameter itself is returned, <code>null</code> * otherwise. * * @param request * the weblounge request * @param index * the parameter index * @return the parameter value or <code>null</code> if the parameter is not * available */ public static String getParameter(WebloungeRequest request, Action action, int index) { List<String> urlparams = getRequestedUrlParams(request, action); // Did we extract as many parameters as we should? if (index >= urlparams.size()) return null; String p = urlparams.get(index); try { p = decode(p, "utf-8"); } catch (UnsupportedEncodingException e) { logger.error("Encoding 'utf-8' is not supported on this platform"); } return StringUtils.trimToNull(p); } /** * Ensures parameter values potentially containing the <code>%</code> * character are decoded properly using the <code>utf-8</code> encoding. * * @param s * the parameter value * @param encoding * the character encoding to be used * @return the properly decoded value * @throws UnsupportedEncodingException * if <code>encoding</code> is not supported by the plattform */ static String decode(String s, String encoding) throws UnsupportedEncodingException { s = StringUtils.trimToEmpty(s); while (true) { try { return URLDecoder.decode(s, encoding); } catch (IllegalArgumentException e) { // Illegal hex characters in escape (%) pattern - For input string: "si" String m = e.getMessage(); String illegalSequence = m.substring(m.length() - 3, m.length() - 1); s = s.replaceAll("%" + illegalSequence, "%25" + illegalSequence); } } } /** * Checks if the parameter <code>parameter</code> is present in the request * and is not equal to the empty string. In this case, the parameter itself is * returned, <code>defaultValue</code> otherwise. * <p> * Note that this method includes the check for <tt>hidden</tt> parameters. * * @param request * the weblounge request * @param parameter * the parameter name * @param defaultValue * the default parameter value * @return the parameter value or <code>defaultValue</code> if the parameter * is not available */ public static String getParameterWithDefault(WebloungeRequest request, String parameter, String defaultValue) { String p = getParameter(request, parameter); return (p != null) ? p : defaultValue; } /** * Checks a parameter <code>parameter</code> is present in the url of the * request at the indicated position, starting with the action's mountpoint. * In this case, the parameter itself is returned, <code>defaultValue</code> * otherwise. * * @param request * the weblounge request * @param index * the parameter index * @param defaultValue * the default parameter value * @return the parameter value or <code>defaultValue</code> if the parameter * is not available */ public static String getParameterWithDefault(WebloungeRequest request, Action action, int index, String defaultValue) { String p = getParameter(request, action, index); return (p != null) ? p : defaultValue; } /** * Checks if the parameter <code>parameter</code> is present in the request * and is not equal to the empty string. In this case, the parameter itself is * returned, while a <code>IllegalStateException</code> is thrown otherwise. * * @param request * the weblounge request * @param parameter * the parameter name * @return the parameter * @throws IllegalStateException * if the parameter was not found in the request */ public static String getRequiredParameter(WebloungeRequest request, String parameter) throws IllegalStateException { String p = getParameter(request, parameter); if (p == null) throw new IllegalStateException("Request parameter '" + parameter + "' is mandatory"); return p; } /** * Checks a parameter <code>parameter</code> is present in the url of the * request at the indicated position, starting with the action's mountpoint. * In this case, the parameter itself is returned, while a * <code>IllegalStateException</code> is thrown otherwise. * * @param request * the weblounge request * @param parameter * the parameter index * @throws IllegalStateException * if the parameter was not found in the request */ public static String getRequiredParameter(WebloungeRequest request, Action action, int parameter) { String p = getParameter(request, action, parameter); if (p == null) throw new IllegalStateException("Url parameter at " + parameter + " is mandatory"); return p; } /** * Checks if the parameter <code>parameter</code> is present in the request * and is not equal to the empty string. In this case, the parameter itself is * returned, <code>null</code> otherwise. * <p> * The parameter is decoded using the specified <code>encoding</code>. * * @param request * the weblounge request * @param parameter * the parameter name * @param decoding * the encoding parameter, e. g. <code>utf-8</code> * @return the decoded parameter value or <code>null</code> if the parameter * is not available */ public static String getParameterWithDecoding(WebloungeRequest request, String parameter, String decoding) { String p = request.getParameter(parameter); if (p != null) { p = p.trim(); if ("application/x-www-form-urlencoded".equalsIgnoreCase(request.getContentType())) { try { p = decode(p, decoding); } catch (UnsupportedEncodingException e) { throw new IllegalArgumentException("Encoding " + decoding + " is unsupported"); } catch (IllegalArgumentException e) { // Tried decoding a string with a % inside, so obviously the // parameter // was decoded already } } } return StringUtils.trimToNull(p); } /** * Checks if the parameter <code>parameter</code> is present in the request * and is not equal to the empty string. * * @param request * the weblounge request * @param parameter * the parameter name * @return <code>true</code> if the parameter is available */ public static boolean parameterExists(WebloungeRequest request, String parameter) { String p = getParameter(request, parameter); return StringUtils.trimToNull(p) != null; } /** * Checks if the parameter <code>parameter</code> is present in the request * and is not equal to the empty string. * * @param request * the weblounge request * @param parameter * the parameter index * @return <code>true</code> if the parameter is available */ public static boolean parameterExists(WebloungeRequest request, Action action, int parameter) { String p = getParameter(request, action, parameter); return StringUtils.trimToNull(p) != null; } /** * Checks if the parameter <code>parameterName</code> is present in the * request and represents a valid <code>short</code>. In that case, the * parameter is returned as a <code>short</code>, otherwise <code>0</code> is * returned. * * @param request * the weblounge request * @param parameterName * the parameter name * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>short</code> */ public static short getShortParameter(WebloungeRequest request, String parameterName) throws IllegalArgumentException { return getShortParameter(request, parameterName, false); } /** * Checks if a parameter is present in the url at position * <code>parameter</code> and represents a valid <code>short</code>. In that * case, the parameter is returned as a <code>short</code>, otherwise * <code>0</code> is returned. * * @param request * the weblounge request * @param parameterName * the parameter name * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>short</code> */ public static short getShortParameter(WebloungeRequest request, Action action, int parameter) throws IllegalArgumentException { return getShortParameter(request, action, parameter, false); } /** * Checks if the parameter <code>parameterName</code> is present in the * request and represents a valid <code>short</code>. Should the parameter be * part of the request, it's value is returned as a <code>short</code> whereas * otherwise the <code>defaultValue</code> is returned instead. * * @param request * the weblounge request * @param parameterName * the parameter name * @param defaultValue * the default parameter value * @return the parameter value or <code>defaultValue</code> if the parameter * is not available * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>short</code> */ public static short getShortParameterWithDefault(WebloungeRequest request, String parameterName, short defaultValue) throws IllegalArgumentException { try { return getShortParameter(request, parameterName, true); } catch (IllegalStateException e) { return defaultValue; } } /** * Checks if a parameter is present in the url at position <code>index</code> * and represents a valid <code>short</code>. Should the parameter be part of * the request, it's value is returned as a <code>short</code> whereas * otherwise the <code>defaultValue</code> is returned instead. * * @param request * the weblounge request * @param index * the parameter index * @return the parameter value or <code>defaultValue</code> if the parameter * is not available * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>short</code> */ public static short getShortParameterWithDefault(WebloungeRequest request, Action action, int index, short defaultValue) throws IllegalArgumentException { try { return getShortParameter(request, action, index, true); } catch (IllegalStateException e) { return defaultValue; } } /** * Checks if the parameter <code>parameterName</code> is present in the * request and represents a valid <code>short</code>. Should the parameter not * be part of the request, <code>defaultValue</code> is returned, otherwise * the parameter value is returned as a <code>short</code>. * * @param request * the weblounge request * @param parameterName * the parameter name * @param defaultValue * the default parameter value * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>short</code> * @throws IllegalStateException * if the parameter was not found in the request */ public static short getRequiredShortParameter(WebloungeRequest request, String parameterName) throws IllegalArgumentException, IllegalStateException { return getShortParameter(request, parameterName, true); } /** * Checks if a parameter is present at position <code>index</code> in the url * whether it represents a valid <code>short</code>. In this case, that * parameter is returned as a <code>short</code> value, whereas otherwise a * {@link IllegalStateException} is thrown. * * @param request * the weblounge request * @param action * the weblounge action * @param index * the parameter index * @return the parameter value * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>short</code> * @throws IllegalStateException * if the parameter was not found in the request */ public static short getRequiredShortParameter(WebloungeRequest request, Action action, int index) throws IllegalArgumentException, IllegalStateException { return getShortParameter(request, action, index, true); } /** * Checks if the parameter <code>parameter</code> is present in the request * and is a valid <code>short</code>. In that case, the parameter is returned * as a <code>short</code>, otherwise <code>0</code> is returned. * <p> * If the parameter is required, then an {@link IllegalStateException} is * thrown. * * @param request * the weblounge request * @param parameterName * the parameter name * @param required * <code>true</code> if this parameter is mandatory * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>short</code> * @throws IllegalStateException * if the parameter was not found in the request */ private static short getShortParameter(WebloungeRequest request, String parameterName, boolean required) throws IllegalArgumentException, IllegalStateException { String p = null; if (required) p = getRequiredParameter(request, parameterName); else p = getParameter(request, parameterName); if (p == null) return 0; try { return Short.valueOf(p); } catch (NumberFormatException e) { throw new IllegalArgumentException("Request parameter '" + parameterName + "' must be a short"); } } /** * Checks if a parameter is present in the url at position * <code>parameter</code> and represents a valid <code>short</code>. In that * case, the parameter is returned as a <code>short</code>, otherwise * <code>0</code> is returned. * <p> * If the parameter is required, and it is not part of the url, then an * {@link IllegalStateException} is thrown. * * @param request * the weblounge request * @param action * the action that determines the mountpoint * @param index * the index of the parameter in the url * @param required * <code>true</code> if this parameter is mandatory * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>short</code> * @throws IllegalStateException * if the parameter was not found in the request */ private static short getShortParameter(WebloungeRequest request, Action action, int index, boolean required) throws IllegalArgumentException, IllegalStateException { String p = null; if (required) p = getRequiredParameter(request, action, index); else p = getParameter(request, action, index); if (p == null) return 0; try { return Short.valueOf(p); } catch (NumberFormatException e) { throw new IllegalArgumentException("Url parameter at index " + index + " must be a short"); } } /** * Checks if the parameter <code>parameter</code> is present in the request * and represents a valid <code>int</code>. In that case, the parameter is * returned as a <code>int</code>, otherwise <code>0</code> is returned. * * @param request * the weblounge request * @param parameterName * the parameter name * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>int</code> */ public static int getIntegerParameter(WebloungeRequest request, String parameterName) throws IllegalArgumentException { return getIntegerParameter(request, parameterName, false); } /** * Checks if the parameter <code>parameter</code> is present in the request * and represents a valid <code>int</code>. Should the parameter not be part * of the request, <code>defaultValue</code> is returned, otherwise the * parameter value is returned as an <code>int</code>. * * @param request * the weblounge request * @param parameterName * the parameter name * @param defaultValue * the default parameter value * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>int</code> */ public static int getIntegerParameterWithDefault(WebloungeRequest request, String parameterName, int defaultValue) throws IllegalArgumentException { try { return getIntegerParameter(request, parameterName, true); } catch (IllegalStateException e) { return defaultValue; } } /** * Checks if a parameter is present in the url at position * <code>parameter</code> and represents a valid <code>int</code>. Should the * parameter be part of the request, it's value is returned as a * <code>int</code> whereas otherwise the <code>defaultValue</code> is * returned instead. * * @param request * the weblounge request * @param index * the parameter index * @return the parameter value or <code>defaultValue</code> if the parameter * is not available * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>int</code> */ public static int getIntegerParameterWithDefault(WebloungeRequest request, Action action, int index, int defaultValue) throws IllegalArgumentException { try { return getIntegerParameter(request, action, index, true); } catch (IllegalStateException e) { return defaultValue; } } /** * Checks if the parameter <code>parameter</code> is present in the request * and is a valid <code>int</code>. Should the parameter not be part of the * request, <code>0</code> is returned, otherwise the parameter value is * returned as an <code>int</code>. * <p> * If the parameter is required, then an {@link IllegalStateException} is * thrown. * * @param request * the weblounge request * @param parameterName * the parameter name * @param required * <code>true</code> if this parameter is mandatory * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>int</code> * @throws IllegalStateException * if the parameter was not found in the request */ private static int getIntegerParameter(WebloungeRequest request, String parameterName, boolean required) throws IllegalArgumentException, IllegalStateException { String p = null; if (required) p = getRequiredParameter(request, parameterName); else p = getParameter(request, parameterName); if (p == null) return 0; try { return Integer.valueOf(p); } catch (NumberFormatException e) { throw new IllegalArgumentException("Request parameter '" + parameterName + "' must be an int"); } } /** * Checks if a parameter is present in the url at position * <code>parameter</code> and represents a valid <code>int</code>. In that * case, the parameter is returned as a <code>int</code>, otherwise * <code>0</code> is returned. * <p> * If the parameter is required, and it is not part of the url, then an * {@link IllegalStateException} is thrown. * * @param request * the weblounge request * @param action * the action that determines the mountpoint * @param index * the index of the parameter in the url * @param required * <code>true</code> if this parameter is mandatory * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>int</code> * @throws IllegalStateException * if the parameter was not found in the request */ private static int getIntegerParameter(WebloungeRequest request, Action action, int index, boolean required) throws IllegalArgumentException, IllegalStateException { String p = null; if (required) p = getRequiredParameter(request, action, index); else p = getParameter(request, action, index); if (p == null) return 0; try { return Integer.valueOf(p); } catch (NumberFormatException e) { throw new IllegalArgumentException("Url parameter at index " + index + " must be a int"); } } /** * Checks if the parameter <code>parameterName</code> is present in the * request and represents a valid <code>int</code>. Should the parameter not * be part of the request, <code>defaultValue</code> is returned, otherwise * the parameter value is returned as an <code>int</code>. * * @param request * the weblounge request * @param parameterName * the parameter name * @param defaultValue * the default parameter value * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>int</code> * @throws IllegalStateException * if the parameter was not found in the request */ public static int getRequiredIntegerParameter(WebloungeRequest request, String parameterName) throws IllegalArgumentException, IllegalStateException { return getIntegerParameter(request, parameterName, true); } /** * Checks if a parameter is present at position <code>index</code> in the url * whether it represents a valid <code>int</code>. In this case, that * parameter is returned as a <code>int</code> value, whereas otherwise a * {@link IllegalStateException} is thrown. * * @param request * the weblounge request * @param action * the weblounge action * @param index * the parameter index * @return the parameter value * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>int</code> * @throws IllegalStateException * if the parameter was not found in the request */ public static int getRequiredIntegerParameter(WebloungeRequest request, Action action, int index) throws IllegalArgumentException, IllegalStateException { return getIntegerParameter(request, action, index, true); } /** * Checks if the parameter <code>parameter</code> is present in the request * and represents a valid <code>long</code>. In that case, the parameter is * returned as a <code>long</code>, otherwise <code>0</code> is returned. * * @param request * the weblounge request * @param parameterName * the parameter name * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>long</code> */ public static long getLongParameter(WebloungeRequest request, String parameterName) throws IllegalArgumentException { return getLongParameter(request, parameterName, false); } /** * Checks if the parameter <code>parameterName</code> is present in the * request and represents a valid <code>long</code>. Should the parameter not * be part of the request, <code>defaultValue</code> is returned, otherwise * the parameter value is returned as an <code>long</code>. * * @param request * the weblounge request * @param parameterName * the parameter name * @param defaultValue * the default parameter value * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>long</code> */ public static long getLongParameterWithDefault(WebloungeRequest request, String parameterName, long defaultValue) throws IllegalArgumentException { try { return getLongParameter(request, parameterName, true); } catch (IllegalStateException e) { return defaultValue; } } /** * Checks if a parameter is present in the url at position <code>index</code> * and represents a valid <code>long</code>. Should the parameter be part of * the request, it's value is returned as a <code>long</code> whereas * otherwise the <code>defaultValue</code> is returned instead. * * @param request * the weblounge request * @param index * the parameter index * @return the parameter value or <code>defaultValue</code> if the parameter * is not available * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>long</code> */ public static long getLongParameterWithDefault(WebloungeRequest request, Action action, int index, long defaultValue) throws IllegalArgumentException { try { return getLongParameter(request, action, index, true); } catch (IllegalStateException e) { return defaultValue; } } /** * Checks if the parameter <code>parameter</code> is present in the request * and is a valid <code>long</code>. Should the parameter not be part of the * request, <code>0</code> is returned, otherwise the parameter value is * returned as an <code>long</code>. * <p> * If the parameter is required, then an {@link IllegalStateException} is * thrown. * * @param request * the weblounge request * @param parameterName * the parameter name * @param required * <code>true</code> if this parameter is mandatory * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>long</code> * @throws IllegalStateException * if the parameter was not found in the request */ private static long getLongParameter(WebloungeRequest request, String parameterName, boolean required) throws IllegalArgumentException, IllegalStateException { String p = null; if (required) p = getRequiredParameter(request, parameterName); else p = getParameter(request, parameterName); if (p == null) return 0; try { return Long.valueOf(p); } catch (NumberFormatException e) { throw new IllegalArgumentException("Request parameter '" + parameterName + "' must be a long"); } } /** * Checks if a parameter is present in the url at position * <code>parameter</code> and represents a valid <code>long</code>. In that * case, the parameter is returned as a <code>long</code>, otherwise * <code>0L</code> is returned. * <p> * If the parameter is required, and it is not part of the url, then an * {@link IllegalStateException} is thrown. * * @param request * the weblounge request * @param action * the action that determines the mountpoint * @param index * the index of the parameter in the url * @param required * <code>true</code> if this parameter is mandatory * @return the parameter value or <code>0L</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>long</code> * @throws IllegalStateException * if the parameter was not found in the request */ private static long getLongParameter(WebloungeRequest request, Action action, int index, boolean required) throws IllegalArgumentException, IllegalStateException { String p = null; if (required) p = getRequiredParameter(request, action, index); else p = getParameter(request, action, index); if (p == null) return 0L; try { return Long.valueOf(p); } catch (NumberFormatException e) { throw new IllegalArgumentException("Url parameter at index " + index + " must be a long"); } } /** * Checks if the parameter <code>parameterName</code> is present in the * request and represents a valid <code>long</code>. Should the parameter not * be part of the request, <code>defaultValue</code> is returned, otherwise * the parameter value is returned as an <code>long</code>. * * @param request * the weblounge request * @param parameterName * the parameter name * @param defaultValue * the default parameter value * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>long</code> * @throws IllegalStateException * if the parameter was not found in the request */ public static long getRequiredLongParameter(WebloungeRequest request, String parameterName) throws IllegalArgumentException, IllegalStateException { return getLongParameter(request, parameterName, true); } /** * Checks if a parameter is present at position <code>index</code> in the url * whether it represents a valid <code>long</code>. In this case, that * parameter is returned as a <code>long</code> value, whereas otherwise a * {@link IllegalStateException} is thrown. * * @param request * the weblounge request * @param action * the weblounge action * @param index * the parameter index * @return the parameter value * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>long</code> * @throws IllegalStateException * if the parameter was not found in the request */ public static long getRequiredLongParameter(WebloungeRequest request, Action action, int index) throws IllegalArgumentException, IllegalStateException { return getLongParameter(request, action, index, true); } /** * Checks if the parameter <code>parameter</code> is present in the request * and represents a valid <code>float</code>. In that case, the parameter is * returned as a <code>float</code>, otherwise <code>0.0f</code> is returned. * * @param request * the weblounge request * @param parameterName * the parameter name * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>float</code> */ public static float getFloatParameter(WebloungeRequest request, String parameterName) throws IllegalArgumentException { return getFloatParameter(request, parameterName, false); } /** * Checks if the parameter <code>parameterName</code> is present in the * request and represents a valid <code>float</code>. Should the parameter not * be part of the request, <code>defaultValue</code> is returned, otherwise * the parameter value is returned as an <code>float</code>. * * @param request * the weblounge request * @param parameterName * the parameter name * @param defaultValue * the default parameter value * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>float</code> */ public static float getFloatParameterWithDefault(WebloungeRequest request, String parameterName, float defaultValue) throws IllegalArgumentException { try { return getFloatParameter(request, parameterName, true); } catch (IllegalStateException e) { return defaultValue; } } /** * Checks if a parameter is present in the url at position * <code>parameter</code> and represents a valid <code>float</code>. Should * the parameter be part of the request, it's value is returned as a * <code>float</code> whereas otherwise the <code>defaultValue</code> is * returned instead. * * @param request * the weblounge request * @param index * the parameter index * @return the parameter value or <code>defaultValue</code> if the parameter * is not available * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>float</code> */ public static float getFloatParameterWithDefault(WebloungeRequest request, Action action, int index, float defaultValue) throws IllegalArgumentException { try { return getFloatParameter(request, action, index, true); } catch (IllegalStateException e) { return defaultValue; } } /** * Checks if the parameter <code>parameter</code> is present in the request * and is a valid <code>float</code>. Should the parameter not be part of the * request, <code>0</code> is returned, otherwise the parameter value is * returned as an <code>float</code>. * <p> * If the parameter is required, then an {@link IllegalStateException} is * thrown. * * @param request * the weblounge request * @param parameterName * the parameter name * @param required * <code>true</code> if this parameter is mandatory * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>float</code> * @throws IllegalStateException * if the parameter was not found in the request */ private static float getFloatParameter(WebloungeRequest request, String parameterName, boolean required) throws IllegalArgumentException, IllegalStateException { String p = null; if (required) p = getRequiredParameter(request, parameterName); else p = getParameter(request, parameterName); if (p == null) return 0; try { return Float.valueOf(p); } catch (NumberFormatException e) { throw new IllegalArgumentException("Request parameter '" + parameterName + "' must be a float"); } } /** * Checks if a parameter is present in the url at position * <code>parameter</code> and represents a valid <code>float</code>. In that * case, the parameter is returned as a <code>float</code>, otherwise * <code>0.0f</code> is returned. * <p> * If the parameter is required, and it is not part of the url, then an * {@link IllegalStateException} is thrown. * * @param request * the weblounge request * @param action * the action that determines the mountpoint * @param index * the index of the parameter in the url * @param required * <code>true</code> if this parameter is mandatory * @return the parameter value or <code>0.0f</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>float</code> * @throws IllegalStateException * if the parameter was not found in the request */ private static float getFloatParameter(WebloungeRequest request, Action action, int index, boolean required) throws IllegalArgumentException, IllegalStateException { String p = null; if (required) p = getRequiredParameter(request, action, index); else p = getParameter(request, action, index); if (p == null) return 0.0f; try { return Float.valueOf(p); } catch (NumberFormatException e) { throw new IllegalArgumentException("Url parameter at index " + index + " must be a float"); } } /** * Checks if the parameter <code>parameterName</code> is present in the * request and represents a valid <code>float</code>. Should the parameter not * be part of the request, <code>defaultValue</code> is returned, otherwise * the parameter value is returned as an <code>float</code>. * * @param request * the weblounge request * @param parameterName * the parameter name * @param defaultValue * the default parameter value * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>float</code> * @throws IllegalStateException * if the parameter was not found in the request */ public static float getRequiredFloatParameter(WebloungeRequest request, String parameterName) throws IllegalArgumentException, IllegalStateException { return getFloatParameter(request, parameterName, true); } /** * Checks if a parameter is present at position <code>index</code> in the url * whether it represents a valid <code>float</code>. In this case, that * parameter is returned as a <code>float</code> value, whereas otherwise a * {@link IllegalStateException} is thrown. * * @param request * the weblounge request * @param action * the weblounge action * @param index * the parameter index * @return the parameter value * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>float</code> * @throws IllegalStateException * if the parameter was not found in the request */ public static float getRequiredFloatParameter(WebloungeRequest request, Action action, int index) throws IllegalArgumentException, IllegalStateException { return getFloatParameter(request, action, index, true); } /** * Checks if the parameter <code>parameter</code> is present in the request * and represents a valid <code>boolean</code>. Should the parameter not be * part of the request, <code>0</code> is returned, otherwise the parameter * value is returned as an <code>boolean</code>. * * @param request * the weblounge request * @param parameterName * the parameter name * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>boolean</code> */ public static boolean getBooleanParameter(WebloungeRequest request, String parameterName) throws IllegalArgumentException { return getBooleanParameter(request, parameterName, false); } /** * Returns <code>true</code> if the editing state is enabled, else return * <code>false</code> * * @param request * the request * @return the editing state */ public static boolean isEditingState(WebloungeRequest request) { if (request.getHeader("X-Weblounge-Special") != null) { return "Page-Preview".equals(request.getHeader("X-Weblounge-Special")); } else if (!SecurityUtils.userHasRole(request.getUser(), EDITOR)) { return false; } else if (request.getParameter(WORKBENCH_PREVIEW_PARAM) != null) { return false; } else if (request.getParameter(WORKBENCH_PARAM) != null) { return true; } else if (request.getCookies() != null) { for (Cookie cookie : request.getCookies()) { if (EditingState.STATE_COOKIE.equals(cookie.getName())) { return true; } } } else if (TRUE.equals(request.getSession().getAttribute(STATE_COOKIE))) { return true; } return false; } /** * Checks if the parameter <code>parameterName</code> is present in the * request and represents a valid <code>boolean</code>. Should the parameter * not be part of the request, <code>defaultValue</code> is returned, * otherwise the parameter value is returned as an <code>boolean</code>. * * @param request * the weblounge request * @param parameterName * the parameter name * @param defaultValue * the default parameter value * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>boolean</code> */ public static boolean getBooleanParameterWithDefault(WebloungeRequest request, String parameterName, boolean defaultValue) throws IllegalArgumentException { String p = getParameter(request, parameterName); if (p == null) return defaultValue; else return getBooleanParameter(request, parameterName); } /** * Checks if a parameter is present in the url at position * <code>parameter</code> and represents a valid <code>boolean</code>. Should * the parameter be part of the request, it's value is returned as a * <code>boolean</code> whereas otherwise the <code>defaultValue</code> is * returned instead. * * @param request * the weblounge request * @param index * the parameter index * @return the parameter value or <code>defaultValue</code> if the parameter * is not available * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>boolean</code> */ public static boolean getBooleanParameterWithDefault(WebloungeRequest request, Action action, int index, boolean defaultValue) throws IllegalArgumentException { try { return getBooleanParameter(request, action, index, true); } catch (IllegalStateException e) { return defaultValue; } } /** * Checks if the parameter <code>parameterName</code> is present in the * request and represents a valid <code>boolean</code>. Should the parameter * not be part of the request, <code>defaultValue</code> is returned, * otherwise the parameter value is returned as an <code>boolean</code>. * * @param request * the weblounge request * @param parameterName * the parameter name * @param defaultValue * the default parameter value * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>boolean</code> * @throws IllegalStateException * if the parameter was not found in the request */ public static boolean getRequiredBooleanParameter(WebloungeRequest request, String parameterName) throws IllegalArgumentException, IllegalStateException { return getBooleanParameter(request, parameterName, true); } /** * Checks if a parameter is present at position <code>index</code> in the url * whether it represents a valid <code>boolean</code>. In this case, that * parameter is returned as a <code>boolean</code> value, whereas otherwise a * {@link IllegalStateException} is thrown. * * @param request * the weblounge request * @param action * the weblounge action * @param index * the parameter index * @return the parameter value * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>boolean</code> * @throws IllegalStateException * if the parameter was not found in the request */ public static boolean getRequiredBooleanParameter(WebloungeRequest request, Action action, int index) throws IllegalArgumentException, IllegalStateException { return getBooleanParameter(request, action, index, true); } /** * Checks if the parameter <code>parameter</code> is present in the request * and is a valid <code>boolean</code>. Should the parameter not be part of * the request, <code>0</code> is returned, otherwise the parameter value is * returned as an <code>boolean</code>. * <p> * If the parameter is required, then an {@link IllegalStateException} is * thrown. * * @param request * the weblounge request * @param parameterName * the parameter name * @param required * <code>true</code> if this parameter is mandatory * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>boolean</code> * @throws IllegalStateException * if the parameter was not found in the request */ private static boolean getBooleanParameter(WebloungeRequest request, String parameterName, boolean required) throws IllegalArgumentException, IllegalStateException { String p = null; if (required) p = getRequiredParameter(request, parameterName); else p = getParameter(request, parameterName); if (p == null) return false; if (!"true".equalsIgnoreCase(p) && !"false".equalsIgnoreCase(p)) throw new IllegalArgumentException("Request parameter '" + parameterName + "' must be a boolean"); return Boolean.valueOf(p); } /** * Checks if a parameter is present in the url at position * <code>parameter</code> and represents a valid <code>boolean</code>. In that * case, the parameter is returned as a <code>boolean</code>, otherwise * <code>false</code> is returned. * <p> * If the parameter is required, and it is not part of the url, then an * {@link IllegalStateException} is thrown. * * @param request * the weblounge request * @param action * the action that determines the mountpoint * @param index * the index of the parameter in the url * @param required * <code>true</code> if this parameter is mandatory * @return the parameter value or <code>false</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>boolean</code> * @throws IllegalStateException * if the parameter was not found in the request */ private static boolean getBooleanParameter(WebloungeRequest request, Action action, int index, boolean required) throws IllegalArgumentException, IllegalStateException { String p = null; if (required) p = getRequiredParameter(request, action, index); else p = getParameter(request, action, index); if (p == null) return false; try { return Boolean.valueOf(p); } catch (NumberFormatException e) { throw new IllegalArgumentException("Url parameter at index " + index + " must be a boolean"); } } /** * Checks if the parameter <code>parameter</code> is present in the request * and represents a valid <code>java.util.Date</code>. Should the parameter * not be part of the request, <code>0</code> is returned, otherwise the * parameter value is returned as an <code>java.util.Date</code>. * * @param request * the weblounge request * @param parameterName * the parameter name * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>boolean</code> */ public static Date getDateParameter(WebloungeRequest request, String parameterName) throws IllegalArgumentException { return getDateParameter(request, parameterName, false); } /** * Checks if the parameter <code>parameterName</code> is present in the * request and represents a valid <code>java.util.Date</code>. Should the * parameter not be part of the request, <code>defaultValue</code> is * returned, otherwise the parameter value is returned as an * <code>java.util.Date</code>. * * @param request * the weblounge request * @param parameterName * the parameter name * @param defaultValue * the default parameter value * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>boolean</code> */ public static Date getDateParameterWithDefault(WebloungeRequest request, String parameterName, Date defaultValue) throws IllegalArgumentException { String p = getParameter(request, parameterName); if (p == null) return defaultValue; else return getDateParameter(request, parameterName); } /** * Checks if a parameter is present in the url at position * <code>parameter</code> and represents a valid <code>java.util.Date</code> . * Should the parameter be part of the request, it's value is returned as a * <code>java.util.Date</code> whereas otherwise the <code>defaultValue</code> * is returned instead. * * @param request * the weblounge request * @param index * the parameter index * @return the parameter value or <code>defaultValue</code> if the parameter * is not available * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>boolean</code> */ public static Date getDateParameterWithDefault(WebloungeRequest request, Action action, int index, Date defaultValue) throws IllegalArgumentException { try { return getDateParameter(request, action, index, true); } catch (IllegalStateException e) { return defaultValue; } } /** * Checks if the parameter <code>parameterName</code> is present in the * request and represents a valid <code>java.util.Date</code>. Should the * parameter not be part of the request, <code>defaultValue</code> is * returned, otherwise the parameter value is returned as an * <code>java.util.Date</code>. * * @param request * the weblounge request * @param parameterName * the parameter name * @param defaultValue * the default parameter value * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>boolean</code> * @throws IllegalStateException * if the parameter was not found in the request */ public static Date getRequiredDateParameter(WebloungeRequest request, String parameterName) throws IllegalArgumentException, IllegalStateException { return getDateParameter(request, parameterName, true); } /** * Checks if a parameter is present at position <code>index</code> in the url * whether it represents a valid <code>java.util.Date</code>. In this case, * that parameter is returned as a <code>java.util.Date</code> value, whereas * otherwise a {@link IllegalStateException} is thrown. * * @param request * the weblounge request * @param action * the weblounge action * @param index * the parameter index * @return the parameter value * @throws IllegalArgumentException * if the parameter value cannot be cast to a <code>boolean</code> * @throws IllegalStateException * if the parameter was not found in the request */ public static Date getRequiredDateParameter(WebloungeRequest request, Action action, int index) throws IllegalArgumentException, IllegalStateException { return getDateParameter(request, action, index, true); } /** * Checks if the parameter <code>parameter</code> is present in the request * and is a valid <code>java.util.Date</code>. Should the parameter not be * part of the request, <code>0</code> is returned, otherwise the parameter * value is returned as an <code>java.util.Date</code>. * <p> * If the parameter is required, then an {@link IllegalStateException} is * thrown. * * @param request * the weblounge request * @param parameterName * the parameter name * @param required * <code>true</code> if this parameter is mandatory * @return the parameter value or <code>0</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>boolean</code> * @throws IllegalStateException * if the parameter was not found in the request */ private static Date getDateParameter(WebloungeRequest request, String parameterName, boolean required) throws IllegalArgumentException, IllegalStateException { String p = null; if (required) p = getRequiredParameter(request, parameterName); else p = getParameter(request, parameterName); if (p == null) return null; try { return parseDate(p); } catch (ParseException e) { throw new IllegalArgumentException("Request parameter must be a date"); } } /** * Checks if a parameter is present in the url at position * <code>parameter</code> and represents a valid <code>java.util.Date</code> . * In that case, the parameter is returned as a <code>java.util.Date</code>, * otherwise <code>false</code> is returned. * <p> * If the parameter is required, and it is not part of the url, then an * {@link IllegalStateException} is thrown. * * @param request * the weblounge request * @param action * the action that determines the mountpoint * @param index * the index of the parameter in the url * @param required * <code>true</code> if this parameter is mandatory * @return the parameter value or <code>false</code> if the parameter is not * available * @throws IllegalArgumentException * if the parameter value cannot be cast to an <code>boolean</code> * @throws IllegalStateException * if the parameter was not found in the request */ private static Date getDateParameter(WebloungeRequest request, Action action, int index, boolean required) throws IllegalArgumentException, IllegalStateException { String p = null; if (required) p = getRequiredParameter(request, action, index); else p = getParameter(request, action, index); if (p == null) return null; try { return parseDate(p); } catch (ParseException e) { throw new IllegalArgumentException("Url parameter at index " + index + " must be a date"); } } /** * Parses a string into a <code>java.util.Date</code> object. Valid date * string patterns are * * <ul> * <li>dd.MM.yyyy (ex. 18.12.2010)</li> * <li>dd.MM.yyyy kk:mm (ex. 18.12.2010 15:35)</li> * <li>dd.MM.yyyy kk:mm:ss (ex. 18.12.2010 15:35:22)</li> * <li>yyyy-MM-dd (ex. 2010-12-18)</li> * <li>yyyyMMdd (ex. 20101218)</li> * <li>yyyy-MM-ddTkk:mmZ (ex. 2010-12-18T15:35+01:00)</li> * <li>yyyy-MM-ddTkk:mm:ssZ (ex. 2010-12-18T15:35:22+01:00)</li> * </ul> * * @param datestring * string to parse * @return date * @throws ParseException * if the given string could not be converted to a valid date object */ private static Date parseDate(String datestring) throws ParseException { String[] parsePatterns = { // german/swiss date format "dd.MM.yyyy", "dd.MM.yyyy kk:mm", "dd.MM.yyyy kk:mm:ss", // ISO8601 "yyyy-MM-dd", "yyyyMMdd", "yyyy-MM-ddTkk:mmZ", "yyyy-MM-ddTkk:mm:ssZ", // us date format "MM/dd/yyyy" }; return DateUtils.parseDate(datestring, parsePatterns); } /** * This method returns without noise if one of the specified parameters can be * found in the request and is not equal to the empty string. Otherwise, an * {@link IllegalArgumentException} is thrown. * * @param request * the weblounge request * @param parameters * the parameter list * @throws IllegalStateException * if none of the parameters were found in the request */ public static void requireAny(WebloungeRequest request, String[] parameters) throws IllegalStateException { if (parameters == null) return; for (int i = 0; i < parameters.length; i++) { if (getParameter(request, parameters[i]) != null) return; } StringBuffer buf = new StringBuffer(); buf.append("["); for (int i = 0; i < parameters.length; i++) { buf.append(parameters[i]); if (i < parameters.length - 1) buf.append(" | "); } buf.append("]"); throw new IllegalArgumentException(buf.toString()); } /** * Returns <code>true</code> if this is a mock request or if it's wrapping * such a request. * * @param request * the request * @return <code>true</code> if this is a mock request */ public static boolean isMockRequest(ServletRequest request) { if (request instanceof MockHttpServletRequest) return true; // Maybe it's wrapped? while (request instanceof HttpServletRequestWrapper) { request = ((HttpServletRequestWrapper) request).getRequest(); if (request instanceof MockHttpServletRequest) return true; } // Definitely not return false; } /** * Returns <code>true</code> if this is a request that was constructed for JSP * precompilation purpose or if <code>request</code> is wrapping such a * request. * * @param request * the request * @return <code>true</code> if this is a precompile request */ public static boolean isPrecompileRequest(ServletRequest request) { if (request instanceof PrecompileHttpServletRequest) return true; // Maybe it's wrapped? while (request instanceof HttpServletRequestWrapper) { request = ((HttpServletRequestWrapper) request).getRequest(); if (request instanceof PrecompileHttpServletRequest) return true; } // Definitely not return false; } /** * Returns <code>true</code> if the exception was caused by the client closing * the connection. * * @param e * the exception * @return <code>true</code> if the client caused */ public static boolean isCausedByClient(IOException e) { Throwable cause = e.getCause(); if (cause == null) return false; if ("Broken pipe".equals(cause.getMessage())) return true; if ("Connection reset by peer".equals(cause.getMessage())) return true; return false; } }