fr.paris.lutece.portal.service.util.AppPathService.java Source code

Java tutorial

Introduction

Here is the source code for fr.paris.lutece.portal.service.util.AppPathService.java

Source

/*
 * Copyright (c) 2002-2013, Mairie de Paris
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  1. Redistributions of source code must retain the above copyright notice
 *     and the following disclaimer.
 *
 *  2. Redistributions in binary form must reproduce the above copyright notice
 *     and the following disclaimer in the documentation and/or other materials
 *     provided with the distribution.
 *
 *  3. Neither the name of 'Mairie de Paris' nor 'Lutece' nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * License 1.0
 */
package fr.paris.lutece.portal.service.util;

import fr.paris.lutece.portal.service.datastore.DatastoreService;
import fr.paris.lutece.portal.service.message.SiteMessageService;
import fr.paris.lutece.portal.web.LocalVariables;
import fr.paris.lutece.portal.web.constants.Parameters;
import fr.paris.lutece.util.ReferenceList;
import fr.paris.lutece.util.string.StringUtil;
import fr.paris.lutece.util.url.UrlItem;

import org.apache.commons.lang.StringUtils;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import java.text.MessageFormat;

import java.util.Enumeration;
import java.util.StringTokenizer;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

/**
 * this class provides services for locate repository or url
 */
public final class AppPathService {
    public static final String SESSION_BASE_URL = "base_url";
    private static final String MSG_LOG_PROPERTY_NOT_FOUND = "Property {0} not found in the properties file ";
    private static final int PORT_NUMBER_HTTP = 80;
    private static final String PROPERTY_BASE_URL = "lutece.base.url";
    private static final String PROPERTY_PORTAL_URL = "lutece.portal.path";
    private static final String PROPERTY_SITE_MESSAGE_URL = "lutece.siteMessage.path";
    private static final String PROPERTY_ADMIN_URL = "lutece.admin.path";
    private static final String PROPERTY_ADMIN_MENU_URL = "lutece.admin.menu.url";
    private static final String PROPERTY_PORTAL_REDIRECT_URL = "lutece.portal.redirect.url";
    private static final String PROPERTY_VIRTUAL_HOST_KEYS = "virtualHostKeys";
    private static final String PROPERTY_VIRTUAL_HOST_KEY_PARAMETER = "virtualHostKey.parameterName";
    private static final String PROPERTY_VIRTUAL_HOST = "virtualHost.";
    private static final String PROPERTY_PREFIX_URL = "url.";
    private static final String PROPERTY_PROD_BASE_URL = "lutece.prod.url";
    private static final String PROPERTY_INSTANCE = "lutece.webapp.instance";
    private static final String INSTANCE_DEFAULT = "default";
    private static final String SUFFIX_BASE_URL = ".baseUrl";
    private static final String SUFFIX_DESCRIPTION = ".description";
    private static final String SLASH = "/";
    private static final String DOUBLE_POINTS = ":";

    // Datastore keys
    private static final String KEY_ADMIN_HOME_URL = "portal.site.site_property.admin_home_url";
    private static final String KEY_PORTAL_HOME_URL = "portal.site.site_property.home_url";
    private static String _strWebAppPath;

    /**
     * Creates a new AppPathService object.
     */
    private AppPathService() {
    }

    /**
     * Initialize The path service
     *
     * @param context The servlet context
     */
    public static void init(ServletContext context) {
        String strRealPath = context.getRealPath("/");
        _strWebAppPath = normalizeWebappPath(strRealPath);
    }

    /**
     * Initialize The webapppath
     *
     * @param strWebAppPath The Webapp path
     */
    public static void init(String strWebAppPath) {
        _strWebAppPath = strWebAppPath;
    }

    /**
     * Returns the absolute path of a repository from a relative definition in
     * properties file
     *
     *
     * @return the repository absolute path
     * @param strKey the repository key definied in properties file
     */
    public static String getPath(String strKey) {
        // Adds relative path found from strKey
        String strDirectory = AppPropertiesService.getProperty(strKey);

        if (strDirectory == null) {
            Object[] propertyMissing = { strKey };
            String strMsg = MessageFormat.format(MSG_LOG_PROPERTY_NOT_FOUND, propertyMissing);
            throw new AppException(strMsg);
        }

        return getWebAppPath() + strDirectory;
    }

    /**
     * Returns the webapp path from the properties file
     *
     *
     * @return the webapp path
     */
    public static String getWebAppPath() {
        return _strWebAppPath;
    }

