trunk/pluto-container/src/main/java/org/apache/pluto/internal/impl/PortletURLImpl.java

/*
 * Copyright 2003,2004 The Apache Software Foundation.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.pluto.internal.impl;

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

import javax.portlet.PortalContext;
import javax.portlet.PortletMode;
import javax.portlet.PortletModeException;
import javax.portlet.PortletSecurityException;
import javax.portlet.PortletURL;
import javax.portlet.WindowState;
import javax.portlet.WindowStateException;

import org.apache.pluto.PortletContainer;
import org.apache.pluto.descriptors.portlet.PortletDD;
import org.apache.pluto.descriptors.portlet.SupportsDD;
import org.apache.pluto.internal.InternalPortletWindow;
import org.apache.pluto.spi.PortletURLProvider;
import org.apache.pluto.util.StringManager;
import org.apache.pluto.util.StringUtils;

public class PortletURLImpl implements PortletURL {

    private static final StringManager EXCEPTIONS =
        StringManager.getManager(PortletURLImpl.class.getPackage().getName());


    private PortletContainer container;
    protected PortletMode mode = null;

    protected Map parameters = new HashMap();

    protected InternalPortletWindow internalPortletWindow;

    protected boolean secure;
    protected javax.servlet.http.HttpServletRequest servletRequest;
    protected javax.servlet.http.HttpServletResponse servletResponse;
    protected WindowState state;
    protected boolean isAction;

    private PortalContext context;

    public PortletURLImpl(PortletContainer container,
                          InternalPortletWindow internalPortletWindow,
                          javax.servlet.http.HttpServletRequest servletRequest,
                          javax.servlet.http.HttpServletResponse servletResponse,
                          boolean isAction) {
        this.container = container;
        this.internalPortletWindow = internalPortletWindow;
        this.servletRequest = servletRequest;
        this.servletResponse = servletResponse;
        secure = servletRequest.isSecure();
        this.isAction = isAction;
        this.context = container.getRequiredContainerServices().getPortalContext();
    }

    // javax.portlet.PortletURL -------------------------------------------------------------------
    public void setWindowState(WindowState windowState)
        throws WindowStateException {
        if (windowState != null && isWindowStateAllowed(windowState)) {
            state = windowState;
            return;
        }

        throw new WindowStateException(
            "unsupported Window State used: " + windowState, windowState);
    }

    public void setPortletMode(PortletMode portletMode)
        throws PortletModeException {
        // Test and throw exception if not allowed.
        isPortletModeAllowed(portletMode);
        mode = portletMode;
    }

    public void setParameter(String name, String value) {
        if (name == null || value == null) {
            throw new IllegalArgumentException(
                "name and value must not be null");
        }

        parameters.put(name, new String[]{value});
    }

    public void setParameter(String name, String[] values) {
        if (name == null || values == null || values.length == 0) {
            throw new IllegalArgumentException(
                "name and values must not be null or values be an empty array");
        }

        parameters.put(name, StringUtils.copy(values));
    }

    /* (non-Javadoc)
     * @see javax.portlet.PortletURL#setParameters(Map)
     */
    public void setParameters(Map parameters) {
        if (parameters == null) {
            throw new IllegalArgumentException("Parameters must not be null.");
        }
        for (Iterator it = parameters.entrySet().iterator(); it.hasNext();) {
            Map.Entry entry = (Map.Entry) it.next();
            if (!(entry.getKey() instanceof String)) {
                throw new IllegalArgumentException(
                    "Key must not be null and of type java.lang.String.");
            }
            if (!(entry.getValue() instanceof String[])) {
                throw new IllegalArgumentException(
                    "Value must not be null and of type java.lang.String[].");
            }
        }

        this.parameters = StringUtils.copyParameters(parameters);
    }

    public void setSecure(boolean secure) throws PortletSecurityException {
        this.secure = secure;
    }

    public String toString() {
        StringBuffer url = new StringBuffer(200);

        PortletURLProvider urlProvider = container
        		.getRequiredContainerServices()
        		.getPortalCallbackService()
        		.getPortletURLProvider(servletRequest, internalPortletWindow);

        if (mode != null) {
            urlProvider.setPortletMode(mode);
        }
        if (state != null) {
            urlProvider.setWindowState(state);
        }
        if (isAction) {
            urlProvider.setAction(true);
        }
        if (secure) {
            urlProvider.setSecure();
        }
        urlProvider.clearParameters();
        urlProvider.setParameters(parameters);

        url.append(urlProvider.toString());

        return url.toString();
    }
    // --------------------------------------------------------------------------------------------


    // additional methods -------------------------------------------------------------------------
    public String getParameter(String name) {
        return (String) parameters.get(name);
    }

    public String[] getParameters(String name) {
        return (String[]) parameters.get(name);
    }

    public PortletMode getPortletMode() {
        return mode;
    }

    public WindowState getWindowState() {
        return state;
    }
    // --------------------------------------------------------------------------------------------


    private boolean isPortletModeAllowed(PortletMode mode)
        throws PortletModeException {
        if (mode == null) {
            throw new PortletModeException(
                EXCEPTIONS.getString("javax.portlet.PortletModeException.null"),
                null);
        }

        return isPortletModeAllowedByPortlet(mode)
               && isPortletModeAllowedByPortal(mode);
    }

    private boolean isPortletModeAllowedByPortlet(PortletMode mode)
        throws PortletModeException {
        // PLT 8.1: View Portlet Mode should always be
        // supported by a portlet, even if not defined in the descriptor
        if (mode.equals(PortletMode.VIEW)) {
            return true;
        }

        PortletDD dd = internalPortletWindow.getPortletEntity()
            .getPortletDefinition();
        Iterator supports = dd.getSupports().iterator();
        while(supports.hasNext()) {
            SupportsDD support = (SupportsDD)supports.next();
            Iterator modes = support.getPortletModes().iterator();
            while(modes.hasNext()) {
                String md = (String)modes.next();
                if (md.toUpperCase().equals(
                    mode.toString().toUpperCase())) {
                    return true;
                }
            }
        }
        String message = EXCEPTIONS.getString(
            "javax.portlet.PortletModeException.portlet", mode.toString());

        throw new PortletModeException(message, mode);
    }

    private boolean isPortletModeAllowedByPortal(PortletMode mode)
        throws PortletModeException {
        Enumeration supportedModes = context.getSupportedPortletModes();
        while (supportedModes.hasMoreElements()) {
            if (supportedModes.nextElement().toString().toUpperCase().equals(
                (mode.toString().toUpperCase()))) {
                return true;
            }
        }
        String message = EXCEPTIONS.getString(
            "javax.portlet.PortletModeException.portal", mode.toString());

        throw new PortletModeException(message, mode);
    }

    private boolean isWindowStateAllowed(WindowState state) {
        Enumeration supportedStates = context.getSupportedWindowStates();
        while (supportedStates.hasMoreElements()) {
            if (supportedStates.nextElement().toString().toUpperCase().equals(
                (state.toString().toUpperCase()))) {
                return true;
            }
        }
        return false;
    }
}