Java tutorial
/** * This file Copyright (c) 2011-2012 Magnolia International * Ltd. (http://www.magnolia-cms.com). All rights reserved. * * * This file is dual-licensed under both the Magnolia * Network Agreement and the GNU General Public License. * You may elect to use one or the other of these licenses. * * This file is distributed in the hope that it will be * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the * implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT. * Redistribution, except as permitted by whichever of the GPL * or MNA you select, is prohibited. * * 1. For the GPL license (GPL), you can redistribute and/or * modify this file under the terms of the GNU General * Public License, Version 3, as published by the Free Software * Foundation. You should have received a copy of the GNU * General Public License, Version 3 along with this program; * if not, write to the Free Software Foundation, Inc., 51 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * 2. For the Magnolia Network Agreement (MNA), this file * and the accompanying materials are made available under the * terms of the MNA which accompanies this distribution, and * is available at http://www.magnolia-cms.com/mna.html * * Any modifications to this file must keep this entire header * intact. * */ package info.magnolia.templating.functions; import info.magnolia.cms.beans.config.ServerConfiguration; import info.magnolia.cms.core.AggregationState; import info.magnolia.cms.core.NodeData; import info.magnolia.cms.i18n.I18nContentSupportFactory; import info.magnolia.cms.util.ContentUtil; import info.magnolia.cms.util.QueryUtil; import info.magnolia.cms.util.SiblingsHelper; import info.magnolia.jcr.inheritance.InheritanceNodeWrapper; import info.magnolia.jcr.util.ContentMap; import info.magnolia.jcr.util.MetaDataUtil; import info.magnolia.jcr.util.NodeTypes; import info.magnolia.jcr.util.NodeUtil; import info.magnolia.jcr.util.PropertyUtil; import info.magnolia.jcr.util.SessionUtil; import info.magnolia.jcr.wrapper.HTMLEscapingNodeWrapper; import info.magnolia.link.LinkUtil; import info.magnolia.objectfactory.Components; import info.magnolia.rendering.template.configured.ConfiguredInheritance; import info.magnolia.repository.RepositoryConstants; import info.magnolia.templating.inheritance.DefaultInheritanceContentDecorator; import java.util.ArrayList; import java.util.Calendar; import java.util.Collection; import java.util.List; import javax.inject.Inject; import javax.inject.Provider; import javax.jcr.Node; import javax.jcr.PathNotFoundException; import javax.jcr.Property; import javax.jcr.PropertyType; import javax.jcr.RepositoryException; import org.apache.commons.lang.StringUtils; import org.apache.jackrabbit.util.ISO8601; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * An object exposing several methods useful for templates. It is exposed in templates as <code>cmsfn</code>. * * @version $Id$ */ public class TemplatingFunctions { private static final Logger log = LoggerFactory.getLogger(TemplatingFunctions.class); private final Provider<AggregationState> aggregationStateProvider; //TODO: To review with Philipp. Should not use Provider, but has deep impact on CategorizationSupportImpl PageSyndicator CategorySyndicator.... @Inject public TemplatingFunctions(Provider<AggregationState> aggregationStateProvider) { this.aggregationStateProvider = aggregationStateProvider; } public Node asJCRNode(ContentMap contentMap) { return contentMap == null ? null : contentMap.getJCRNode(); } public ContentMap asContentMap(Node content) { return content == null ? null : new ContentMap(content); } public List<Node> children(Node content) throws RepositoryException { return content == null ? null : asNodeList(NodeUtil.getNodes(content, NodeUtil.EXCLUDE_META_DATA_FILTER)); } public List<Node> children(Node content, String nodeTypeName) throws RepositoryException { return content == null ? null : asNodeList(NodeUtil.getNodes(content, nodeTypeName)); } public List<ContentMap> children(ContentMap content) throws RepositoryException { return content == null ? null : asContentMapList(NodeUtil.getNodes(asJCRNode(content), NodeUtil.EXCLUDE_META_DATA_FILTER)); } public List<ContentMap> children(ContentMap content, String nodeTypeName) throws RepositoryException { return content == null ? null : asContentMapList(NodeUtil.getNodes(asJCRNode(content), nodeTypeName)); } public ContentMap root(ContentMap contentMap) throws RepositoryException { return contentMap == null ? null : asContentMap(this.root(contentMap.getJCRNode())); } public ContentMap root(ContentMap contentMap, String nodeTypeName) throws RepositoryException { return contentMap == null ? null : asContentMap(this.root(contentMap.getJCRNode(), nodeTypeName)); } public Node root(Node content) throws RepositoryException { return this.root(content, null); } public Node root(Node content, String nodeTypeName) throws RepositoryException { if (content == null) { return null; } if (nodeTypeName == null) { return (Node) content.getAncestor(0); } if (isRoot(content) && content.isNodeType(nodeTypeName)) { return content; } Node parentNode = this.parent(content, nodeTypeName); while (parent(parentNode, nodeTypeName) != null) { parentNode = this.parent(parentNode, nodeTypeName); } return parentNode; } public ContentMap parent(ContentMap contentMap) throws RepositoryException { return contentMap == null ? null : asContentMap(this.parent(contentMap.getJCRNode())); } public ContentMap parent(ContentMap contentMap, String nodeTypeName) throws RepositoryException { return contentMap == null ? null : asContentMap(this.parent(contentMap.getJCRNode(), nodeTypeName)); } public Node parent(Node content) throws RepositoryException { return this.parent(content, null); } public Node parent(Node content, String nodeTypeName) throws RepositoryException { if (content == null) { return null; } if (isRoot(content)) { return null; } if (nodeTypeName == null) { return content.getParent(); } Node parent = content.getParent(); while (!parent.isNodeType(nodeTypeName)) { if (isRoot(parent)) { return null; } parent = parent.getParent(); } return parent; } /** * Returns the page's {@link ContentMap} of the passed {@link ContentMap}. If the passed {@link ContentMap} represents a page, the passed {@link ContentMap} will be returned. * If the passed {@link ContentMap} has no parent page at all, null is returned. * * @param content the {@link ContentMap} to get the page's {@link ContentMap} from. * @return returns the page {@link ContentMap} of the passed content {@link ContentMap}. * @throws RepositoryException */ public ContentMap page(ContentMap content) throws RepositoryException { return content == null ? null : asContentMap(page(content.getJCRNode())); } /** * Returns the page {@link Node} of the passed node. If the passed {@link Node} is a page, the passed {@link Node} will be returned. * If the passed Node has no parent page at all, null is returned. * * @param content the {@link Node} to get the page from. * @return returns the page {@link Node} of the passed content {@link Node}. * @throws RepositoryException */ public Node page(Node content) throws RepositoryException { if (content == null) { return null; } if (content.isNodeType(NodeTypes.Page.NAME)) { return content; } return parent(content, NodeTypes.Page.NAME); } public List<ContentMap> ancestors(ContentMap contentMap) throws RepositoryException { return ancestors(contentMap, null); } public List<ContentMap> ancestors(ContentMap contentMap, String nodeTypeName) throws RepositoryException { List<Node> ancestorsAsNodes = this.ancestors(contentMap.getJCRNode(), nodeTypeName); return asContentMapList(ancestorsAsNodes); } public List<Node> ancestors(Node content) throws RepositoryException { return content == null ? null : this.ancestors(content, null); } public List<Node> ancestors(Node content, String nodeTypeName) throws RepositoryException { if (content == null) { return null; } List<Node> ancestors = new ArrayList<Node>(); int depth = content.getDepth(); for (int i = 1; i < depth; ++i) { Node possibleAncestor = (Node) content.getAncestor(i); if (nodeTypeName == null) { ancestors.add(possibleAncestor); } else { if (possibleAncestor.isNodeType(nodeTypeName)) { ancestors.add(possibleAncestor); } } } return ancestors; } public Node inherit(Node content) throws RepositoryException { return inherit(content, null); } public Node inherit(Node content, String relPath) throws RepositoryException { if (content == null) { return null; } Node inheritedNode = wrapForInheritance(content); if (StringUtils.isBlank(relPath)) { return inheritedNode; } try { Node subNode = inheritedNode.getNode(relPath); return NodeUtil.unwrap(subNode); } catch (PathNotFoundException e) { // TODO fgrilli: rethrow exception? } return null; } public ContentMap inherit(ContentMap content) throws RepositoryException { return inherit(content, null); } public ContentMap inherit(ContentMap content, String relPath) throws RepositoryException { if (content == null) { return null; } Node node = inherit(content.getJCRNode(), relPath); return node == null ? null : new ContentMap(node); } public Property inheritProperty(Node content, String relPath) throws RepositoryException { if (content == null) { return null; } if (StringUtils.isBlank(relPath)) { throw new IllegalArgumentException("relative path cannot be null or empty"); } try { Node inheritedNode = wrapForInheritance(content); return inheritedNode.getProperty(relPath); } catch (PathNotFoundException e) { // TODO fgrilli: rethrow exception? } catch (RepositoryException e) { // TODO fgrilli:rethrow exception? } return null; } public Property inheritProperty(ContentMap content, String relPath) throws RepositoryException { if (content == null) { return null; } return inheritProperty(content.getJCRNode(), relPath); } public List<Node> inheritList(Node content, String relPath) throws RepositoryException { if (content == null) { return null; } if (StringUtils.isBlank(relPath)) { throw new IllegalArgumentException("relative path cannot be null or empty"); } Node inheritedNode = wrapForInheritance(content); Node subNode = inheritedNode.getNode(relPath); return children(subNode); } public List<ContentMap> inheritList(ContentMap content, String relPath) throws RepositoryException { if (content == null) { return null; } if (StringUtils.isBlank(relPath)) { throw new IllegalArgumentException("relative path cannot be null or empty"); } Node node = asJCRNode(content); Node inheritedNode = wrapForInheritance(node); Node subNode = inheritedNode.getNode(relPath); return children(new ContentMap(subNode)); } public boolean isInherited(Node content) { if (content instanceof InheritanceNodeWrapper) { return ((InheritanceNodeWrapper) content).isInherited(); } return false; } public boolean isInherited(ContentMap content) { return isInherited(asJCRNode(content)); } public boolean isFromCurrentPage(Node content) { return !isInherited(content); } public boolean isFromCurrentPage(ContentMap content) { return isFromCurrentPage(asJCRNode(content)); } /** * Create link for the Node identified by nodeIdentifier in the specified workspace. */ public String link(String workspace, String nodeIdentifier) { try { return LinkUtil.createLink(workspace, nodeIdentifier); } catch (RepositoryException e) { return null; } } /** * There should be no real reason to use this method except to produce link to binary content stored in jcr:data property in which case one should call {@link #link(Node)} while passing parent node as a parameter. In case you find other valid reason to use this method, please raise it in a forum discussion or create issue. Otherwise this method will be removed in the future. * * @deprecated since 4.5.4. There is no valid use case for this method. */ @Deprecated public String link(Property property) { try { Node parentNode = null; String propertyName = null; if (property.getType() == PropertyType.BINARY) { parentNode = property.getParent().getParent(); propertyName = property.getParent().getName(); } else { parentNode = property.getParent(); propertyName = property.getName(); } NodeData equivNodeData = ContentUtil.asContent(parentNode).getNodeData(propertyName); return LinkUtil.createLink(equivNodeData); } catch (Exception e) { return null; } } public String link(Node content) { return content == null ? null : LinkUtil.createLink(content); } public String link(ContentMap contentMap) throws RepositoryException { return contentMap == null ? null : this.link(asJCRNode(contentMap)); } /** * Get the language used currently. * @return The language as a String. */ public String language() { return I18nContentSupportFactory.getI18nSupport().getLocale().toString(); } /** * Returns an external link prepended with <code>http://</code> in case the protocol is missing or an empty String * if the link does not exist. * * @param content The node where the link property is stored on. * @param linkPropertyName The property where the link value is stored in. * @return The link prepended with <code>http://</code> */ public String externalLink(Node content, String linkPropertyName) { String externalLink = PropertyUtil.getString(content, linkPropertyName); if (StringUtils.isBlank(externalLink)) { return StringUtils.EMPTY; } if (!hasProtocol(externalLink)) { externalLink = "http://" + externalLink; } return externalLink; } /** * Returns an external link prepended with <code>http://</code> in case the protocol is missing or an empty String * if the link does not exist. * * @param content The node's map representation where the link property is stored on. * @param linkPropertyName The property where the link value is stored in. * @return The link prepended with <code>http://</code> */ public String externalLink(ContentMap content, String linkPropertyName) { return externalLink(asJCRNode(content), linkPropertyName); } /** * Return a link title based on the @param linkTitlePropertyName. When property @param linkTitlePropertyName is * empty or null, the link itself is provided as the linkTitle (prepended with <code>http://</code>). * * @param content The node where the link property is stored on. * @param linkPropertyName The property where the link value is stored in. * @param linkTitlePropertyName The property where the link title value is stored * @return the resolved link title value */ public String externalLinkTitle(Node content, String linkPropertyName, String linkTitlePropertyName) { String linkTitle = PropertyUtil.getString(content, linkTitlePropertyName); if (StringUtils.isNotEmpty(linkTitle)) { return linkTitle; } return externalLink(content, linkPropertyName); } /** * Return a link title based on the @param linkTitlePropertyName. When property @param linkTitlePropertyName is * empty or null, the link itself is provided as the linkTitle (prepended with <code>http://</code>). * * @param content The node where the link property is stored on. * @param linkPropertyName The property where the link value is stored in. * @param linkTitlePropertyName The property where the link title value is stored * @return the resolved link title value */ public String externalLinkTitle(ContentMap content, String linkPropertyName, String linkTitlePropertyName) { return externalLinkTitle(asJCRNode(content), linkPropertyName, linkTitlePropertyName); } public boolean isEditMode() { // TODO : see CmsFunctions.isEditMode, which checks a couple of other properties. return isAuthorInstance() && !isPreviewMode(); } public boolean isPreviewMode() { return this.aggregationStateProvider.get().isPreviewMode(); } public boolean isAuthorInstance() { return Components.getComponent(ServerConfiguration.class).isAdmin(); } public boolean isPublicInstance() { return !isAuthorInstance(); } /** * Util method to create html attributes <code>name="value"</code>. If the value is empty an empty string will be returned. * This is mainly helpful to avoid empty attributes. */ public String createHtmlAttribute(String name, String value) { value = StringUtils.trim(value); if (StringUtils.isNotEmpty(value)) { return new StringBuffer().append(name).append("=\"").append(value).append("\"").toString(); } return StringUtils.EMPTY; } /** * Returns an instance of SiblingsHelper for the given node. */ public SiblingsHelper siblings(Node node) throws RepositoryException { return SiblingsHelper.of(ContentUtil.asContent(node)); } public SiblingsHelper siblings(ContentMap node) throws RepositoryException { return siblings(asJCRNode(node)); } /** * Return the Node for the Given Path * from the website repository. */ public Node content(String path) { return content(RepositoryConstants.WEBSITE, path); } /** * Return the Node for the Given Path * from the given repository. */ public Node content(String repository, String path) { return SessionUtil.getNode(repository, path); } /** * Return the Node by the given identifier * from the website repository. */ public Node contentByIdentifier(String id) { return contentByIdentifier(RepositoryConstants.WEBSITE, id); } /** * Return the Node by the given identifier * from the given repository. */ public Node contentByIdentifier(String repository, String id) { return SessionUtil.getNodeByIdentifier(repository, id); } public List<ContentMap> asContentMapList(Collection<Node> nodeList) { if (nodeList != null) { List<ContentMap> contentMapList = new ArrayList<ContentMap>(); for (Node node : nodeList) { contentMapList.add(asContentMap(node)); } return contentMapList; } return null; } public List<Node> asNodeList(Collection<ContentMap> contentMapList) { if (contentMapList != null) { List<Node> nodeList = new ArrayList<Node>(); for (ContentMap node : contentMapList) { nodeList.add(node.getJCRNode()); } return nodeList; } return null; } // TODO fgrilli: should we unwrap children? protected List<Node> asNodeList(Iterable<Node> nodes) { List<Node> childList = new ArrayList<Node>(); for (Node child : nodes) { childList.add(child); } return childList; } // TODO fgrilli: should we unwrap children? protected List<ContentMap> asContentMapList(Iterable<Node> nodes) { List<ContentMap> childList = new ArrayList<ContentMap>(); for (Node child : nodes) { childList.add(new ContentMap(child)); } return childList; } /** * Checks if passed string has a <code>http://</code> protocol. * * @param link The link to check * @return If @param link contains a <code>http://</code> protocol */ private boolean hasProtocol(String link) { return link != null && link.contains("://"); } /** * Checks if the passed {@link Node} is the jcr root '/' of the workspace. * @param content {@link Node} to check if its root. * @return if @param content is the jcr workspace root. * @throws RepositoryException */ private boolean isRoot(Node content) throws RepositoryException { return content.getDepth() == 0; } /** * Removes escaping of HTML on properties. */ public ContentMap decode(ContentMap content) { return asContentMap(decode(content.getJCRNode())); } /** * Removes escaping of HTML on properties. */ public Node decode(Node content) { return NodeUtil.deepUnwrap(content, HTMLEscapingNodeWrapper.class); } /** * Adds escaping of HTML on properties as well as changing line breaks into <br/> tags. */ public Node encode(Node content) { return content != null ? new HTMLEscapingNodeWrapper(content, true) : null; } private Node wrapForInheritance(Node destination) throws RepositoryException { ConfiguredInheritance inheritanceConfiguration = new ConfiguredInheritance(); inheritanceConfiguration.setEnabled(true); return new DefaultInheritanceContentDecorator(destination, inheritanceConfiguration).wrapNode(destination); } /** * Returns the string representation of a property from the metaData of the node or <code>null</code> if the node has no Magnolia metaData or if no matching property is found. */ public String metaData(Node content, String property) { Object returnValue; try { if (property.equals(NodeTypes.Created.CREATED)) { returnValue = NodeTypes.Created.getCreated(content); } else if (property.equals(NodeTypes.Created.CREATED_BY)) { returnValue = NodeTypes.Created.getCreatedBy(content); } else if (property.equals(NodeTypes.LastModified.LAST_MODIFIED)) { returnValue = NodeTypes.LastModified.getLastModified(content); } else if (property.equals(NodeTypes.LastModified.LAST_MODIFIED_BY)) { returnValue = NodeTypes.LastModified.getLastModifiedBy(content); } else if (property.equals(NodeTypes.Renderable.TEMPLATE)) { returnValue = NodeTypes.Renderable.getTemplate(content); } else if (property.equals(NodeTypes.Activatable.LAST_ACTIVATED)) { returnValue = NodeTypes.Activatable.getLastActivated(content); } else if (property.equals(NodeTypes.Activatable.LAST_ACTIVATED_BY)) { returnValue = NodeTypes.Activatable.getLastActivatedBy(content); } else if (property.equals(NodeTypes.Activatable.ACTIVATION_STATUS)) { returnValue = NodeTypes.Activatable.getActivationStatus(content); } else if (property.equals(NodeTypes.Deleted.DELETED)) { returnValue = NodeTypes.Deleted.getDeleted(content); } else if (property.equals(NodeTypes.Deleted.DELETED_BY)) { returnValue = NodeTypes.Deleted.getDeletedBy(content); } else if (property.equals(NodeTypes.Deleted.COMMENT)) { // Since NodeTypes.Deleted.COMMENT and NodeTypes.Versionable.COMMENT have identical names this will work for both returnValue = NodeTypes.Deleted.getComment(content); } else { // Try to get the value using one of the deprecated names in MetaData. // This throws an IllegalArgumentException if its not one of those constants returnValue = MetaDataUtil.getMetaData(content).getStringProperty(property); // If no exception was thrown then warn that a legacy constant was used log.warn("Deprecated constant [" + property + "] used to query for meta data property on node [" + NodeUtil.getPathIfPossible(content) + "]"); } } catch (RepositoryException e) { return ""; } return returnValue instanceof Calendar ? ISO8601.format((Calendar) returnValue) : returnValue.toString(); } /** * @see {@link TemplatingFunctions#metaData(Node, String)}. */ public String metaData(ContentMap content, String property) { return metaData(content.getJCRNode(), property); } /** * Executes query and returns result as Collection of Nodes. * * @param workspace * @param statement has to be in formal form for chosen language * @param language * @param returnItemType */ public Collection<Node> search(String workspace, String statement, String language, String returnItemType) { try { return NodeUtil.getCollectionFromNodeIterator( QueryUtil.search(workspace, statement, language, returnItemType)); } catch (Exception e) { log.error(e.getMessage(), e); } return null; } /** * Executes simple SQL2 query and returns result as Collection of Nodes. * * @param workspace * @param statement should be set of labels target has to contain inserted as one string each separated by comma * @param returnItemType * @param startPath can be inserted, for results without limitation set it to slash */ public Collection<Node> simpleSearch(String workspace, String statement, String returnItemType, String startPath) { if (StringUtils.isEmpty(statement)) { log.error("Cannot search with empty statement."); return null; } String query = QueryUtil.buildQuery(statement, startPath); try { return NodeUtil .getCollectionFromNodeIterator(QueryUtil.search(workspace, query, "JCR-SQL2", returnItemType)); } catch (Exception e) { log.error(e.getMessage(), e); } return null; } }