    /**
     * Returns the absolute path of file from its relative definition in
     * properties file.
     *
     * @param strKey the repository key defined in properties file
     * @param strFilename The name of file
     * @return the absolute path of file
     */
    public static String getPath(String strKey, String strFilename) {
        return getPath(strKey) + SLASH + strFilename;
    }

    /**
     * Gets a file as stream
     *
     * @param strPath the path
     * @param strFilename The name of file
     * @return a FileInput Stream object
     */
    public static FileInputStream getResourceAsStream(String strPath, String strFilename) {
        String strFilePath = getWebAppPath() + strPath + strFilename;

        try {
            File file = new File(strFilePath);
            FileInputStream fis = new FileInputStream(file);

            return fis;
        } catch (IOException e) {
            throw new AppException("Unable to get file : " + strFilePath);
        }
    }

    /**
     * Returns the absolute path of a repository from a relative path
     *
     *
     * @return the repository absolute path
     * @param strDirectory the relative path
     */
    public static String getAbsolutePathFromRelativePath(String strDirectory) {
        return _strWebAppPath + strDirectory;
    }

    /**
     * Return the url of the webapp, built from the request
     *
     * @param request The HttpServletRequest
     * @return strBase the webapp url
     */
    public static String getBaseUrl(HttpServletRequest request) {
        if (request == null) {
            return getBaseUrl();
        }

        String strBase;

        // Search for a Virtual Host Base Url defined in the request
        strBase = getVirtualHostBaseUrl(request);

        // If not found, get the base url from session
        if ((strBase == null) || strBase.equals(StringUtils.EMPTY)) {
            HttpSession session = request.getSession(false);

            if (session != null) {
                Object oBase = session.getAttribute(SESSION_BASE_URL);

                if (oBase != null) {
                    strBase = (String) oBase;
                }
            }
        }

        // If not found, get the base url from the config.properties
        if ((strBase == null) || (strBase.equals(StringUtils.EMPTY))) {
            strBase = AppPropertiesService.getProperty(PROPERTY_BASE_URL);
        }

        if ((strBase == null) || (strBase.equals(StringUtils.EMPTY))) {
            // Dynamic base URL if not defined in the properties
            strBase = request.getScheme() + DOUBLE_POINTS + SLASH + SLASH + request.getServerName();

            int nPort = request.getServerPort();

            if (nPort != PORT_NUMBER_HTTP) {
                strBase += (DOUBLE_POINTS + nPort);
            }

            strBase += request.getContextPath();
        }

        if (!strBase.endsWith(SLASH)) {
            strBase += SLASH;
        }

        return strBase;
    }

    /**
     * Return the url of the webapp. The method should only be used out of
     * request context (by daemons for example). If there is a request context,
     * use {@link AppPathService#getBaseUrl(HttpServletRequest)} instead.
     *
     * @return The webapp url, or null if the 'lutece.base.url' property has not
     *         been set.
     * @deprecated Use {@link AppPathService#getBaseUrl(HttpServletRequest)}
     *             instead
     */
    @Deprecated
    public static String getBaseUrl() {
        HttpServletRequest request = LocalVariables.getRequest();

        if (request != null) {
            return getBaseUrl(request);
        }

        // FIXME : lutece.base.url is only set when using WSSO
        String strBaseUrl = AppPropertiesService.getProperty(PROPERTY_BASE_URL);

        if (strBaseUrl == null) {
            strBaseUrl = StringUtils.EMPTY;
        } else {
            if (!strBaseUrl.endsWith(SLASH)) {
                strBaseUrl += SLASH;
            }
        }

        return strBaseUrl;
    }

    /**
     * Return the webapp prod url (or the base url if no prod url has been
     * definied).
     *
     * @param request The HTTP request
     * @return The prod url
     */
    public static String getProdUrl(HttpServletRequest request) {
        String strBaseUrl = AppPropertiesService.getProperty(PROPERTY_PROD_BASE_URL);

        if (StringUtils.isBlank(strBaseUrl)) {
            strBaseUrl = getBaseUrl(request);
        }

        if (!strBaseUrl.endsWith(SLASH)) {
            strBaseUrl += SLASH;
        }

        return strBaseUrl;
    }

    /**
     * Return the webapp prod url (or the base url if no prod url has been
     * definied)
     *
     * @return The prod url
     * @deprecated Use {@link AppPathService#getProdUrl(String)} instead
     */
    @Deprecated
    public static String getProdUrl() {
        return getProdUrl(getBaseUrl());
    }

