| /******************************************************************************* |
| * Copyright (c) 2006 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: |
| * Cameron Bateman/Oracle - initial API and implementation |
| * |
| ********************************************************************************/ |
| |
| package org.eclipse.jst.jsf.designtime; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.util.Properties; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.Platform; |
| import org.eclipse.core.runtime.QualifiedName; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jst.jsf.core.internal.JSFCorePlugin; |
| import org.eclipse.jst.jsf.core.jsfappconfig.JSFAppConfigUtils; |
| import org.eclipse.jst.jsf.designtime.context.AbstractDTExternalContextFactory; |
| import org.eclipse.jst.jsf.designtime.context.DTFacesContext; |
| import org.eclipse.jst.jsf.designtime.context.IExternalContextFactoryLocator; |
| import org.eclipse.jst.jsf.designtime.el.AbstractDTMethodResolver; |
| import org.eclipse.jst.jsf.designtime.el.AbstractDTPropertyResolver; |
| import org.eclipse.jst.jsf.designtime.el.AbstractDTVariableResolver; |
| import org.eclipse.jst.jsf.designtime.internal.BasicExtensionFactory.ExtensionData; |
| import org.eclipse.jst.jsf.designtime.internal.view.IDTViewHandler; |
| |
| |
| /** |
| * Per-web-application manager that manages design time information for a corresponding |
| * project. |
| * |
| * TODO: migrate to managed singleton |
| * @author cbateman |
| * |
| */ |
| public final class DesignTimeApplicationManager |
| { |
| // TODO: load from property file? |
| private static final String PROPERTY_QUALIFIER = "org.eclipse.jst.jsf.designtime.internal"; //$NON-NLS-1$ |
| private static final String SESSION_PROPERTY_NAME_PROJECT = "DesignTimeApplicationManager"; //$NON-NLS-1$ |
| private static final QualifiedName SESSION_PROPERTY_KEY_PROJECT |
| = new QualifiedName(PROPERTY_QUALIFIER, SESSION_PROPERTY_NAME_PROJECT); |
| |
| private static final String SESSION_PROPERTY_NAME_FACES_CONTEXT = "DTFacesContext"; //$NON-NLS-1$ |
| private static final QualifiedName SESSION_PROPERTY_KEY_FACES_CONTEXT |
| = new QualifiedName(PROPERTY_QUALIFIER, SESSION_PROPERTY_NAME_FACES_CONTEXT); |
| |
| private static final String PERSIST_PROPERTY_NAME_EXTERNAL_CONTEXT_PROVIDER = |
| "ExternalContextProvider"; //$NON-NLS-1$ |
| private static final QualifiedName PERSIST_PROPERTY_KEY_EXTERNAL_CONTEXT_PROVIDER = |
| new QualifiedName(PROPERTY_QUALIFIER, PERSIST_PROPERTY_NAME_EXTERNAL_CONTEXT_PROVIDER); |
| |
| private static final String PERSIST_PROPERTY_NAME_VARIABLE_RESOLVER_PROVIDER = |
| "VariableResolverProvider"; //$NON-NLS-1$ |
| private static final QualifiedName PERSIST_PROPERTY_KEY_VARIABLE_RESOLVER_PROVIDER |
| = new QualifiedName(PROPERTY_QUALIFIER, PERSIST_PROPERTY_NAME_VARIABLE_RESOLVER_PROVIDER); |
| |
| private static final String PERSIST_PROPERTY_NAME_PROPERTY_RESOLVER_PROVIDER = |
| "PropertyResolverProvider"; //$NON-NLS-1$ |
| private static final QualifiedName PERSIST_PROPERTY_KEY_PROPERTY_RESOLVER_PROVIDER = |
| new QualifiedName(PROPERTY_QUALIFIER, PERSIST_PROPERTY_NAME_PROPERTY_RESOLVER_PROVIDER); |
| |
| private static final String PERSIST_PROPERTY_NAME_METHOD_RESOLVER_PROVIDER = |
| "MethodResolverProvider"; //$NON-NLS-1$ |
| private static final QualifiedName PERSIST_PROPERTY_KEY_METHOD_RESOLVER_PROVIDER = |
| new QualifiedName(PROPERTY_QUALIFIER, PERSIST_PROPERTY_NAME_METHOD_RESOLVER_PROVIDER); |
| |
| private static final String PERSIST_PROPERTY_NAME_VIEW_HANDLER = |
| "ViewHandler"; //$NON-NLS-1$ |
| |
| private static final String DEFAULT_EXTERNAL_CONTEXT_ID = |
| "org.eclipse.jst.jsf.core.externalcontext.default"; //$NON-NLS-1$ |
| |
| private static final String DEFAULT_VARIABLE_RESOLVER_ID = |
| "org.eclipse.jst.jsf.core.variableresolver.default.decorative"; //$NON-NLS-1$ |
| |
| private static final String DEFAULT_PROPERTY_RESOLVER_ID = |
| "org.eclipse.jst.jsf.core.propertyresolver.default.decorative"; //$NON-NLS-1$ |
| |
| private static final String DEFAULT_METHOD_RESOLVER_ID = |
| "org.eclipse.jst.jsf.core.methodresolver.default"; //$NON-NLS-1$ |
| |
| private static final String DEFAULT_VIEW_HANDLER_ID = |
| "org.eclipse.jst.jsf.designtime.view.jspviewhandler"; //$NON-NLS-1$ |
| |
| /** |
| * @param project |
| * @return the app manager associated with project |
| */ |
| public final static DesignTimeApplicationManager getInstance(IProject project) |
| { |
| if (!hasJSFDesignTime(project)) |
| { |
| return null; |
| } |
| |
| try |
| { |
| synchronized(project) |
| { |
| DesignTimeApplicationManager manager = |
| (DesignTimeApplicationManager) project.getSessionProperty(SESSION_PROPERTY_KEY_PROJECT); |
| |
| |
| if (manager == null) |
| { |
| manager = new DesignTimeApplicationManager(project); |
| project.setSessionProperty(SESSION_PROPERTY_KEY_PROJECT, manager); |
| } |
| // bug 147729: if project was renamed, the project param will be |
| // valid, but it will not be in sync with the one for _project |
| // unfortunately, since we are using session propertie |
| else |
| { |
| synchronized(manager) |
| { |
| if (!project.equals(manager._project)) |
| { |
| manager._project = project; |
| } |
| } |
| } |
| |
| return manager; |
| } |
| } |
| catch (CoreException ce) |
| { |
| Platform.getLog(JSFCorePlugin.getDefault().getBundle()).log(new Status(IStatus.ERROR, JSFCorePlugin.getDefault().getBundle().getSymbolicName(), 0, "Problem loading design time appmanager", new Throwable(ce))); //$NON-NLS-1$ |
| } |
| |
| return null; |
| } |
| |
| /** |
| * The criteria for a project having a JSF design time are: |
| * |
| * - project is non-null. |
| * - project is accessible (project.isAccessible() == true) |
| * - project has a JSF facet (this implies that it's dependent facets are also present). |
| * |
| * @param project |
| * @return true if project can have a JSF DesignTimeApplicationManager |
| * associated with it. getInstance(project) uses this determine if should |
| * construct an instance for a project. |
| */ |
| public static boolean hasJSFDesignTime(final IProject project) |
| { |
| return project != null && project.isAccessible() && |
| JSFAppConfigUtils.isValidJSFProject(project); |
| } |
| |
| // instance definition |
| // _project must be writable in case the manager needs to be retargetted |
| // after a rename/move etc. |
| private IProject _project; |
| private final IExternalContextFactoryLocator _locator; |
| //private IDTViewHandler _viewHandler; |
| private Properties _properties; |
| |
| private DesignTimeApplicationManager(IProject project) |
| { |
| _project = project; |
| _locator = new MyExternalContextFactoryLocator(); |
| _properties = loadProperties(_project); |
| } |
| |
| /** |
| * @param file must not be null |
| * @return the faces context for the file or null if not found |
| */ |
| public DTFacesContext getFacesContext(IFile file) |
| { |
| if (!hasDTFacesContext(file)) |
| { |
| return null; |
| } |
| |
| try |
| { |
| synchronized(file) |
| { |
| Object context = file.getSessionProperty(SESSION_PROPERTY_KEY_FACES_CONTEXT); |
| |
| if (context == null) |
| { |
| context = new DTFacesContext(file, _locator); |
| file.setSessionProperty(SESSION_PROPERTY_KEY_PROJECT, context); |
| } |
| |
| return (DTFacesContext) context; |
| } |
| } |
| catch (CoreException ce) |
| { |
| Platform.getLog(JSFCorePlugin.getDefault().getBundle()) |
| .log(new Status(IStatus.ERROR, |
| JSFCorePlugin.getDefault().getBundle().getSymbolicName(), |
| 0, "Problem loading design time facescontext", //$NON-NLS-1$ |
| new Throwable(ce))); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Only files for which a runtime request context will be generated |
| * have a corresponding design time context. This is generally confined |
| * to view definition files such as JSP's. |
| * |
| * General criteria for a file to have a design time faces context are: |
| * |
| * - the file is non-null and isAccessible() |
| * - the file has designtime view handler (getViewHandler(file) != null) |
| * and it supports the content type of file. |
| * |
| * getFacesContext uses this to decide whether to generate a context |
| * for an IFile. |
| * |
| * @param file |
| * @return true if file has a design time faces context |
| */ |
| public boolean hasDTFacesContext(final IFile file) |
| { |
| IDTViewHandler viewHandler = getViewHandler(); |
| |
| if (file != null && file.isAccessible()&& |
| viewHandler != null && viewHandler.supportsViewDefinition(file)) |
| { |
| return true; |
| } |
| return false; |
| } |
| /** |
| * @return the design time view handler for this webap (project). |
| */ |
| public synchronized IDTViewHandler getViewHandler() |
| { |
| final String viewHandlerId = |
| getFromProjectSettings(PERSIST_PROPERTY_NAME_VIEW_HANDLER |
| , DEFAULT_VIEW_HANDLER_ID); |
| |
| if (viewHandlerId != null) |
| { |
| return JSFCorePlugin.getViewHandlers(viewHandlerId).getInstance(_project); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Sets the persistent id on this project that will be used to load the |
| * view handler. |
| * |
| * @param viewHandlerId |
| */ |
| public synchronized void setViewHandlerId(final String viewHandlerId) |
| { |
| setProjectSetting(PERSIST_PROPERTY_NAME_VIEW_HANDLER, viewHandlerId); |
| } |
| |
| /** |
| * @param resolverPluginId |
| * @throws CoreException |
| */ |
| public synchronized void setExternalContextProvider(final String resolverPluginId) |
| throws CoreException |
| { |
| _project.setPersistentProperty |
| (PERSIST_PROPERTY_KEY_EXTERNAL_CONTEXT_PROVIDER, resolverPluginId); |
| } |
| |
| /** |
| * @return the id of the active design time external context provider |
| */ |
| public synchronized String getExternalContextProvider() |
| { |
| return getResolverId(PERSIST_PROPERTY_KEY_EXTERNAL_CONTEXT_PROVIDER, |
| DEFAULT_EXTERNAL_CONTEXT_ID); |
| } |
| |
| /** |
| * @return the designtime variable resolver for this application |
| */ |
| public synchronized AbstractDTVariableResolver getVariableResolver() |
| { |
| ExtensionData<AbstractDTVariableResolver> extData = null; |
| |
| String id = getResolverId_OLD(PERSIST_PROPERTY_KEY_VARIABLE_RESOLVER_PROVIDER); |
| if (id != null) |
| { |
| extData = JSFCorePlugin.getVariableResolvers(id); |
| } |
| |
| if (extData == null) |
| { |
| extData = JSFCorePlugin.getVariableResolvers(DEFAULT_VARIABLE_RESOLVER_ID); |
| } |
| |
| return extData.getInstance(_project); |
| } |
| |
| /** |
| * Sets the plugin used to determine the designtime variable resolver. To |
| * reset to the default, pass null. |
| * |
| * @param resolverPluginId |
| * @throws CoreException -- if the setting the new value fails |
| */ |
| public synchronized void setVariableResolverProvider(final String resolverPluginId) |
| throws CoreException |
| { |
| _project.setPersistentProperty |
| (PERSIST_PROPERTY_KEY_VARIABLE_RESOLVER_PROVIDER, resolverPluginId); |
| } |
| |
| /** |
| * @return the id of the active design time variable resolver |
| */ |
| public synchronized String getVariableResolverProvider() |
| { |
| return getResolverId(PERSIST_PROPERTY_KEY_VARIABLE_RESOLVER_PROVIDER, |
| DEFAULT_VARIABLE_RESOLVER_ID); |
| } |
| |
| /** |
| * @return the default property resolver that will be used if no other |
| * is provided. The default property resolver is intended to match the |
| * similar resolver used by the runtime. |
| */ |
| public synchronized AbstractDTPropertyResolver getDefaultPropertyResolver() |
| { |
| return JSFCorePlugin.getPropertyResolver(DEFAULT_PROPERTY_RESOLVER_ID).getInstance(_project); |
| } |
| |
| /** |
| * @return the designtime property resolver for this application |
| */ |
| public synchronized AbstractDTPropertyResolver getPropertyResolver() |
| { |
| ExtensionData<AbstractDTPropertyResolver> extData = null; |
| |
| String id = getResolverId_OLD(PERSIST_PROPERTY_KEY_PROPERTY_RESOLVER_PROVIDER); |
| if (id != null) |
| { |
| extData = JSFCorePlugin.getPropertyResolver(id); |
| } |
| |
| if (extData == null) |
| { |
| extData = JSFCorePlugin.getPropertyResolver(DEFAULT_PROPERTY_RESOLVER_ID); |
| } |
| |
| return extData.getInstance(_project); |
| } |
| |
| /** |
| * @param resolverPluginId |
| * @throws CoreException -- if setting the provider fails |
| */ |
| public synchronized void setPropertyResolverProvider(final String resolverPluginId) |
| throws CoreException |
| { |
| _project.setPersistentProperty |
| (PERSIST_PROPERTY_KEY_PROPERTY_RESOLVER_PROVIDER, resolverPluginId); |
| } |
| |
| /** |
| * @return the id of the active design time variable resolver |
| */ |
| public synchronized String getPropertyResolverProvider() |
| { |
| return getResolverId(PERSIST_PROPERTY_KEY_PROPERTY_RESOLVER_PROVIDER, |
| DEFAULT_PROPERTY_RESOLVER_ID); |
| } |
| |
| /** |
| * @return the designtime method resolver for this application |
| */ |
| public synchronized AbstractDTMethodResolver getMethodResolver() |
| { |
| ExtensionData<AbstractDTMethodResolver> extData = null; |
| |
| String id = getResolverId_OLD(PERSIST_PROPERTY_KEY_METHOD_RESOLVER_PROVIDER); |
| if (id != null) |
| { |
| extData = JSFCorePlugin.getMethodResolvers(id); |
| } |
| |
| if (extData == null) |
| { |
| extData = JSFCorePlugin.getMethodResolvers(DEFAULT_METHOD_RESOLVER_ID); |
| } |
| |
| return extData.getInstance(_project); |
| } |
| |
| /** |
| * @param resolverPluginId |
| * @throws CoreException -- if setting the plugin fails |
| */ |
| public synchronized void setMethodResolverProvider(final String resolverPluginId) |
| throws CoreException |
| { |
| _project.setPersistentProperty |
| (PERSIST_PROPERTY_KEY_METHOD_RESOLVER_PROVIDER, resolverPluginId); |
| |
| } |
| |
| /** |
| * @return the id of the active design time variable resolver |
| */ |
| public synchronized String getMethodResolverProvider() |
| { |
| return getResolverId(PERSIST_PROPERTY_KEY_METHOD_RESOLVER_PROVIDER, |
| DEFAULT_METHOD_RESOLVER_ID); |
| } |
| |
| private String getResolverId_OLD(final QualifiedName pluginKey) |
| { |
| String pluginId = null; |
| |
| try |
| { |
| pluginId = |
| _project.getPersistentProperty(pluginKey); |
| } |
| catch (CoreException ce) |
| { |
| JSFCorePlugin.getDefault().getLog().log( |
| new Status(IStatus.ERROR, JSFCorePlugin.PLUGIN_ID, |
| 0, "Error getting plugin property", //$NON-NLS-1$ |
| ce)); |
| pluginId = null; |
| // fall-through and use the default |
| } |
| |
| return pluginId; |
| } |
| |
| private String getResolverId(final QualifiedName key, final String defaultValue) |
| { |
| String id = defaultValue; |
| |
| try |
| { |
| final String userId = |
| _project.getPersistentProperty(key); |
| |
| if (userId != null) |
| { |
| id = userId; |
| } |
| } |
| catch (CoreException ce) |
| { |
| // do nothing; fall through and return default |
| } |
| |
| return id; |
| } |
| |
| private class MyExternalContextFactoryLocator implements IExternalContextFactoryLocator |
| { |
| public AbstractDTExternalContextFactory getFactory() |
| { |
| ExtensionData<AbstractDTExternalContextFactory> extData = null; |
| |
| String id = getResolverId_OLD(PERSIST_PROPERTY_KEY_EXTERNAL_CONTEXT_PROVIDER); |
| if (id != null) |
| { |
| extData = JSFCorePlugin.getExternalContextProviders(id); |
| } |
| |
| if (extData == null) |
| { |
| extData = JSFCorePlugin.getExternalContextProviders(DEFAULT_EXTERNAL_CONTEXT_ID); |
| } |
| |
| return extData.getInstance(_project); |
| } |
| } |
| |
| private String getFromProjectSettings(final String key, final String defaultValue) |
| { |
| return _properties.getProperty(key, defaultValue); |
| } |
| |
| private void setProjectSetting(final String key, final String value) |
| { |
| _properties.setProperty(key, value); |
| storeProperties(_properties); |
| } |
| |
| private void storeProperties(final Properties properties) |
| { |
| IFile propFile; |
| try |
| { |
| propFile = getPropsFile(_project); |
| if (propFile != null) |
| { |
| final ByteArrayOutputStream outstream = |
| new ByteArrayOutputStream(); |
| properties.store(outstream, null); |
| propFile.setContents(new ByteArrayInputStream(outstream.toByteArray()) |
| , true, true, null); |
| } |
| } |
| catch (CoreException e) |
| { |
| JSFCorePlugin.log(e, "Problem storing properties"); |
| } |
| catch (IOException e) |
| { |
| JSFCorePlugin.log(e, "Problem storing properties"); |
| } |
| } |
| |
| private Properties loadProperties(final IProject project) |
| { |
| Properties props = new Properties(); |
| try |
| { |
| final IFile propFile = getPropsFile(project); |
| |
| if (propFile != null) |
| { |
| props.load(propFile.getContents()); |
| } |
| } |
| catch (CoreException ce) |
| { |
| JSFCorePlugin.log(ce, "Problem loading properties"); |
| } |
| catch (IOException ce) |
| { |
| JSFCorePlugin.log(ce, "Problem loading properties"); |
| } |
| |
| return props; |
| } |
| |
| private IFile getPropsFile(final IProject project) throws CoreException |
| { |
| IFolder folder = project.getFolder(new Path(".settings")); |
| if (!folder.exists()) |
| { |
| folder.create(false, true, null); |
| } |
| |
| final IFile file = folder.getFile( |
| new Path("org.eclipse.jst.jsf.designtime.appmgr.prefs")); |
| |
| if (!file.exists()) |
| { |
| file.create(new ByteArrayInputStream(new byte[0]), false, null); |
| } |
| |
| return file; |
| } |
| } |
