jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/webxml/WebXmlUtilsForJ2EE.java

/*******************************************************************************
 * Copyright (c) 2001, 2008 Oracle Corporation and others. 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: Oracle Corporation - initial API and implementation
 *******************************************************************************/


package org.eclipse.jst.jsf.common.webxml;


import java.util.Arrays;
import java.util.List;

import org.eclipse.jst.j2ee.common.CommonFactory;
import org.eclipse.jst.j2ee.common.Description;
import org.eclipse.jst.j2ee.common.Listener;
import org.eclipse.jst.j2ee.common.ParamValue;
import org.eclipse.jst.j2ee.webapplication.Filter;
import org.eclipse.jst.j2ee.webapplication.FilterMapping;
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.j2ee.webapplication.internal.impl.ServletTypeImpl;


/**
 * Web.xml editing utilities for J2EE (Servlet 2.4 and lower versions).
 *
 * @author Debajit Adhikary
 *
 */
public class WebXmlUtilsForJ2EE
{
    /**
     * @param webapp
     * @param servletName
     * @param servletClass
     * @param loadOnStartup
     */
    public static void addServlet (final WebApp webapp,
                                   final String servletName,
                                   final String servletClass,
                                   final String loadOnStartup)
    {
        if (existsServlet(webapp, servletName, servletClass))
            return;

        // Create new servlet

        final Servlet servlet = WebapplicationFactory.eINSTANCE.createServlet();
        servlet.setServletName(servletName);
        servlet.setLoadOnStartup(new Integer(loadOnStartup));

        final ServletType servletType = WebapplicationFactory.eINSTANCE.createServletType();
        servletType.setClassName(servletClass);
        servlet.setWebType(servletType);

        webapp.getServlets().add(servlet);
    }


    /**
     * @param webapp
     * @param servletName
     * @param servletClass
     * @return true if the specified servlet is declared for use in webapp
     */
    public static boolean existsServlet (final WebApp webapp,
                                         final String servletName,
                                         final String servletClass)
    {
        return findServlet(webapp, servletName, servletClass) != null;
    }


    /**
     * @param webapp
     *            Webapp in which to look for
     * @param servletName
     *            Servlet name
     * @param servletClass
     *            Servlet class
     *
     * @return The servlet containing the specified servlet-name and
     *         servlet-class in web.xml
     */
    public static Servlet findServlet (final WebApp webapp,
                                       final String servletName,
                                       final String servletClass)
    {
        for (final Object s : webapp.getServlets())
        {
            final Servlet servlet = (Servlet) s;
            if (servlet.getServletName().equals(servletName)
                    && ((ServletType) servlet.getWebType()).getClassName().equals(servletClass))
            {
                return servlet;
            }
        }

        return null;
    }


    /**
     * @param webApp
     * @param servletClassName
     * @return the servlet or null if not found
     */
    public static Servlet findServlet (final WebApp webApp,
                                       final String servletClassName)
    {
        for (final Object servlet : webApp.getServlets())
        {
            final org.eclipse.jst.j2ee.webapplication.Servlet j2eeServlet = (org.eclipse.jst.j2ee.webapplication.Servlet) servlet;
            final String servletClass = ((ServletTypeImpl) j2eeServlet.getWebType()).getClassName();
            if (servletClass.equals(servletClassName))
                return j2eeServlet;
        }
        return null;
    }


    /**
     * @param webapp
     * @param servletName
     * @return the servlet or null if not found
     */
    public static Servlet findServletByName (final WebApp webapp,
                                             final String servletName)
    {
        for (final Object s : webapp.getServlets())
        {
            final Servlet servlet = (Servlet) s;
            if (servlet.getServletName().trim().equals(servletName))
                return servlet;
        }

        return null;
    }


    /**
     * @param webApp
     * @param servlet
     */
    public static void removeServlet (final WebApp webApp,
                                      final Servlet servlet)
    {
        webApp.getServlets().remove(servlet);
    }


    /**
     * @param webapp
     * @param servletName
     * @param servletClass
     * @param urlPattern
     */
    public static void addServletMapping (final WebApp webapp,
                                          final String servletName,
                                          final String servletClass,
                                          final String urlPattern)
    {
        if (existsServletMapping(webapp, servletName, urlPattern))
            return;

        final Servlet servlet = findServlet(webapp, servletName, servletClass);
        if (servlet == null)
            throw new IllegalArgumentException("Cannot create servlet mapping with servlet name \"" //$NON-NLS-1$
                    + servletName + "\" and URL pattern \"" //$NON-NLS-1$
                    + urlPattern + "\". No corresponding servlet is defined."); //$NON-NLS-1$

        final ServletMapping servletMapping = WebapplicationFactory.eINSTANCE.createServletMapping();
        servletMapping.setServlet(servlet);
        servletMapping.setName(servletName);
        servletMapping.setUrlPattern(urlPattern);

        webapp.getServletMappings().add(servletMapping);
    }