    /**
     * Return the webapp prod url. If no prod URL has been defined, then the
     * base URL is returned
     *
     * @param strBaseUrl The base URL
     * @return The prod url
     */
    public static String getProdUrl(String strBaseUrl) {
        String strProdUrl = AppPropertiesService.getProperty(PROPERTY_PROD_BASE_URL);

        if (StringUtils.isBlank(strProdUrl)) {
            strProdUrl = strBaseUrl;
        }

        if ((strProdUrl != null) && !strProdUrl.endsWith(SLASH)) {
            strProdUrl += SLASH;
        }

        return strProdUrl;
    }

    /**
     * Return the url of the webapp, built from the request
     *
     * @param request The HttpServletRequest
     * @return strBase the webapp url
     */
    public static String getSiteMessageUrl(HttpServletRequest request) {
        // Set the site message url
        return SiteMessageService.setSiteMessageUrl(getBaseUrl(request) + getSiteMessageUrl());
    }

    /**
     * Returns the portal page relative url (jsp/site/Portal.jsp) defined in
     * lutece.properties
     *
     * @return the Portal Url
     */
    public static String getPortalUrl() {
        return AppPropertiesService.getProperty(PROPERTY_PORTAL_URL);
    }

    /**
     * Returns the forward URL for webapp's root path. Default is
     * (jsp/site/Portal.jsp) defined in lutece.properties
     *
     * @return the Portal Root forward Url
     */
    public static String getRootForwardUrl() {
        return DatastoreService.getDataValue(KEY_PORTAL_HOME_URL,
                AppPropertiesService.getProperty(PROPERTY_PORTAL_REDIRECT_URL));
    }

    /**
     * Returns the Site Message relative url (jsp/site/SiteMessage.jsp) defined
     * in lutece.properties
     *
     * @return the SiteMessage Url
     */
    public static String getSiteMessageUrl() {
        return AppPropertiesService.getProperty(PROPERTY_SITE_MESSAGE_URL);
    }

    /**
     * Returns the admin portal page relative url (jsp/admin/site/AdminSite.jsp)
     * defined in lutece.properties
     *
     * @return the Portal Url
     */
    public static String getAdminPortalUrl() {
        return AppPropertiesService.getProperty(PROPERTY_ADMIN_URL);
    }

    /**
     * Returns the admin menu page relative url (jsp/admin/site/AdminMenu.jsp)
     * defined in lutece.properties
     *
     * @return the Admin Menu Url
     */
    public static String getAdminMenuUrl() {
        return DatastoreService.getDataValue(KEY_ADMIN_HOME_URL,
                AppPropertiesService.getProperty(PROPERTY_ADMIN_MENU_URL));
    }

    /**
     * Normalizes the Webapp Path
     *
     * @param strPath The path to normalize
     * @return The normalized path
     */
    private static String normalizeWebappPath(String strPath) {
        // convert Windows path separator if present
        String strNormalized = StringUtil.substitute(strPath, "/", "\\");

        // remove the ending separator if present
        if (strNormalized.endsWith("/")) {
            strNormalized = strNormalized.substring(0, strNormalized.length() - 1);
        }

        return strNormalized;
    }

    ////////////////////////////////////////////////////////////////////////////
    // Multiple virtual hosts configuration management
    /**
     * Gets available virtual hosts defined in the config.properties
     *
     * @return A reference list containing the key and the description of each
     *         virtual host configuration. The list is empty if there is no
     *         configuration defined.
     */
    public static ReferenceList getAvailableVirtualHosts() {
        ReferenceList list = null;

        // Get keys list form config.properties
        String strKeysList = AppPropertiesService.getProperty(PROPERTY_VIRTUAL_HOST_KEYS);

        if (strKeysList != null) {
            list = new ReferenceList();

            // Extracts each key (separated by a comma)
            StringTokenizer strTokens = new StringTokenizer(strKeysList, ",");

            while (strTokens.hasMoreTokens()) {
                String strHostKey = strTokens.nextToken();
                String strHostKeyDescription = AppPropertiesService
                        .getProperty(PROPERTY_VIRTUAL_HOST + strHostKey + SUFFIX_DESCRIPTION);
                list.addItem(strHostKey, strHostKeyDescription);
            }
        }

        return list;
    }

    /**
     * Gets a Virtual Host Key if the request contains a virtual host key
     *
     * @param request The HTTP request
     * @return A Virtual Host Key if present, otherwise null.
     */
    public static String getVirtualHostKey(HttpServletRequest request) {
        String strVirtalHostKey = null;

        // Get from config.properties the parameter name for virtual host keys
        String strVirtualHostKeyParameter = AppPropertiesService.getProperty(PROPERTY_VIRTUAL_HOST_KEY_PARAMETER);

        if ((request != null) && (strVirtualHostKeyParameter != null) && (!strVirtualHostKeyParameter.equals(""))) {
            // Search for this parameter into the request
            strVirtalHostKey = request.getParameter(strVirtualHostKeyParameter);
        }

        return strVirtalHostKey;
    }

