Java tutorial
/* * This library is part of OpenCms - * the Open Source Content Management System * * Copyright (c) Alkacon Software GmbH (http://www.alkacon.com) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * For further information about Alkacon Software GmbH, please see the * company website: http://www.alkacon.com * * For further information about OpenCms, please see the * project website: http://www.opencms.org * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package org.opencms.workplace.editors; import org.opencms.main.CmsLog; import org.opencms.util.CmsStringUtil; import org.opencms.xml.CmsXmlException; import org.opencms.xml.CmsXmlUtils; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; import org.apache.commons.logging.Log; import org.dom4j.Document; import org.dom4j.Element; /** * Single editor configuration object.<p> * * Holds all necessary information about an OpenCms editor which is stored in the * "editor_configuration.xml" file in each editor folder.<p> * * Provides methods to get the editor information for the editor manager.<p> * * @since 6.0.0 */ public class CmsWorkplaceEditorConfiguration { /** Name of the root document node. */ public static final String DOCUMENT_NODE = "editor"; /** Name of the single user agent node. */ protected static final String N_AGENT = "agent"; /** Name of the resource type class node. */ protected static final String N_CLASS = "class"; /** Name of the editor label node. */ protected static final String N_LABEL = "label"; /** Name of the resource type subnode mapto. */ protected static final String N_MAPTO = "mapto"; /** Name of the resource type subnode name. */ protected static final String N_NAME = "name"; /** Name of the resource type subnode ranking. */ protected static final String N_RANKING = "ranking"; /** Name of the resourcetypes node. */ protected static final String N_RESOURCETYPES = "resourcetypes"; /** Name of the resource type node. */ protected static final String N_TYPE = "type"; /** Name of the useragents node. */ protected static final String N_USERAGENTS = "useragents"; /** Name of the widgeteditor node. */ protected static final String N_WIDGETEDITOR = "widgeteditor"; /** The log object for this class. */ private static final Log LOG = CmsLog.getLog(CmsWorkplaceEditorConfiguration.class); private List m_browserPattern; private String m_editorLabel; private String m_editorUri; private Map m_resTypes; private List m_userAgentsRegEx; private boolean m_validConfiguration; private String m_widgetEditor; /** * Constructor with xml data String.<p> * * @param xmlData the XML data String containing the information about the editor * @param editorUri the editor workplace URI */ public CmsWorkplaceEditorConfiguration(byte[] xmlData, String editorUri) { setValidConfiguration(true); try { initialize(CmsXmlUtils.unmarshalHelper(xmlData, null), editorUri); } catch (CmsXmlException e) { // xml String could not be parsed logConfigurationError(Messages.get().getBundle().key(Messages.ERR_XML_PARSE_0), e); } } /** * Returns the list of compiled browser patterns.<p> * * @return the list of compiled browser patterns */ public List getBrowserPattern() { return m_browserPattern; } /** * Returns the editor label key used for the localized nice name.<p> * * @return the editor label key used for the localized nice name */ public String getEditorLabel() { return m_editorLabel; } /** * Returns the editor workplace URI.<p> * * @return the editor workplace URI */ public String getEditorUri() { return m_editorUri; } /** * Returns the mapping for the given resource type.<p> * * @param resourceType the resource type name to check * @return the mapping or null, if no mapping is specified */ public String getMappingForResourceType(String resourceType) { String[] resourceTypeParams = (String[]) getResourceTypes().get(resourceType); if (resourceTypeParams == null) { return null; } else { return resourceTypeParams[1]; } } /** * Returns the ranking value for the given resource type.<p> * * @param resourceType the current resource type * @return the ranking (the higher the better) */ public float getRankingForResourceType(String resourceType) { String[] resourceTypeParams = (String[]) getResourceTypes().get(resourceType); if (resourceTypeParams == null) { return -1.0f; } else { return Float.parseFloat(resourceTypeParams[0]); } } /** * Returns the valid resource types of the editor.<p> * * A single map item has the resource type name as key, * the value is a String array with two entries: * <ul> * <li>Entry 0: the ranking for the resource type</li> * <li>Entry 1: the mapping to another resource type or null</li> * </ul><p> * * @return the valid resource types of the editor */ public Map getResourceTypes() { return m_resTypes; } /** * Returns the valid user agents regular expressions of the editor.<p> * * @return the valid user agents regular expressions of the editor */ public List getUserAgentsRegEx() { return m_userAgentsRegEx; } /** * Returns the widget editor class for rich text editing.<p> * * @return the widget editor class for rich text editing */ public String getWidgetEditor() { return m_widgetEditor; } /** * Returns if the current configuration is valid.<p> * * @return true if no configuration errors were found, otherwise false */ public boolean isValidConfiguration() { return m_validConfiguration; } /** * Returns if the editor is usable as a widget editor for rich text editing.<p> * * @return true if the editor is usable as a widget editor for rich text editing, otherwise false */ public boolean isWidgetEditor() { return CmsStringUtil.isNotEmpty(m_widgetEditor); } /** * Tests if the current browser is matching the configuration.<p> * * @param currentBrowser the users browser String to test * @return true if the browser matches the configuration, otherwise false */ public boolean matchesBrowser(String currentBrowser) { if (currentBrowser == null) { return false; } for (int i = 0; i < getBrowserPattern().size(); i++) { boolean matches = ((Pattern) getBrowserPattern().get(i)).matcher(currentBrowser.trim()).matches(); if (matches) { if (LOG.isDebugEnabled()) { LOG.debug( Messages.get().getBundle().key(Messages.LOG_BROWSER_MATCHES_CONFIG_1, currentBrowser)); } return true; } } return false; } /** * Returns if the configuration is suitable for the given resource type.<p> * * @param resourceType the resource type to check * @return true if the configuration matches the resource type */ public boolean matchesResourceType(String resourceType) { return m_resTypes.containsKey(resourceType); } /** * Initializes all member variables.<p> * * @param document the XML configuration document * @param editorUri the editor workplace URI */ private void initialize(Document document, String editorUri) { // get the root element of the configuration Element rootElement = document.getRootElement(); // set the label of the editor setEditorLabel(rootElement.elementText(N_LABEL)); // set the widget editor class if available String widgetClass = rootElement.elementText(N_WIDGETEDITOR); if (CmsStringUtil.isNotEmpty(widgetClass)) { setWidgetEditor(widgetClass); } // set the URI of the editor setEditorUri(editorUri); // create the map of valid resource types Iterator i = rootElement.element(N_RESOURCETYPES).elementIterator(N_TYPE); Map resTypes = new HashMap(); while (i.hasNext()) { Element currentType = (Element) i.next(); float ranking; String name = currentType.elementText(N_NAME); if (CmsStringUtil.isEmpty(name)) { logConfigurationError(Messages.get().getBundle().key(Messages.ERR_INVALID_RESTYPE_NAME_0), null); continue; } try { ranking = Float.parseFloat(currentType.elementText(N_RANKING)); } catch (Throwable t) { logConfigurationError(Messages.get().getBundle().key(Messages.ERR_INVALID_RESTYPE_RANKING_1, name), t); continue; } String mapTo = currentType.elementText(N_MAPTO); if (CmsStringUtil.isEmpty(mapTo)) { mapTo = null; } resTypes.put(name, new String[] { "" + ranking, mapTo }); } // add the additional resource types i = rootElement.element(N_RESOURCETYPES).elementIterator(N_CLASS); while (i.hasNext()) { Element currentClass = (Element) i.next(); String name = currentClass.elementText(N_NAME); List assignedTypes = new ArrayList(); try { // get the editor type matcher class I_CmsEditorTypeMatcher matcher = (I_CmsEditorTypeMatcher) Class.forName(name).newInstance(); assignedTypes = matcher.getAdditionalResourceTypes(); } catch (Throwable t) { logConfigurationError(Messages.get().getBundle().key(Messages.ERR_INVALID_RESTYPE_CLASS_1, name), t); continue; } float ranking; try { ranking = Float.parseFloat(currentClass.elementText(N_RANKING)); } catch (Throwable t) { logConfigurationError(Messages.get().getBundle().key(Messages.ERR_INVALID_RESTYPE_RANKING_1, name), t); continue; } String mapTo = currentClass.elementText(N_MAPTO); if ("".equals(mapTo)) { mapTo = null; } // now loop through all types found and add them Iterator j = assignedTypes.iterator(); while (j.hasNext()) { String typeName = (String) j.next(); resTypes.put(typeName, new String[] { "" + ranking, mapTo }); } } setResourceTypes(resTypes); // create the list of user agents & compiled patterns for editor i = document.getRootElement().element(N_USERAGENTS).elementIterator(N_AGENT); List pattern = new ArrayList(); List userAgents = new ArrayList(); while (i.hasNext()) { Element currentAgent = (Element) i.next(); String agentName = currentAgent.getText(); if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(agentName)) { userAgents.add(agentName); try { pattern.add(Pattern.compile(agentName)); } catch (PatternSyntaxException e) { logConfigurationError( Messages.get().getBundle().key(Messages.ERR_COMPILE_EDITOR_REGEX_1, agentName), e); } } else { logConfigurationError(Messages.get().getBundle().key(Messages.ERR_INVALID_USERAGENT_DEF_0), null); } } setBrowserPattern(pattern); setUserAgentsRegEx(userAgents); } /** * Logs configuration errors and invalidates the current configuration.<p> * * @param message the message specifying the configuration error * @param t the Throwable object or null */ private void logConfigurationError(String message, Throwable t) { setValidConfiguration(false); if (LOG.isErrorEnabled()) { if (t == null) { LOG.error(Messages.get().getBundle().key(Messages.LOG_EDITOR_CONFIG_ERROR_1, message)); } else { LOG.error(Messages.get().getBundle().key(Messages.LOG_EDITOR_CONFIG_ERROR_1, message), t); } } } /** * Sets the list of compiled browser patterns.<p> * * @param pattern the list of compiled browser patterns */ private void setBrowserPattern(List pattern) { if ((pattern == null) || (pattern.size() == 0)) { setValidConfiguration(false); LOG.error(Messages.get().getBundle().key(Messages.LOG_EDITOR_CONFIG_NO_PATTERN_0)); } m_browserPattern = pattern; } /** * Sets the editor label key used for the localized nice name.<p> * * @param label the editor label key used for the localized nice name */ private void setEditorLabel(String label) { if (CmsStringUtil.isEmptyOrWhitespaceOnly(label)) { setValidConfiguration(false); LOG.error(Messages.get().getBundle().key(Messages.LOG_EDITOR_CONFIG_NO_LABEL_0)); } m_editorLabel = label; } /** * Sets the editor workplace URI.<p> * @param uri the editor workplace URI */ private void setEditorUri(String uri) { if (CmsStringUtil.isEmptyOrWhitespaceOnly(uri)) { setValidConfiguration(false); LOG.error(Messages.get().getBundle().key(Messages.LOG_EDITOR_CONFIG_NO_URI_0)); } m_editorUri = uri; } /** * Sets the valid resource types of the editor.<p> * * @param types the valid resource types of the editor */ private void setResourceTypes(Map types) { if ((types == null) || (types.size() == 0)) { setValidConfiguration(false); LOG.error(Messages.get().getBundle().key(Messages.LOG_NO_RESOURCE_TYPES_0)); } m_resTypes = types; } /** * Sets the valid user agents regular expressions of the editor.<p> * * @param agents the valid user agents regular expressions of the editor */ private void setUserAgentsRegEx(List agents) { if ((agents == null) || (agents.size() == 0)) { setValidConfiguration(false); LOG.error(Messages.get().getBundle().key(Messages.LOG_NO_USER_AGENTS_0)); } m_userAgentsRegEx = agents; } /** * Sets if the current configuration is valid.<p> * * @param isValid true if no configuration errors were found, otherwise false */ private void setValidConfiguration(boolean isValid) { m_validConfiguration = isValid; } /** * Sets the widget editor class for rich text editing.<p> * * @param widgetEditor the widget editor class for rich text editing */ private void setWidgetEditor(String widgetEditor) { m_widgetEditor = widgetEditor; } }