| /******************************************************************************* |
| * Copyright (c) 2005 Oracle Corporation. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Gerry Kessler - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.jst.jsf.core.internal.project.facet; |
| |
| import java.io.PrintWriter; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.jst.j2ee.common.CommonFactory; |
| import org.eclipse.jst.j2ee.common.ParamValue; |
| import org.eclipse.jst.j2ee.internal.J2EEVersionConstants; |
| import org.eclipse.jst.j2ee.model.IModelProvider; |
| import org.eclipse.jst.j2ee.webapplication.ContextParam; |
| import org.eclipse.jst.j2ee.webapplication.Servlet; |
| import org.eclipse.jst.j2ee.webapplication.ServletMapping; |
| import org.eclipse.jst.j2ee.webapplication.ServletType; |
| import org.eclipse.jst.j2ee.webapplication.WebApp; |
| import org.eclipse.jst.j2ee.webapplication.WebapplicationFactory; |
| import org.eclipse.jst.jsf.core.JSFVersion; |
| import org.eclipse.wst.common.frameworks.datamodel.IDataModel; |
| |
| /** |
| * Utility file for JSF model v1.1 |
| * |
| * @author Gerry Kessler - Oracle |
| */ |
| /*package use JSFUtilFactory*/ class JSFUtils11 extends JSFUtils { |
| |
| /** |
| * @param modelProvider |
| */ |
| protected JSFUtils11(final IModelProvider modelProvider) |
| { |
| super(JSFVersion.V1_1, modelProvider); |
| } |
| |
| /** |
| * @param webApp |
| * as Object |
| * @return Servlet - the JSF Servlet for the specified WebApp or null if not |
| * present |
| */ |
| private Servlet findJSFServlet(final WebApp webApp) |
| { |
| if (webApp == null) |
| { |
| return null; |
| } |
| |
| final Iterator it = webApp.getServlets().iterator(); |
| |
| while (it.hasNext()) |
| { |
| final Servlet servlet = (Servlet) it.next(); |
| if (servlet != null && servlet.getWebType() != null) |
| { |
| if (servlet.getWebType().isServletType()) |
| { |
| if (((ServletType) servlet.getWebType()).getClassName() != null |
| && ((ServletType) servlet.getWebType()) |
| .getClassName().trim().equals( |
| JSF_SERVLET_CLASS)) |
| { |
| return servlet; |
| } |
| } |
| } |
| } |
| |
| // if we get to here then we have finished the loop |
| // without finding the servlet we're looking for |
| return null; |
| } |
| |
| /** |
| * Creates a stubbed JSF configuration file for specified JSF version and |
| * path |
| */ |
| @Override |
| public void doVersionSpecificConfigFile(final PrintWriter pw) |
| { |
| final String QUOTE = new String(new char[] |
| { '"' }); |
| pw.write("<?xml version=" + QUOTE + "1.0" + QUOTE + " encoding=" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ |
| + QUOTE + "UTF-8" + QUOTE + "?>\n\n"); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| pw.write("<!DOCTYPE faces-config PUBLIC\n"); //$NON-NLS-1$ |
| pw.write(" " //$NON-NLS-1$ |
| + QUOTE |
| + "-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.1//EN" //$NON-NLS-1$ |
| + QUOTE + "\n"); //$NON-NLS-1$ |
| pw.write(" " + QUOTE //$NON-NLS-1$ |
| + "http://java.sun.com/dtd/web-facesconfig_1_1.dtd" //$NON-NLS-1$ |
| + QUOTE + ">\n\n"); //$NON-NLS-1$ |
| |
| pw.write("<faces-config>\n\n"); //$NON-NLS-1$ |
| pw.write("</faces-config>\n"); //$NON-NLS-1$ |
| } |
| |
| /** |
| * Creates servlet reference in WebApp if not present or updates servlet |
| * name if found using the passed configuration. |
| * |
| * @param webApp |
| * @param config |
| * @param servlet |
| * @return Servlet servlet - if passed servlet was null, will return created |
| * servlet |
| */ |
| private Servlet createOrUpdateServletRef(final WebApp webApp, |
| final IDataModel config, Servlet servlet) |
| { |
| |
| String displayName = getDisplayName(config); |
| String className = getServletClassname(config); |
| |
| if (servlet == null) |
| { |
| // Create the servlet instance and set up the parameters from data |
| // model |
| servlet = WebapplicationFactory.eINSTANCE.createServlet(); |
| servlet.setServletName(displayName); |
| |
| ServletType servletType = WebapplicationFactory.eINSTANCE |
| .createServletType(); |
| servletType.setClassName(className); |
| servlet.setWebType(servletType); |
| servlet.setLoadOnStartup(Integer.valueOf(1)); |
| // Add the servlet to the web application model |
| webApp.getServlets().add(servlet); |
| } |
| else |
| { |
| // update |
| updateServletMappings(webApp, servlet, displayName); |
| servlet.setServletName(displayName); |
| servlet.setLoadOnStartup(Integer.valueOf(1)); |
| } |
| return servlet; |
| } |
| |
| private void updateServletMappings(final WebApp webApp, |
| final Servlet servlet, final String displayName) |
| { |
| List<ServletMapping> mappings = findServletMappings(webApp, servlet); |
| for (ServletMapping map : mappings) |
| { |
| map.setName(displayName); |
| } |
| |
| } |
| |
| private List<ServletMapping> findServletMappings(final WebApp webApp, final Servlet servlet) { |
| String servletName = servlet.getServletName(); |
| servletName = servletName != null ? servletName.trim() : servletName; |
| final List<ServletMapping> mappings = new ArrayList<ServletMapping>(); |
| final List<ServletMapping> allMappings = webApp.getServletMappings(); |
| for (int i=allMappings.size()-1;i>=0;--i){ |
| ServletMapping mapping = allMappings.get(i); |
| if (mapping != null && |
| mapping.getServlet() != null && |
| mapping.getServlet().getServletName() != null && |
| mapping.getServlet().getServletName().trim().equals(servletName)) |
| mappings.add(mapping); |
| } |
| return mappings; |
| } |
| |
| /** |
| * Creates servlet-mappings for the servlet |
| * |
| * @param webApp |
| * @param urlMappingList - list of string values to be used in url-pattern for servlet-mapping |
| * @param servlet |
| */ |
| private void setUpURLMappings(final WebApp webApp, final List urlMappingList, |
| final Servlet servlet) { |
| // Add mappings |
| Iterator it = urlMappingList.iterator(); |
| while (it.hasNext()) { |
| String pattern = (String) it.next(); |
| if (!(doesServletMappingExist(webApp, servlet, pattern))){ |
| ServletMapping mapping = WebapplicationFactory.eINSTANCE |
| .createServletMapping(); |
| mapping.setServlet(servlet); |
| mapping.setName(servlet.getServletName()); |
| mapping.setUrlPattern(pattern); |
| webApp.getServletMappings().add(mapping); |
| } |
| } |
| } |
| |
| |
| private boolean doesServletMappingExist(final WebApp webApp, final Servlet servlet, |
| final String pattern) { |
| |
| List mappings = webApp.getServletMappings(); |
| String servletName = servlet.getServletName(); |
| if (servletName != null) |
| { |
| final Iterator it = mappings.iterator(); |
| while(it.hasNext()) |
| { |
| ServletMapping mapping = (ServletMapping) it.next(); |
| if (mapping != null && |
| mapping.getServlet() != null && |
| mapping.getServlet().getServletName() != null && |
| mapping.getServlet().getServletName().trim().equals(servletName) && |
| mapping.getUrlPattern() != null && |
| mapping.getUrlPattern().trim().equals(pattern)) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Removes servlet-mappings for servlet using servlet-name. |
| * @param webApp |
| * @param servlet |
| */ |
| private void removeURLMappings(final WebApp webApp, final Servlet servlet) { |
| List mappings = webApp.getServletMappings(); |
| String servletName = servlet.getServletName(); |
| if (servletName != null) { |
| for (int i=mappings.size()-1;i>=0;--i){ |
| ServletMapping mapping = (ServletMapping)mappings.get(i); |
| if (mapping != null && |
| mapping.getServlet() != null && |
| mapping.getServlet().getServletName() != null && |
| mapping.getServlet().getServletName().trim() |
| .equals(servletName)) { |
| mappings.remove(mapping); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Creates or updates config file context-param in v 2.3 WebApp if non default configuration file is specified. |
| * @param webApp |
| * @param config |
| */ |
| private void setupConfigFileContextParamForV2_3(final WebApp webApp, |
| final IDataModel config) { |
| // if not default name and location, then add context param |
| ContextParam cp = null; |
| ContextParam foundCP = null; |
| boolean found = false; |
| final String stringProperty = |
| config.getStringProperty(IJSFFacetInstallDataModelProperties.CONFIG_PATH); |
| if (stringProperty != null && |
| !stringProperty.equals(JSF_DEFAULT_CONFIG_PATH)) { |
| // check to see if present |
| Iterator it = webApp.getContexts().iterator(); |
| while (it.hasNext()) { |
| cp = (ContextParam) it.next(); |
| if (cp != null && |
| cp.getParamName() != null && |
| cp.getParamName().equals(JSF_CONFIG_CONTEXT_PARAM)) { |
| foundCP = cp; |
| found = true; |
| } |
| } |
| if (!found) { |
| cp = WebapplicationFactory.eINSTANCE.createContextParam(); |
| cp.setParamName(JSF_CONFIG_CONTEXT_PARAM); |
| cp.setParamValue(stringProperty); |
| webApp.getContexts().add(cp); |
| } else { |
| cp = foundCP; |
| if (cp.getParamValue().indexOf(stringProperty) < 0) { |
| String curVal = cp.getParamValue(); |
| String val = stringProperty; |
| if (curVal != null && !"".equals(curVal.trim())) { //$NON-NLS-1$ |
| val = curVal + ",\n" + val; //$NON-NLS-1$ |
| } |
| cp.setParamValue(val); |
| } |
| } |
| } |
| } |
| /** |
| * Creates or updates config file context-param in v2.4 WebApp if non default configuration file is specified. |
| * @param webApp |
| * @param config |
| */ |
| private void setupConfigFileContextParamForV2_4(final WebApp webApp, |
| final IDataModel config) { |
| // if not default name and location, then add context param |
| ParamValue foundCP = null; |
| ParamValue cp = null; |
| boolean found = false; |
| final String stringProperty = |
| config.getStringProperty(IJSFFacetInstallDataModelProperties.CONFIG_PATH); |
| if (stringProperty != null && |
| !stringProperty.equals(JSF_DEFAULT_CONFIG_PATH)) { |
| // check to see if present |
| Iterator it = webApp.getContextParams().iterator(); |
| while (it.hasNext()) { |
| cp = (ParamValue) it.next(); |
| if (cp != null && |
| cp.getName() != null && |
| cp.getName().trim().equals(JSF_CONFIG_CONTEXT_PARAM)) { |
| foundCP = cp; |
| found = true; |
| } |
| } |
| if (!found) { |
| ParamValue pv = CommonFactory.eINSTANCE.createParamValue(); |
| pv.setName(JSF_CONFIG_CONTEXT_PARAM); |
| pv.setValue(stringProperty); |
| webApp.getContextParams().add(pv); |
| } else { |
| cp = foundCP; |
| if (cp.getValue().indexOf(stringProperty) < 0) { |
| String curVal = cp.getValue(); |
| String val = stringProperty; |
| if (curVal != null && !"".equals(curVal.trim())) { //$NON-NLS-1$ |
| val = curVal + ",\n" + val; //$NON-NLS-1$ |
| } |
| cp.setValue(val); |
| } |
| } |
| } |
| } |
| |
| /** |
| * @param webApp |
| * @return the default file extension from the context param. Default is |
| * "jsp" if no context param. |
| */ |
| private String getDefaultSuffix(final WebApp webApp) |
| { |
| String defaultSuffix = getDefaultDefaultSuffix(); |
| if ("2.3".equals(webApp.getVersion())) //$NON-NLS-1$ |
| { |
| for (Iterator it = webApp.getContexts().iterator(); it.hasNext();) |
| { |
| ContextParam cp = (ContextParam) it.next(); |
| if (cp != null) |
| { |
| final String paramName = cp.getParamName(); |
| final String suffix = calculateSuffix(paramName, cp |
| .getParamValue()); |
| if (suffix != null) |
| { |
| return suffix; |
| } |
| } |
| } |
| } |
| else if ("2.4".equals(webApp.getVersion())) //$NON-NLS-1$ |
| { |
| for (Iterator it = webApp.getContextParams().iterator(); it.hasNext();) |
| { |
| ParamValue cp = (ParamValue) it.next(); |
| if (cp != null) |
| { |
| final String paramName = cp.getName(); |
| final String suffix = calculateSuffix(paramName, cp |
| .getValue()); |
| if (suffix != null) |
| { |
| return suffix; |
| } |
| } |
| } |
| } |
| return defaultSuffix; |
| } |
| |
| /** |
| * @param map |
| * @return prefix mapping. may return null. |
| */ |
| private String getPrefixMapping(final ServletMapping map) |
| { |
| final String urlPattern = map.getUrlPattern(); |
| if (urlPattern != null && urlPattern.trim().length() != 0) |
| { |
| IPath extPath = new Path(urlPattern); |
| if (extPath != null) |
| { |
| String ext = extPath.getFileExtension(); |
| if (ext == null) |
| { |
| String lastSeg = extPath.lastSegment(); |
| if (lastSeg != null && lastSeg.equals("*")) //$NON-NLS-1$ |
| { |
| return extPath.removeLastSegments(1).toString(); |
| } |
| |
| return extPath.toString(); |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * @param map |
| * @return extension from map. Will return null if file extension not found |
| * in url patterns. |
| */ |
| private String getFileExtensionFromMap(final ServletMapping map) |
| { |
| final String urlPattern = map.getUrlPattern(); |
| if (urlPattern != null |
| && urlPattern.trim().length() != 0) |
| { |
| IPath extPath = new Path(map.getUrlPattern()); |
| if (extPath != null) |
| { |
| String ext = extPath.getFileExtension(); |
| if (ext != null && ext.trim().length() != 0) |
| { |
| return ext; |
| } |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| public void updateWebApp(Object webApp, IDataModel config) |
| { |
| // create or update servlet ref |
| Servlet servlet = findJSFServlet((WebApp) webApp);// check to see |
| // if already |
| // present |
| |
| |
| servlet = createOrUpdateServletRef((WebApp) webApp, config, servlet); |
| |
| // init mappings |
| final List listOfMappings = getServletMappings(config); |
| setUpURLMappings((WebApp) webApp, listOfMappings, servlet); |
| |
| // setup context params |
| setupContextParams((WebApp) webApp, config); |
| } |
| |
| private void setupContextParams(WebApp webApp, final IDataModel config) { |
| if (webApp.getVersionID() == J2EEVersionConstants.WEB_2_3_ID)//shouldn't have to do it this way, but that's the way it goes 119442 |
| { |
| setupConfigFileContextParamForV2_3(webApp, config); |
| } |
| else if (webApp.getVersionID() == J2EEVersionConstants.WEB_2_4_ID) |
| { |
| setupConfigFileContextParamForV2_4(webApp, config); |
| } |
| else |
| { |
| throw new IllegalArgumentException("Invalid argument: "+webApp.getVersionID()); //$NON-NLS-1$ |
| } |
| } |
| |
| @Override |
| public void rollbackWebApp(Object webApp) |
| { |
| org.eclipse.jst.j2ee.webapplication.Servlet servlet = findJSFServlet((WebApp) webApp); |
| if (servlet == null) |
| { |
| return; |
| } |
| // remove faces url mappings |
| removeURLMappings((WebApp) webApp, servlet); |
| // remove context params |
| removeJSFContextParams((WebApp) webApp, servlet); |
| // remove servlet |
| removeJSFServlet((WebApp) webApp, servlet); |
| } |
| |
| private void removeJSFContextParams(final org.eclipse.jst.j2ee.webapplication.WebApp webApp, final org.eclipse.jst.j2ee.webapplication.Servlet servlet) { |
| if ("2.3".equals(webApp.getVersion())) //$NON-NLS-1$ |
| { |
| Iterator it = webApp.getContexts().iterator(); |
| while (it.hasNext()) |
| { |
| final ContextParam cp = (ContextParam) it.next(); |
| if (JSFUtils.JSF_CONFIG_CONTEXT_PARAM.equals(cp.getParamName())) |
| { |
| webApp.getContexts().remove(cp); |
| break; |
| } |
| } |
| } |
| else if ("2.4".equals(webApp.getVersion())) //$NON-NLS-1$ |
| { |
| Iterator it = webApp.getContextParams().iterator(); |
| while (it.hasNext()) |
| { |
| ParamValue cp = (ParamValue) it.next(); |
| if (cp.getName().equals(JSFUtils.JSF_CONFIG_CONTEXT_PARAM)) { |
| webApp.getContextParams().remove(cp); |
| break; |
| } |
| } |
| } |
| // otherwise do nothing |
| } |
| |
| private void removeJSFServlet(final org.eclipse.jst.j2ee.webapplication.WebApp webApp, final org.eclipse.jst.j2ee.webapplication.Servlet servlet) { |
| webApp.getServlets().remove(servlet); |
| } |
| |
| @Override |
| public IPath getFileUrlPath(Object webAppObj, IResource resource, |
| IPath existingURL) |
| { |
| if (webAppObj instanceof WebApp) |
| { |
| final WebApp webApp = (WebApp)webAppObj; |
| final Servlet servlet = findJSFServlet(webApp); |
| // if no faces servlet, do nothing |
| if (servlet == null) |
| { |
| return null; |
| } |
| |
| //if not a JSF page, do nothing |
| if (!isJSFPage(resource)) |
| { |
| return null; |
| } |
| |
| final String defaultSuffix = getDefaultSuffix(webApp); |
| //is the resource using default_suffix |
| final String fileExtension = resource.getFileExtension(); |
| final boolean canUseExtensionMapping = |
| fileExtension != null && fileExtension.equalsIgnoreCase(defaultSuffix); |
| |
| //if not using default extension and is not a known file extension, then we will abort |
| if (! canUseExtensionMapping && ! isValidKnownExtension(fileExtension)) |
| { |
| return null; |
| } |
| |
| Iterator mappings = servlet.getMappings().iterator(); |
| ServletMapping map = null; |
| String foundFileExtension = null; |
| String foundPrefixMapping = null; |
| while (mappings.hasNext()) |
| { |
| map = (ServletMapping)mappings.next(); |
| |
| foundFileExtension = getFileExtensionFromMap(map); |
| if (foundFileExtension != null && canUseExtensionMapping) |
| { |
| return existingURL.removeFileExtension().addFileExtension(foundFileExtension); |
| } |
| |
| if (foundPrefixMapping == null) |
| { |
| foundPrefixMapping = getPrefixMapping(map); |
| } |
| } |
| if (foundPrefixMapping != null) |
| { |
| return new Path(foundPrefixMapping).append(existingURL); |
| } |
| if (! canUseExtensionMapping && foundFileExtension != null){ |
| //we could prompt user that this may not work... |
| //for now we will return the extension mapping |
| return existingURL.removeFileExtension().addFileExtension(foundFileExtension); |
| } |
| |
| //we could, at this point, add a url mapping to the faces servlet, or prompt user that it may be a good idea to add one... ;- |
| } |
| return null; |
| } |
| } |