    /**
     * Gets a Base Url for a virtual host if the request contains a virtual host
     * key
     *
     * @param request The HTTP request
     * @return A virtual host base url if present, otherwise null.
     */
    private static String getVirtualHostBaseUrl(HttpServletRequest request) {
        String strBaseUrl = null;
        String strVirtalHostKey = getVirtualHostKey(request);

        if ((strVirtalHostKey != null) && (!strVirtalHostKey.equals(""))) {
            // If found gets the Base url for this virtual host by its key
            strBaseUrl = AppPropertiesService
                    .getProperty(PROPERTY_VIRTUAL_HOST + strVirtalHostKey + SUFFIX_BASE_URL);
        }

        return strBaseUrl;
    }

    /**
     * Build the url item to use for a url that includes the redirection
     * parameter for reconnection.
     *
     * @param strRootUrl the root part of the url, to build an absolute url
     * @param strUrlPropertySuffixKey The property suffix to retrieve the url
     * @return an absolute url, completed with the redirectUrl parameter
     *         (contains the relative part of the url), as an UrlItem
     */
    public static UrlItem buildRedirectUrlItem(String strRootUrl, String strUrlPropertySuffixKey) {
        String strUrl = AppPropertiesService.getProperty(PROPERTY_PREFIX_URL + strUrlPropertySuffixKey);
        UrlItem url = new UrlItem(strRootUrl + strUrl);
        url.addParameter(Parameters.REDIRECT_URL, strUrlPropertySuffixKey);

        return url;
    }

    /**
     * Retrieve the url to redirect to after login. It is given by the
     * redirectUrl parameter if found. The request parameters are copied (except
     * the login and acces code). This is to be used by the doLogin method of
     * AdminLoginJspBean.
     *
     * @param request the http request
     * @param strDefaultRedirectUrl the default url to go to after login
     * @return an UrlItem corresponding to the url to redirect to after login.
     */
    public static UrlItem resolveRedirectUrl(HttpServletRequest request, String strDefaultRedirectUrl) {
        String strUrl = strDefaultRedirectUrl;

        String strUrlKey = request.getParameter(Parameters.REDIRECT_URL);
        String strRedirectUrl = null;

        if (strUrlKey != null) {
            strRedirectUrl = AppPropertiesService.getProperty(PROPERTY_PREFIX_URL + strUrlKey);
        }

        if (strRedirectUrl != null) {
            strUrl = strRedirectUrl;
        }

        Enumeration enumParams = request.getParameterNames();
        UrlItem url = new UrlItem(getBaseUrl(request) + strUrl);

        String strParamName;

        while (enumParams.hasMoreElements()) {
            strParamName = (String) enumParams.nextElement();

            if (!strParamName.equals(Parameters.REDIRECT_URL) && !strParamName.equals(Parameters.ACCESS_CODE)
                    && !strParamName.equals(Parameters.PASSWORD)) {
                url.addParameter(strParamName, request.getParameter(strParamName));
            }
        }

        return url;
    }

    /**
     * Returns the absolute url corresponding to the given one, if the later was
     * found to be relative. An url starting with "http://" is absolute. A
     * relative url should be given relatively to the webapp root.
     *
     * @param request the http request (provides the base path if needed)
     * @param strUrl the url to transform
     * @return the corresonding absolute url
     *
     *
     */
    public static String getAbsoluteUrl(HttpServletRequest request, String strUrl) {
        if ((strUrl != null) && !strUrl.startsWith("http://") && !strUrl.startsWith("https://")) {
            return AppPathService.getBaseUrl(request) + strUrl;
        }

        return strUrl;
    }

    /**
     * Gets the webapp instance defined in the config.properties file with the
     * key lutece.webapp.instance
     *
     * @return The instance name
     * @since 4.1
     */
    public static String getWebappInstance() {
        String strInstance = AppPropertiesService.getProperty(PROPERTY_INSTANCE);

        if ((strInstance != null) && (!strInstance.equals(StringUtils.EMPTY))) {
            return strInstance;
        }

        return INSTANCE_DEFAULT;
    }

    /**
     * Returns whether the current instance is the default webapp instance
     *
     * @return true if default, otherwise false
     */
    public static boolean isDefaultWebappInstance() {
        return INSTANCE_DEFAULT.equals(getWebappInstance());
    }
}