/projects/displaytag-1.2/displaytag-portlet/src/main/java/org/displaytag/portlet/PortletHref.java

/**
 * 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.portlet;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import javax.portlet.PortletMode;
import javax.portlet.PortletModeException;
import javax.portlet.PortletRequest;
import javax.portlet.PortletSecurityException;
import javax.portlet.PortletURL;
import javax.portlet.RenderResponse;
import javax.portlet.WindowState;
import javax.portlet.WindowStateException;

import org.apache.commons.collections.Predicate;
import org.apache.commons.collections.functors.AnyPredicate;
import org.apache.commons.collections.functors.InstanceofPredicate;
import org.apache.commons.collections.functors.NullPredicate;
import org.apache.commons.collections.map.PredicatedMap;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.displaytag.util.Href;


/**
 * Implementation of the Href interface that generates URLs using the javax.portlet APIs. As the portlet API supports
 * the concept of WindowStates, PorletModes, secure URLs and actions versus render the implementation supports these
 * concepts as well through the standard {@link Href} APIs. <br>
 * <br>
 * The features are manipulated using special parameter names and values: <table>
 * <tr>
 * <th>Feature</th>
 * <th>Parameter Name</th>
 * <th>Parameter Value</th>
 * </tr>
 * <tr>
 * <td>Render vs Action URL</td>
 * <td>{@link #PARAM_TYPE} (portlet:type)</td>
 * <td>"render" for RenderURLs, "action" for ActionURLs</td>
 * </tr>
 * <tr>
 * <td>WindowState</td>
 * <td>{@link #PARAM_STATE} (portlet:state)</td>
 * <td>The value is used directly for the WindowState name</td>
 * </tr>
 * <tr>
 * <td>PorltetMode</td>
 * <td>{@link #PARAM_MODE} (portlet:mode)</td>
 * <td>The value is used directly for the PortletMode name</td>
 * </tr>
 * <tr>
 * <td>Secure URL</td>
 * <td>{@link #PARAM_SECURE} (portlet:secure)</td>
 * <td>"true" requests a secure URL, anything else requests a standard URL</td>
 * </tr>
 * </table>
 * @author Eric Dalquist <a href="mailto:dalquist@gmail.com">dalquist@gmail.com</a>
 * @version $Id: PortletHref.java 999 2006-01-22 20:01:46Z fgiust $
 */
public class PortletHref implements Href
{

    // Constants for working with the special parameters
    private static final String PARAM_PREFIX = "portlet:";

    public static final String PARAM_MODE = PARAM_PREFIX + "mode";

    public static final String PARAM_STATE = PARAM_PREFIX + "state";

    public static final String PARAM_SECURE = PARAM_PREFIX + "secure";

    public static final String PARAM_TYPE = PARAM_PREFIX + "type";

    public static final String TYPE_RENDER = "render";

    public static final String TYPE_ACTION = "action";

    /**
     * D1597A17A6.
     */
    private static final long serialVersionUID = 899149338534L;

    // Predicated for type checking the parameter map
    private static final Predicate PRED_TYPE_OF_STRING = new InstanceofPredicate(String.class);

    private static final Predicate PRED_TYPE_OF_STRING_ARRY = new InstanceofPredicate(String[].class);

    private static final Predicate PRED_OR_STR_STRARR = new AnyPredicate(new Predicate[]{
        PRED_TYPE_OF_STRING,
        PRED_TYPE_OF_STRING_ARRY,
        NullPredicate.INSTANCE});

    // Portlet request and response are needed for feature checking and generating the URLs
    private final PortletRequest portletRequest;

    private final RenderResponse renderResponse;

    private Map parameters = this.createParameterMap();

    private boolean isAction;

    private PortletMode requestedMode;

    private WindowState requestedState;

    private boolean requestedSecure;

    private String anchor;

    /**
     * Creates a new PortletHref. The actual PortletURL object is not generated until the toString method is called.
     * @param portletRequest request to to feature checking with, may not be null.
     * @param renderResponse response to generate the URLs from, may not be null.
     */
    public PortletHref(PortletRequest portletRequest, RenderResponse renderResponse)
    {
        if (portletRequest == null)
        {
            throw new IllegalArgumentException("portletRequest may not be null");
        }
        if (renderResponse == null)
        {
            throw new IllegalArgumentException("renderResponse may not be null");
        }

        this.portletRequest = portletRequest;
        this.renderResponse = renderResponse;
    }

    /**
     * @see org.displaytag.util.Href#setFullUrl(java.lang.String)
     */
    public void setFullUrl(String baseUrl)
    {
        // do nothing
    }

    /**
     * @return Returns the isAction.
     */
    public boolean isAction()
    {
        return this.isAction;
    }

