RELEASE_2_1_13/src/blocks/portal/java/org/apache/cocoon/portal/impl/LinkInfo.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.cocoon.portal.impl;

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Enumeration;

import org.apache.cocoon.environment.Request;
import org.apache.cocoon.environment.wrapper.RequestParameters;
import org.apache.cocoon.util.NetUtils;
import org.apache.commons.lang.BooleanUtils;

/**
 * Helper class containing the information about common parts for each link
 * that will be generated in the portal page.
 *
 * @version $Id$
 */
public class LinkInfo {

    /** Link base contains the base url for the http protocol. */
    protected final String       httpLinkBase;
    protected final String       secureLinkBase;
    protected boolean            hasParameters = false;
    protected final ArrayList    comparableEvents = new ArrayList(5);
    protected final StringBuffer url = new StringBuffer();
    protected final Request      request;

    /** Is the page called using https? */
    protected final boolean isSecure;

    public LinkInfo(Request request, int defaultPort, int defaultSecurePort) {
        this.isSecure = request.getScheme().equals("https");
        // create relative url
        String relativeURI = getRelativeURI(request);

        this.request = request;
        this.secureLinkBase = getSecureLinkBase(request, relativeURI, defaultSecurePort);
        this.httpLinkBase = getHttpLinkBase(request, relativeURI, defaultPort);
    }

    protected String getRelativeURI(Request request) {
        String relativeURI = request.getSitemapURI();
        final int pos = relativeURI.lastIndexOf('/');
        if (pos != -1)
        {
            relativeURI = relativeURI.substring(pos + 1);
        }
        return relativeURI;
    }

    /**
     * Return the base url for a secure http request
     * @param relativeURI The current relative URI
     * @param defaultPort The default port to use
     * @return A String containing the base url for a secure http request
     */
    protected String getSecureLinkBase(Request request, String relativeURI, int defaultPort) {
        return (this.isSecure) ? relativeURI : getAbsoluteUrl(request, true, defaultPort);
    }

    /**
     * Return the url for an http request
     * @param relativeURI The current relative URI
     * @param defaultPort The default port to use
     * @return A string containing the base url for an http request
     */
    protected String getHttpLinkBase(Request request, String relativeURI, int defaultPort) {
        return (this.isSecure) ? getAbsoluteUrl(request, false, defaultPort) : relativeURI;
    }

    /**
     * Return the absolute URL for a reqeust
     * @param request The current Request
     * @param useSecure true if the Request should be secure
     * @param port The port to use
     * @return A String containing the absolute url for a request
     */
    protected String getAbsoluteUrl(Request request, boolean useSecure, int port) {
        final StringBuffer buffer = new StringBuffer();
        if ( useSecure ) {
            buffer.append("https://");
        } else {
            buffer.append("http://");
        }
        buffer.append(request.getServerName());
        if (  (  useSecure && port != 443)
           || ( !useSecure && port != 80 ) ) {
            buffer.append(':');
            buffer.append(port);
        }
        if ( request.getContextPath().length() > 0 ) {
            buffer.append(request.getContextPath());
        }
        buffer.append('/');                        
        if ( request.getSitemapURIPrefix().length() > 0 ) {
            buffer.append(request.getSitemapURIPrefix());
        }
        buffer.append(request.getSitemapURI());
        return buffer.toString();
    }
        
    public String getBase(Boolean secure) {
        // if no information is provided, we stay with the same protocol
        if ( secure == null ) {
            secure = BooleanUtils.toBooleanObject(this.isSecure);
        }
        if ( secure.booleanValue() ) {
            return this.secureLinkBase + this.url.toString();
        }
        return this.httpLinkBase + this.url.toString();
    }

    public LinkInfo appendToBase(String value) {
        this.url.append(value);
        return this;
    }

    public LinkInfo appendToBase(char c) {
        this.url.append(c);
        return this;
    }

    public void deleteParameterFromBase(String parameterName) {
        if ( this.hasParameters ) {
            final int pos = this.url.toString().indexOf("?");
            final String queryString = this.url.substring(pos + 1);
            final RequestParameters params = new RequestParameters(queryString);
            if ( params.getParameter(parameterName) != null ) {
                // the parameter is available, so remove it
                this.url.delete(pos, this.url.length() + 1);
                this.hasParameters = false;
                
                Enumeration enumeration = params.getParameterNames();
                while ( enumeration.hasMoreElements() ) {
                    final String paramName = (String)enumeration.nextElement();
                    if ( !paramName.equals(parameterName) ) {
                        String[] values = params.getParameterValues(paramName);
                        for( int i = 0; i < values.length; i++ ) {
                            this.addParameterToBase(paramName, values[i]);
                        }
                    }
                }
            }
        }            
    }

    public void addParameterToBase(String name, String value) {
        if ( this.hasParameters ) {
            this.appendToBase('&');
        } else {
            this.appendToBase('?');
        }
        try {
            this.appendToBase(name).appendToBase('=').appendToBase(NetUtils.encode(value, "utf-8"));
        } catch (UnsupportedEncodingException uee) {
            // ignore this as utf-8 is always supported
        }
        this.hasParameters = true;
    }

    public boolean hasParameters() {
        return this.hasParameters;
    }
}