Java tutorial
/* * 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()); } }