    /**
     * @param isAction The isAction to set.
     */
    public void setAction(boolean isAction)
    {
        this.isAction = isAction;
    }

    /**
     * @return Returns the requestedMode.
     */
    public PortletMode getRequestedMode()
    {
        return this.requestedMode;
    }

    /**
     * @param requestedMode The requestedMode to set.
     */
    public void setRequestedMode(PortletMode requestedMode)
    {
        this.requestedMode = requestedMode;
    }

    /**
     * @return Returns the requestedSecure.
     */
    public boolean isRequestedSecure()
    {
        return this.requestedSecure;
    }

    /**
     * @param requestedSecure The requestedSecure to set.
     */
    public void setRequestedSecure(boolean requestedSecure)
    {
        this.requestedSecure = requestedSecure;
    }

    /**
     * @return Returns the requestedState.
     */
    public WindowState getRequestedState()
    {
        return this.requestedState;
    }

    /**
     * @param requestedState The requestedState to set.
     */
    public void setRequestedState(WindowState requestedState)
    {
        this.requestedState = requestedState;
    }

    /**
     * @see org.displaytag.util.Href#addParameter(java.lang.String, int)
     */
    public Href addParameter(String name, int value)
    {
        return this.addParameter(name, Integer.toString(value));
    }

    /**
     * @see org.displaytag.util.Href#addParameter(String, Object)
     */
    public Href addParameter(String name, Object objValue)
    {
        String value = ObjectUtils.toString(objValue, null);

        if (name != null && name.startsWith(PARAM_PREFIX))
        {
            if (PARAM_TYPE.equals(name))
            {
                if (TYPE_RENDER.equals(value))
                {
                    this.setAction(false);
                }
                else if (TYPE_ACTION.equals(value))
                {
                    this.setAction(true);
                }
                else
                {
                    throw new IllegalArgumentException("Value of parameter '"
                        + name
                        + "' must be equal to '"
                        + TYPE_RENDER
                        + "' or '"
                        + TYPE_ACTION
                        + "'. '"
                        + value
                        + "' is not allowed.");
                }
            }
            else if (PARAM_SECURE.equals(name))
            {
                if (new Boolean(value).booleanValue())
                {
                    this.setRequestedSecure(true);
                }
                else
                {
                    this.setRequestedSecure(false);
                }
            }
            else if (PARAM_MODE.equals(name))
            {
                if (value == null)
                {
                    this.setRequestedMode(null);
                }
                else
                {
                    final PortletMode mode = new PortletMode(value);

                    if (!this.portletRequest.isPortletModeAllowed(mode))
                    {
                        throw new IllegalArgumentException("PortletMode '"
                            + mode
                            + "' is not allowed for this request.");
                    }

                    this.setRequestedMode(mode);
                }
            }
            else if (PARAM_STATE.equals(name))
            {
                if (value == null)
                {
                    this.setRequestedState(null);
                }
                else
                {
                    final WindowState state = new WindowState(value);

                    if (!this.portletRequest.isWindowStateAllowed(state))
                    {
                        throw new IllegalArgumentException("WindowState '"
                            + state
                            + "' is not allowed for this request.");
                    }

                    this.setRequestedState(state);
                }
            }
            else
            {
                throw new IllegalArgumentException("'"
                    + name
                    + "' is not a valid '"
                    + PARAM_PREFIX
                    + "' prefixed parameter.");
            }
        }
        else
        {
            this.parameters.put(name, value);
        }

        return this;
    }

    /**
     * @see org.displaytag.util.Href#addParameterMap(java.util.Map)
     */
    public void addParameterMap(Map parametersMap)
    {
        for (final Iterator paramItr = parametersMap.entrySet().iterator(); paramItr.hasNext();)
        {
            final Map.Entry entry = (Map.Entry) paramItr.next();

            final String name = (String) entry.getKey();
            final Object value = entry.getValue();

            // Allow multivalued parameters since code elsewhere calls this method to copy
            // parameters from the request to the response. Ensures that developer specified
            // multivalued parameters are retained correctly.
            if (value instanceof String[])
            {
                this.parameters.put(name, value);
            }
            else if (value == null || value instanceof String)
            {
                this.addParameter(name, value);
            }
            else
            {
                this.addParameter(name, value.toString());
            }
        }
    }

    /**
     * @see org.displaytag.util.Href#setParameterMap(java.util.Map)
     */
    public void setParameterMap(Map parametersMap)
    {
        this.parameters.clear();
        this.addParameterMap(parametersMap);
    }