    /**
     * @param webapp
     * @param servletName
     * @param urlPattern
     * @return true if the servlet mapping exists
     */
    public static boolean existsServletMapping (final WebApp webapp,
                                                final String servletName,
                                                final String urlPattern)
    {
        return findServletMapping(webapp, servletName, urlPattern) != null;
    }


    /**
     * @param webapp
     * @param servletName
     * @param urlPattern
     * @return the servlet mapping
     */
    public static ServletMapping findServletMapping (final WebApp webapp,
                                                     final String servletName,
                                                     final String urlPattern)
    {
        for (final Object mapping : webapp.getServletMappings())
        {
            final ServletMapping servletMapping = (ServletMapping) mapping;
            if (servletMapping.getName().equals(servletName)
                    && servletMapping.getUrlPattern().equals(urlPattern))
            {
                return servletMapping;
            }
        }

        return null;
    }


    /**
     * @param webApp
     * @param servlet
     */
    public static void removeServletMappings (final WebApp webApp,
                                              final Servlet servlet)
    {
        final List mappings = webApp.getServletMappings();
        String servletName = servlet.getServletName();

        if (servletName != null)
        {
            servletName = servletName.trim();
            for (int i = mappings.size() - 1; i >= 0; --i)
            {
                final ServletMapping mapping = (ServletMapping) mappings.get(i);
                if (mapping != null && mapping.getServlet().getServletName() != null
                        && mapping.getServlet().getServletName().trim().equals(servletName))
                {
                    mappings.remove(mapping);
                }
            }
        }
    }


    /**
     * @param webapp
     * @param filterName
     * @param filterClass
     */
    public static void addFilter (final WebApp webapp,
                                  final String filterName,
                                  final String filterClass)
    {
        if (existsFilter(webapp, filterName, filterClass))
            return;

        webapp.getFilters().add(createFilter(filterName, filterClass));
    }


    /**
     * @param filterName
     * @param filterClass
     * @return the filter or null if not found.
     */
    public static Filter createFilter (final String filterName,
                                       final String filterClass)
    {
        final Filter filter = WebapplicationFactory.eINSTANCE.createFilter();
        filter.setName(filterName);
        filter.setFilterClassName(filterClass);
        return filter;
    }


    /**
     * @param webapp
     * @param filterName
     * @param filterClass
     * @return true if the filter exists.
     */
    public static boolean existsFilter (final WebApp webapp,
                                        final String filterName,
                                        final String filterClass)
    {
        return findFilter(webapp, filterName, filterClass) != null;
    }


    /**
     * @param webapp
     * @param filterName
     * @param filterClass
     * @return the filter or null if not found.
     */
    public static Filter findFilter (final WebApp webapp,
                                     final String filterName,
                                     final String filterClass)
    {
        for (final Object f : webapp.getFilters())
        {
            final Filter filter = (Filter) f;
            if (filter.getName().trim().equals(filterName)
                    && filter.getFilterClassName().trim().equals(filterClass))
            {
                return filter;
            }
        }

        return null;
    }


    /**
     * @param webApp
     * @param filterClassName
     * @return the filter or null if not found.
     */
    public static Filter findFilter (final WebApp webApp,
                                     final String filterClassName)
    {
        for (final Object filter : webApp.getFilters())
        {
            if (((Filter) filter).getFilterClassName().trim().equals(filterClassName))
                return (Filter) filter;
        }

        return null;
    }


    /**
     * @param webapp
     * @param filterName
     * @param filterClass
     * @param servletName
     */
    public static void addFilterMapping (final WebApp webapp,
                                         final String filterName,
                                         final String filterClass,
                                         final String servletName)
    {
        if (existsFilterMapping(webapp, filterName, servletName))
            return;


        // Find corresponding filter
        final Filter filter = findFilter(webapp, filterName, filterClass);
        if (filter == null)
            throw new IllegalArgumentException("Cannot create filter mapping with filter name \"" //$NON-NLS-1$
                    + filterName + "\" and servlet name \"" //$NON-NLS-1$
                    + servletName + "\". No corresponding filter is defined."); //$NON-NLS-1$


        // Find corresponding servlet
        final Servlet servlet = findServletByName(webapp, servletName);
        if (servlet == null)
            throw new IllegalArgumentException("Cannot create filter mapping with filter name \"" //$NON-NLS-1$
                    + filterName + "\" and servlet name \"" //$NON-NLS-1$
                    + servletName + "\". No corresponding servlet is defined."); //$NON-NLS-1$


        // Create new filter mapping
        final FilterMapping filterMapping = WebapplicationFactory.eINSTANCE.createFilterMapping();
        filterMapping.setFilter(filter);
        filterMapping.setServlet(servlet);
        filterMapping.setServletName(servletName);

        webapp.getFilterMappings().add(filterMapping);
    }


    /**
     * @param webapp
     * @param filterName
     * @param servletName
     * @return true if the filter mapping exists
     */
    public static boolean existsFilterMapping (final WebApp webapp,
                                               final String filterName,
                                               final String servletName)
    {
        return findFilterMapping(webapp, filterName, servletName) != null;
    }


