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.relations; import org.opencms.file.CmsObject; import org.opencms.file.CmsRequestContext; import org.opencms.file.CmsResource; import org.opencms.file.CmsResourceFilter; import org.opencms.file.CmsVfsResourceNotFoundException; import org.opencms.file.wrapper.CmsObjectWrapper; import org.opencms.main.CmsException; import org.opencms.main.CmsLog; import org.opencms.main.OpenCms; import org.opencms.staticexport.CmsLinkProcessor; import org.opencms.util.CmsRequestUtil; import org.opencms.util.CmsStringUtil; import org.opencms.util.CmsUUID; import org.opencms.util.CmsUriSplitter; import java.util.Map; import java.util.Set; import org.apache.commons.logging.Log; import org.dom4j.Attribute; import org.dom4j.Element; /** * A single link entry in the link table.<p> * * @since 6.0.0 */ public class CmsLink { /** Name of the internal attribute of the link node. */ public static final String ATTRIBUTE_INTERNAL = "internal"; /** Name of the name attribute of the elements node. */ public static final String ATTRIBUTE_NAME = "name"; /** Name of the type attribute of the elements node. */ public static final String ATTRIBUTE_TYPE = "type"; /** Default link name. */ public static final String DEFAULT_NAME = "ref"; /** Default link type. */ public static final CmsRelationType DEFAULT_TYPE = CmsRelationType.XML_WEAK; /** A dummy uri. */ public static final String DUMMY_URI = "@@@"; /** Name of the anchor node. */ public static final String NODE_ANCHOR = "anchor"; /** Name of the query node. */ public static final String NODE_QUERY = "query"; /** Name of the target node. */ public static final String NODE_TARGET = "target"; /** Name of the UUID node. */ public static final String NODE_UUID = "uuid"; /** Constant for the NULL link. */ public static final CmsLink NULL_LINK = new CmsLink(); /** The log object for this class. */ private static final Log LOG = CmsLog.getLog(CmsLink.class); /** The anchor of the URI, if any. */ private String m_anchor; /** The XML element reference. */ private Element m_element; /** Indicates if the link is an internal link within the OpenCms VFS. */ private boolean m_internal; /** The internal name of the link. */ private String m_name; /** The parameters of the query, if any. */ private Map<String, String[]> m_parameters; /** The query, if any. */ private String m_query; /** A variable for storing the resource which the link points to. */ private CmsResource m_resource; /** The site root of the (internal) link. */ private String m_siteRoot; /** The structure id of the linked resource. */ private CmsUUID m_structureId; /** The link target (destination). */ private String m_target; /** The type of the link. */ private CmsRelationType m_type; /** The raw uri. */ private String m_uri; /** * Reconstructs a link object from the given XML node.<p> * * @param element the XML node containing the link information */ public CmsLink(Element element) { m_element = element; Attribute attrName = element.attribute(ATTRIBUTE_NAME); if (attrName != null) { m_name = attrName.getValue(); } else { m_name = DEFAULT_NAME; } Attribute attrType = element.attribute(ATTRIBUTE_TYPE); if (attrType != null) { m_type = CmsRelationType.valueOfXml(attrType.getValue()); } else { m_type = DEFAULT_TYPE; } Attribute attrInternal = element.attribute(ATTRIBUTE_INTERNAL); if (attrInternal != null) { m_internal = Boolean.valueOf(attrInternal.getValue()).booleanValue(); } else { m_internal = true; } Element uuid = element.element(NODE_UUID); Element target = element.element(NODE_TARGET); Element anchor = element.element(NODE_ANCHOR); Element query = element.element(NODE_QUERY); m_structureId = (uuid != null) ? new CmsUUID(uuid.getText()) : null; m_target = (target != null) ? target.getText() : null; m_anchor = (anchor != null) ? anchor.getText() : null; setQuery((query != null) ? query.getText() : null); // update the uri from the components setUri(); } /** * Creates a new link object without a reference to the xml page link element.<p> * * @param name the internal name of this link * @param type the type of this link * @param structureId the structure id of the link * @param uri the link uri * @param internal indicates if the link is internal within OpenCms */ public CmsLink(String name, CmsRelationType type, CmsUUID structureId, String uri, boolean internal) { m_element = null; m_name = name; m_type = type; m_internal = internal; m_structureId = structureId; m_uri = uri; // update component members from the uri setComponents(); } /** * Creates a new link object without a reference to the xml page link element.<p> * * @param name the internal name of this link * @param type the type of this link * @param uri the link uri * @param internal indicates if the link is internal within OpenCms */ public CmsLink(String name, CmsRelationType type, String uri, boolean internal) { this(name, type, null, uri, internal); } /** * Empty constructor for NULL constant.<p> */ private CmsLink() { // empty constructor for NULL constant } /** * Checks and updates the structure id or the path of the target.<p> * * @param cms the cms context */ public void checkConsistency(CmsObject cms) { m_resource = null; if (!m_internal || (cms == null)) { return; } try { if (m_structureId == null) { // try by path throw new CmsException(Messages.get().container(Messages.LOG_BROKEN_LINK_NO_ID_0)); } // first look for the resource with the given structure id String rootPath = null; CmsResource res; try { res = cms.readResource(m_structureId, CmsResourceFilter.ALL); m_resource = res; rootPath = res.getRootPath(); if (!res.getRootPath().equals(m_target)) { // update path if needed if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key(Messages.LOG_BROKEN_LINK_UPDATED_BY_ID_3, m_structureId, m_target, res.getRootPath())); } } } catch (CmsException e) { // not found throw new CmsVfsResourceNotFoundException(org.opencms.db.generic.Messages.get() .container(org.opencms.db.generic.Messages.ERR_READ_RESOURCE_1, m_target)); } if ((rootPath != null) && !rootPath.equals(m_target)) { // set the new target m_target = res.getRootPath(); setUri(); // update xml node CmsLinkUpdateUtil.updateXml(this, m_element, true); } } catch (CmsException e) { if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key(Messages.LOG_BROKEN_LINK_BY_ID_2, m_target, m_structureId), e); } if (CmsStringUtil.isEmptyOrWhitespaceOnly(m_target)) { // no correction is possible return; } // go on with the resource with the given path String siteRoot = cms.getRequestContext().getSiteRoot(); try { cms.getRequestContext().setSiteRoot(""); // now look for the resource with the given path CmsResource res = cms.readResource(m_target, CmsResourceFilter.ALL); m_resource = res; if (!res.getStructureId().equals(m_structureId)) { // update structure id if needed if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key(Messages.LOG_BROKEN_LINK_UPDATED_BY_NAME_3, m_target, m_structureId, res.getStructureId())); } m_target = res.getRootPath(); // could change by a translation rule m_structureId = res.getStructureId(); CmsLinkUpdateUtil.updateXml(this, m_element, true); } } catch (CmsException e1) { // no correction was possible if (LOG.isDebugEnabled()) { LOG.debug(Messages.get().getBundle().key(Messages.LOG_BROKEN_LINK_BY_NAME_1, m_target), e1); } m_structureId = null; } finally { cms.getRequestContext().setSiteRoot(siteRoot); } } } /** * A link is considered equal if the link target and the link type is equal.<p> * * @see java.lang.Object#equals(java.lang.Object) */ @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (obj instanceof CmsLink) { CmsLink other = (CmsLink) obj; return (m_type == other.m_type) && CmsStringUtil.isEqual(m_target, other.m_target); } return false; } /** * Returns the anchor of this link.<p> * * @return the anchor or null if undefined */ public String getAnchor() { return m_anchor; } /** * Returns the xml node element representing this link object.<p> * * @return the xml node element representing this link object */ public Element getElement() { return m_element; } /** * Returns the processed link.<p> * * @param cms the current OpenCms user context, can be <code>null</code> * * @return the processed link */ public String getLink(CmsObject cms) { if (m_internal) { // if we have a local link, leave it unchanged // cms may be null for unit tests if ((cms == null) || (m_uri.length() == 0) || (m_uri.charAt(0) == '#')) { return m_uri; } checkConsistency(cms); //String target = replaceTargetWithDetailPageIfNecessary(cms, m_resource, m_target); String target = m_target; String uri = computeUri(target, m_query, m_anchor); CmsObjectWrapper wrapper = (CmsObjectWrapper) cms.getRequestContext() .getAttribute(CmsObjectWrapper.ATTRIBUTE_NAME); if (wrapper != null) { // if an object wrapper is used, rewrite the URI m_uri = wrapper.rewriteLink(m_uri); uri = wrapper.rewriteLink(uri); } if ((cms.getRequestContext().getSiteRoot().length() == 0) && (cms.getRequestContext().getAttribute(CmsRequestContext.ATTRIBUTE_EDITOR) == null)) { // Explanation why this check is required: // If the site root name length is 0, this means that a user has switched // the site root to the root site "/" in the Workplace. // In this case the workplace site must also be the active site. // If the editor is opened in the root site, because of this code the links are // always generated _with_ server name / port so that the source code looks identical to code // that would normally be created when running in a regular site. // If normal link processing would be used, the site information in the link // would be lost. return OpenCms.getLinkManager().substituteLink(cms, uri); } // get the site root for this URI / link // if there is no site root, we either have a /system link, or the site was deleted, // return the full URI prefixed with the opencms context String siteRoot = getSiteRoot(); if (siteRoot == null) { return OpenCms.getLinkManager().substituteLink(cms, uri); } if (cms.getRequestContext().getAttribute(CmsRequestContext.ATTRIBUTE_FULLLINKS) != null) { // full links should be generated even if we are in the same site return OpenCms.getLinkManager().getServerLink(cms, uri); } // return the link with the server prefix, if necessary return OpenCms.getLinkManager().substituteLink(cms, getSitePath(uri), siteRoot); } else { // don't touch external links return m_uri; } } /** * Returns the processed link.<p> * * @param cms the current OpenCms user context, can be <code>null</code> * @param processEditorLinks this parameter is not longer used * * @return the processed link * * @deprecated use {@link #getLink(CmsObject)} instead, * the process editor option is set using the OpenCms request context attributes */ @Deprecated public String getLink(CmsObject cms, boolean processEditorLinks) { return getLink(cms); } /** * Returns the macro name of this link.<p> * * @return the macro name name of this link */ public String getName() { return m_name; } /** * Returns the first parameter value for the given parameter name.<p> * * @param name the name of the parameter * @return the first value for this name or <code>null</code> */ public String getParameter(String name) { String[] p = getParameterMap().get(name); if (p != null) { return p[0]; } return null; } /** * Returns the map of parameters of this link.<p> * * @return the map of parameters */ public Map<String, String[]> getParameterMap() { if (m_parameters == null) { m_parameters = CmsRequestUtil.createParameterMap(m_query); } return m_parameters; } /** * Returns the set of available parameter names for this link.<p> * * @return the parameter names */ public Set<String> getParameterNames() { return getParameterMap().keySet(); } /** * Returns all parameter values for the given name.<p> * * @param name the name of the parameter * * @return all parameter values or <code>null</code> */ public String[] getParameterValues(String name) { return getParameterMap().get(name); } /** * Returns the query of this link.<p> * * @return the query or null if undefined */ public String getQuery() { return m_query; } /** * Returns the vfs link of the target if it is internal.<p> * * @return the full link destination or null if the link is not internal */ public String getSitePath() { return getSitePath(m_uri); } /** * Return the site root if the target of this link is internal, or <code>null</code> otherwise.<p> * * @return the site root if the target of this link is internal, or <code>null</code> otherwise */ public String getSiteRoot() { if (m_internal && (m_siteRoot == null)) { m_siteRoot = OpenCms.getSiteManager().getSiteRoot(m_target); if (m_siteRoot == null) { m_siteRoot = ""; } } return m_siteRoot; } /** * The structure id of the linked resource.<p> * * @return structure id of the linked resource */ public CmsUUID getStructureId() { return m_structureId; } /** * Returns the target (destination) of this link.<p> * * @return the target the target (destination) of this link */ public String getTarget() { return m_target; } /** * Returns the type of this link.<p> * * @return the type of this link */ public CmsRelationType getType() { return m_type; } /** * Returns the raw uri of this link.<p> * * @return the uri */ public String getUri() { return m_uri; } /** * Returns the vfs link of the target if it is internal.<p> * * @return the full link destination or null if the link is not internal * * @deprecated Use {@link #getSitePath()} instead */ @Deprecated public String getVfsUri() { return getSitePath(); } /** * @see java.lang.Object#hashCode() */ @Override public int hashCode() { int result = m_type.hashCode(); if (m_target != null) { result += m_target.hashCode(); } return result; } /** * Returns if the link is internal.<p> * * @return true if the link is a local link */ public boolean isInternal() { return m_internal; } /** * @see java.lang.Object#toString() */ @Override public String toString() { return m_uri; } /** * Updates the uri of this link with a new value.<p> * * Also updates the structure of the underlying XML page document this link belongs to.<p> * * Note that you can <b>not</b> update the "internal" or "type" values of the link, * so the new link must be of same type (A, IMG) and also remain either an internal or external link.<p> * * @param uri the uri to update this link with <code>scheme://authority/path#anchor?query</code> */ public void updateLink(String uri) { // set the uri m_uri = uri; // update the components setComponents(); // update the xml CmsLinkUpdateUtil.updateXml(this, m_element, true); } /** * Updates the uri of this link with a new target, anchor and query.<p> * * If anchor and/or query are <code>null</code>, this features are not used.<p> * * Note that you can <b>not</b> update the "internal" or "type" values of the link, * so the new link must be of same type (A, IMG) and also remain either an internal or external link.<p> * * Also updates the structure of the underlying XML page document this link belongs to.<p> * * @param target the target (destination) of this link * @param anchor the anchor or null if undefined * @param query the query or null if undefined */ public void updateLink(String target, String anchor, String query) { // set the components m_target = target; m_anchor = anchor; setQuery(query); // create the uri from the components setUri(); // update the xml CmsLinkUpdateUtil.updateXml(this, m_element, true); } /** * Helper method for getting the site path for a uri.<p> * * @param uri a VFS uri * @return the site path */ protected String getSitePath(String uri) { if (m_internal) { String siteRoot = getSiteRoot(); if (siteRoot != null) { return uri.substring(siteRoot.length()); } else { return uri; } } return null; } /** * Helper method for creating a uri from its components.<p> * * @param target the uri target * @param query the uri query component * @param anchor the uri anchor component * * @return the uri */ private String computeUri(String target, String query, String anchor) { StringBuffer uri = new StringBuffer(64); uri.append(target); if (query != null) { uri.append('?'); uri.append(query); } if (anchor != null) { uri.append('#'); uri.append(anchor); } return uri.toString(); } /** * Sets the component member variables (target, anchor, query) * by splitting the uri <code>scheme://authority/path#anchor?query</code>.<p> */ private void setComponents() { CmsUriSplitter splitter = new CmsUriSplitter(m_uri, true); m_target = splitter.getPrefix(); m_anchor = CmsLinkProcessor.unescapeLink(splitter.getAnchor()); setQuery(splitter.getQuery()); } /** * Sets the query of the link.<p> * * @param query the query to set. */ private void setQuery(String query) { m_query = CmsLinkProcessor.unescapeLink(query); m_parameters = null; } /** * Joins the internal target, anchor and query components * to one uri string, setting the internal uri and parameters fields.<p> */ private void setUri() { m_uri = computeUri(m_target, m_query, m_anchor); } }