    /**
     * Warning, parameters added to the Map directly will not be parsed by the PortletUrl feature support portions of
     * this class.
     * @see org.displaytag.util.Href#getParameterMap()
     */
    public Map getParameterMap()
    {
        return this.parameters;
    }

    /**
     * @see org.displaytag.util.Href#removeParameter(java.lang.String)
     */
    public void removeParameter(String name)
    {
        this.parameters.remove(name);
    }

    /**
     * @see org.displaytag.util.Href#setAnchor(java.lang.String)
     */
    public void setAnchor(String name)
    {
        this.anchor = name;
    }

    /**
     * @see org.displaytag.util.Href#getAnchor()
     */
    public String getAnchor()
    {
        return this.anchor;
    }

    /**
     * Generates a render or action URL depending on the use of the PortletUrl specific features of this class.
     * @see org.displaytag.util.Href#getBaseUrl()
     */
    public String getBaseUrl()
    {
        if (this.isAction())
        {
            return this.renderResponse.createActionURL().toString();
        }
        else
        {
            return this.renderResponse.createRenderURL().toString();
        }
    }

    /**
     * @see org.displaytag.util.Href#clone()
     */
    public Object clone()
    {
        PortletHref href;

        try
        {
            href = (PortletHref) super.clone();
        }
        catch (CloneNotSupportedException cnse)
        {
            throw new RuntimeException("Parent through a CloneNotSupportedException, this should never happen", cnse);
        }

        href.isAction = this.isAction;
        href.parameters = this.createParameterMap();
        href.parameters.putAll(this.parameters);
        href.requestedMode = this.requestedMode;
        href.requestedState = this.requestedState;
        href.requestedSecure = this.requestedSecure;
        href.anchor = this.anchor;

        return href;
    }

    /**
     * @see org.displaytag.util.Href#equals(java.lang.Object)
     */
    public boolean equals(Object object)
    {
        if (this == object)
        {
            return true;
        }
        if (!(object instanceof PortletHref))
        {
            return false;
        }
        PortletHref rhs = (PortletHref) object;
        return new EqualsBuilder().append(this.isAction, rhs.isAction).append(this.parameters, rhs.parameters).append(
            this.requestedMode,
            rhs.requestedMode).append(this.requestedState, rhs.requestedState).append(
            this.requestedSecure,
            rhs.requestedSecure).append(this.anchor, rhs.anchor).isEquals();
    }

    /**
     * @see org.displaytag.util.Href#hashCode()
     */
    public int hashCode()
    {
        return new HashCodeBuilder(1313733113, -431360889)
            .append(this.isAction)
            .append(this.parameters)
            .append(this.requestedMode)
            .append(this.requestedState)
            .append(this.requestedSecure)
            .append(this.anchor)
            .toHashCode();
    }

    /**
     * @see org.displaytag.util.Href#toString()
     */
    public String toString()
    {
        final PortletURL url;
        if (this.isAction())
        {
            url = this.renderResponse.createActionURL();
        }
        else
        {
            url = this.renderResponse.createRenderURL();
        }

        if (this.isRequestedSecure())
        {
            try
            {
                url.setSecure(true);
            }
            catch (PortletSecurityException pse)
            {
                throw new RuntimeException("Creating secure PortletURL Failed.", pse);
            }
        }

        if (this.getRequestedMode() != null)
        {
            try
            {
                url.setPortletMode(this.getRequestedMode());
            }
            catch (PortletModeException pme)
            {
                final IllegalStateException ise = new IllegalStateException("Requested PortletMode='"
                    + this.getRequestedMode()
                    + "' could not be set.");
                ise.initCause(pme);
                throw ise;
            }
        }

        if (this.getRequestedState() != null)
        {
            try
            {
                url.setWindowState(this.getRequestedState());
            }
            catch (WindowStateException wse)
            {
                final IllegalStateException ise = new IllegalStateException("Requested WindowState='"
                    + this.getRequestedState()
                    + "' could not be set.");
                ise.initCause(wse);
                throw ise;
            }
        }

        for (final Iterator paramItr = this.parameters.entrySet().iterator(); paramItr.hasNext();)
        {
            final Map.Entry entry = (Map.Entry) paramItr.next();

            final String name = (String) entry.getKey();
            final Object value = entry.getValue();

            if (value instanceof String)
            {
                url.setParameter(name, (String) value);
            }
            else if (value instanceof String[])
            {
                url.setParameter(name, (String[]) value);
            }
        }

        if (this.getAnchor() == null)
        {
            return url.toString();
        }
        else
        {
            return url.toString() + "#" + this.getAnchor();
        }
    }

    private Map createParameterMap()
    {
        return PredicatedMap.decorate(new HashMap(), PRED_TYPE_OF_STRING, PRED_OR_STR_STRARR);
    }
}