    /**
     * @param webapp
     * @param filterName
     * @param servletName
     * @return the filter mapping or null if it doesn't exist.
     */
    public static FilterMapping findFilterMapping (final WebApp webapp,
                                                   final String filterName,
                                                   final String servletName)
    {
        for (final Object fm : webapp.getFilterMappings())
        {
            final FilterMapping filterMapping = (FilterMapping) fm;

            if (filterMapping.getFilter().getName().trim().equals(filterName)
                    && filterMapping.getServletName().equals(servletName))
            {
                return filterMapping;
            }
        }

        return null;
    }


    /**
     * @param webApp
     * @param paramName
     * @param paramValue
     * @param description
     */
    public static void addContextParam (final WebApp webApp,
                                        final String paramName,
                                        final String paramValue,
                                        final String description)
    {
        if (existsContextParam(webApp, paramName, paramValue))
            return;

        webApp.getContextParams().add(createContextParam(paramName, paramValue, description));
    }


    /**
     * @param paramName
     * @param paramValue
     * @param descriptionString
     * @return the param value or null if doesn't exist
     */
    public static ParamValue createContextParam (final String paramName,
                                                 final String paramValue,
                                                 final String descriptionString)
    {
        final ParamValue param = CommonFactory.eINSTANCE.createParamValue();
        param.setName(paramName);
        param.setValue(paramValue);

        if (descriptionString != null)
        {
            final Description description = CommonFactory.eINSTANCE.createDescription();
            description.setValue(descriptionString);
            param.getDescriptions().add(description);
        }

        return param;
    }


    /**
     * @param webApp
     * @param paramName
     * @param paramValue
     * @return true if the context param exists.
     */
    public static boolean existsContextParam (final WebApp webApp,
                                              final String paramName,
                                              final String paramValue)
    {
        return findContextParam(webApp, paramName, paramValue) != null;
    }


    /**
     * @param webApp
     * @param paramName
     * @param paramValue
     * @return the param value or null if not found
     */
    public static ParamValue findContextParam (final WebApp webApp,
                                               final String paramName,
                                               final String paramValue)
    {
        for (final Object param : webApp.getContextParams())
        {
            final ParamValue contextParam = (ParamValue) param;
            if (contextParam.getName().equals(paramName)
                    && contextParam.getValue().equals(paramValue))
            {
                return contextParam;
            }
        }

        return null;
    }


    /**
     * @param webApp
     * @param paramName
     * @return the param value or null if not found
     */
    public static String getContextParamValue (final WebApp webApp,
                                               final String paramName)
    {
        for (final Object param : webApp.getContextParams())
        {
            final ParamValue contextParam = (ParamValue) param;
            if (contextParam.getName().equals(paramName))
            {
                return contextParam.getValue();
            }
        }

        return null;
    }


    /**
     * @param webApp
     * @param paramName Name of context param
     * @param valuesDelimiterRegex
     * @return Values of the given context param as a list
     */
    public static List<String> getContextParamValuesAsList (final WebApp webApp,
                                                            final String paramName,
                                                            final String valuesDelimiterRegex)
    {
        final String valuesString = getContextParamValue(webApp, paramName);
        return Arrays.asList(valuesString.split(valuesDelimiterRegex));
    }


    /**
     * Updates the value of a context param if it exists. Otherwise, adds this
     * as a new context param.
     * 
     * @param webApp
     * @param paramName
     * @param paramValue
     */
    public static void setContextParamValue (final WebApp webApp,
                                             final String paramName,
                                             final String paramValue)
    {
        ParamValue contextParam = null;

        for (final Object p : webApp.getContextParams())
        {
            final ParamValue param = (ParamValue) p;
            if (param.getName().equals(paramName))
            {
                contextParam = param;
                break;
            }
        }

        if (contextParam == null)
        {
            webApp.getContextParams().add(createContextParam(paramName, paramValue, null));
        }
        else
        {
            contextParam.setValue(paramValue);
        }
    }


    /**
     * @param webapp
     * @param listenerClass
     */
    public static void addListener (final WebApp webapp,
                                    final String listenerClass)
    {
        if (existsListener(webapp, listenerClass))
            return;

        // Create new listener
        final Listener listener = CommonFactory.eINSTANCE.createListener();
        listener.setListenerClassName(listenerClass);

        webapp.getListeners().add(listener);
    }


    /**
     * @param webapp
     * @param listenerClass
     * @return true if the listener exists
     */
    public static boolean existsListener (final WebApp webapp,
                                          final String listenerClass)
    {
        return findListener(webapp, listenerClass) != null;
    }


    /**
     * @param webapp
     * @param listenerClass
     * @return the listener or null if not found
     */
    public static Listener findListener (final WebApp webapp,
                                         final String listenerClass)
    {
        for (final Object listener : webapp.getListeners())
            if (((Listener) listener).getListenerClassName().equals(listenerClass))
                return (Listener) listener;

        return null;
    }
}