/**
    * This file Copyright (c) 2011-2017 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.beans.config.URI2RepositoryManager;
  import info.magnolia.cms.core.AggregationState;
  import info.magnolia.cms.core.NodeData;
  import info.magnolia.cms.i18n.I18nContentSupport;
  import info.magnolia.cms.util.ContentUtil;
  import info.magnolia.cms.util.PathUtil;
  import info.magnolia.cms.util.QueryUtil;
  import info.magnolia.cms.util.SelectorUtil;
  import info.magnolia.cms.util.SiblingsHelper;
  import info.magnolia.context.MgnlContext;
  import info.magnolia.context.WebContext;
  import info.magnolia.context.HTMLEscapingWebContextWrapper;
  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.HTMLEscapingContentDecorator;
  import info.magnolia.jcr.wrapper.HTMLEscapingNodeWrapper;
  import info.magnolia.jcr.wrapper.I18nNodeWrapper;
  import info.magnolia.link.LinkUtil;
  import info.magnolia.objectfactory.Components;
  import info.magnolia.rendering.engine.RenderingEngine;
  import info.magnolia.rendering.template.configured.ConfiguredInheritance;
  import info.magnolia.rendering.template.type.DefaultTemplateTypes;
  import info.magnolia.rendering.template.type.TemplateTypeHelper;
  import info.magnolia.repository.RepositoryConstants;
  import info.magnolia.templating.inheritance.DefaultInheritanceContentDecorator;
  import info.magnolia.util.EscapeUtil;
  
  import java.net.URI;
  import java.net.URISyntaxException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Calendar;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Set;
  
  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.io.FileUtils;
  import org.apache.commons.lang3.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>.
   */
  public class TemplatingFunctions {
 
     private static final Logger log = LoggerFactory.getLogger(TemplatingFunctions.class);
 
     private final Provider<WebContext> webContextProvider;
     private final TemplateTypeHelper templateTypeHelper;
     private final Provider<I18nContentSupport> i18nContentSupport;
 
     @Inject
     public TemplatingFunctions(TemplateTypeHelper templateTypeFunctions, Provider<I18nContentSupport> i18nContentSupport, Provider<WebContext> webContextProvider) {
         this.webContextProvider = webContextProvider;
         this.templateTypeHelper = templateTypeFunctions;
         this.i18nContentSupport = i18nContentSupport;
     }
 
     /**
      * @deprecated since 5.4.11/5.5.1. Use {@link #TemplatingFunctions(info.magnolia.rendering.template.type.TemplateTypeHelper, javax.inject.Provider, javax.inject.Provider)} instead.
      */
     @Deprecated
     public TemplatingFunctions(Provider<AggregationState> aggregationStateProvider, TemplateTypeHelper templateTypeFunctions, Provider<I18nContentSupport> i18nContentSupport) {
         this(templateTypeFunctions, i18nContentSupport, new Provider<WebContext>() {
             @Override
             public WebContext get() {
                 return Components.getComponent(WebContext.class);
             }
         });
     }
 
     /**
      * @deprecated since 5.4.1 - use {@link TemplatingFunctions(Provider<AggregationState>, TemplateTypeHelper, Provider<I18nContentSupport>)} instead.
      */
     @Deprecated
     public TemplatingFunctions(Provider<AggregationState> aggregationStateProvider, TemplateTypeHelper templateTypeFunctions) {
         this(templateTypeFunctions, new Provider<I18nContentSupport>() {
             @Override
             public I18nContentSupport get() {
                 return Components.getComponent(I18nContentSupport.class);
             }
         }, new Provider<WebContext>() {
             @Override
             public WebContext get() {
                 return Components.getComponent(WebContext.class);
             }
         });
     }
 
     /**
      * @deprecated since 5.4 - use {@link TemplatingFunctions(Provider<AggregationState>, info.magnolia.rendering.template.type.TemplateTypeHelper)} instead.
      */
     @Deprecated
     public TemplatingFunctions(Provider<AggregationState> aggregationStateProvider) {
         this(Components.getComponent(TemplateTypeHelper.class), new Provider<I18nContentSupport>() {
             @Override
             public I18nContentSupport get() {
                 return Components.getComponent(I18nContentSupport.class);
             }
         }, new Provider<WebContext>() {
             @Override
             public WebContext get() {
                 return Components.getComponent(WebContext.class);
             }
         });
     }
 
     /**
      * Return the equivalent jcr node object for the provided contentMap.
      * Useful for converting an object for use in methods that expect a node.
      */
     public Node asJCRNode(ContentMap contentMap) {
         return contentMap == null ? null : contentMap.getJCRNode();
     }
 
     /**
      * Return the equivalent contentMap for the provided node object.
      * Useful for converting a node for use in templates - or for methods that expect a contentMap.
      */
     public ContentMap asContentMap(Node content) {
         return content == null ? null : new ContentMap(content);
     }
 
     /**
      * Returns the child nodes of the provided node.
      */
     public List<Node> children(Node content) throws RepositoryException {
         return content == null ? null : asNodeList(NodeUtil.getNodes(content, NodeUtil.EXCLUDE_META_DATA_FILTER));
     }
 
     /**
      * Returns the child nodes of the provided node of a specific nodeType.
      */
     public List<Node> children(Node content, String nodeTypeName) throws RepositoryException {
         return content == null ? null : asNodeList(NodeUtil.getNodes(content, nodeTypeName));
     }
 
     /**
      * Returns the child nodes of the provided contentMap - as a list of ContentMaps.
      */
     public List<ContentMap> children(ContentMap content) throws RepositoryException {
         return content == null ? null : asContentMapList(NodeUtil.getNodes(asJCRNode(content), NodeUtil.EXCLUDE_META_DATA_FILTER));
     }
 
     /**
      * Returns the child nodes of the the provided contentMap of a specific nodeType - as a list of ContentMaps.
      */
     public List<ContentMap> children(ContentMap content, String nodeTypeName) throws RepositoryException {
         return content == null ? null : asContentMapList(NodeUtil.getNodes(asJCRNode(content), nodeTypeName));
     }
 
     /**
      * See {@link #root(Node)} for details.
      */
     public ContentMap root(ContentMap contentMap) throws RepositoryException {
         return contentMap == null ? null : asContentMap(this.root(contentMap.getJCRNode()));
     }
 
     /**
      * See {@link #root(Node, String)} for details.
      */
     public ContentMap root(ContentMap contentMap, String nodeTypeName) throws RepositoryException {
         return contentMap == null ? null : asContentMap(this.root(contentMap.getJCRNode(), nodeTypeName));
     }
 
     /**
      * Returns the root node of the workspace to which the provided node belongs.
      */
     public Node root(Node content) throws RepositoryException {
         return this.root(content, null);
     }
 
     /**
      * Returns the *oldest* ancestor node of the provided node which has the specified nodeType.
      */
     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;
     }
 
     /**
      * See {@link #parent(Node)} for details.
      */
     public ContentMap parent(ContentMap contentMap) throws RepositoryException {
         return contentMap == null ? null : asContentMap(this.parent(contentMap.getJCRNode()));
     }
 
     /**
      * See {@link #parent(Node, String)} for details.
      */
     public ContentMap parent(ContentMap contentMap, String nodeTypeName) throws RepositoryException {
         return contentMap == null ? null : asContentMap(this.parent(contentMap.getJCRNode(), nodeTypeName));
     }
 
     /**
      * Returns the direct parent of the node.
      */
     public Node parent(Node content) throws RepositoryException {
         return this.parent(content, null);
     }
 
     /**
      * Returns the closest ancestor of the provided node which is of the specified nodeType.
      * For example, can be used to find the parent page of component as in {{@link #page(Node)}.
      */
     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 The page {@link ContentMap} of the passed content {@link ContentMap}.
      */
     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 The page {@link Node} of the passed content {@link Node}.
      */
     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);
     }
 
     /**
      * See {@link #ancestors(Node)} for details.
      */
     public List<ContentMap> ancestors(ContentMap contentMap) throws RepositoryException {
         return ancestors(contentMap, null);
     }
 
     /**
      * See {@link #ancestors(Node, String)} for details.
      */
     public List<ContentMap> ancestors(ContentMap contentMap, String nodeTypeName) throws RepositoryException {
         List<Node> ancestorsAsNodes = this.ancestors(contentMap.getJCRNode(), nodeTypeName);
         return asContentMapList(ancestorsAsNodes);
     }
 
     /**
      * Return a list of ancestors of the provided node.
      * The list does not include the root node and is ordered from *oldest* to *youngest*.
      */
     public List<Node> ancestors(Node content) throws RepositoryException {
         return content == null ? null : this.ancestors(content, null);
     }
 
     /**
      * Return a list of ancestors of the provided node which have the provided nodeType.
      * The list does not include the root node and is ordered from *oldest* to *youngest*.
      */
     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;
     }
 
     /**
      * Wraps the provided node with an inheritance wrapper so that the node appears to
      * contain the components and/or properties that exist in the equivalent nodes of the
      * ancestors of the provided node's "anchor".
      * <p>
      * (The anchor is the first parent of type mgnl:content - typically the page node of the area). The inheritance is subject to the inheritance configuration of the node. (See {@link info.magnolia.rendering.template.configured.ConfiguredInheritance}.) <b>Note:</b> This is the most commonly used signature of the 'inherit' methods, but the inherit methods are seldom necessary because areas already support inheritance natively through configuration.
      * </p>
      */
     public Node inherit(Node content) throws RepositoryException {
         return inherit(content, null);
     }
 
     /**
      * Wraps the provided node with an inheritance wrapper so that the node appears to
      * contain the components and/or properties that exist in the equivalent nodes of the
      * ancestors of the provided node's "anchor".
      * <p>
      * (The anchor is the first parent of type mgnl:content - typically the page node of the area). The inheritance is subject to the inheritance configuration of the node. (See {@link info.magnolia.rendering.template.configured.ConfiguredInheritance}.)
      * </p>
      *
      * @param relPath If not blank, the node will inherit the node specified by this relative path rather than the actual provided node.
      * This could be used to grab a specific property from a subnode.
      */
     public Node inherit(Node content, String relPath) throws RepositoryException {
         return inherit(content, relPath, StringUtils.EMPTY, ConfiguredInheritance.COMPONENTS_FILTERED, ConfiguredInheritance.PROPERTIES_ALL);
     }
 
     /**
      * Wraps the provided node with an inheritance wrapper so that the node appears to contain the components and/or
      * properties that exist in the equivalent nodes of the ancestors of the provided node's "anchor" (The anchor is
      * the first parent of type mgnl:content - typically the page node of the provided node).
      *
      * <p>The inheritance is subject to the inheritance configuration of the node, but can be overridden with the
      * parameters of this method.</p>
      * <p><b>Note</b>: The inherit methods are seldom necessary because areas already support inheritance natively
      * through configuration.</p>
      *
      * <p>Node inheritance accepts:
      * <dl><dt>{@link ConfiguredInheritance#COMPONENTS_ALL}</dt><dd>Inherit all components</dd>
      * <dt>{@link ConfiguredInheritance#COMPONENTS_FILTERED}</dt><dd>Inherit only components with property
      * <code>inheritable=true</code></dd>
      * <dt>{@link ConfiguredInheritance#COMPONENTS_NONE}</dt><dd>Do not inherit components</dd></dl></p>
      *
      * <p>Property inheritance accepts:
      * <dl><dt>{@link ConfiguredInheritance#PROPERTIES_ALL}</dt><dd>Inherit all properties of ancestors, if multiple
      * ancestors provide the same property the one from the nearest ancestor is used</dd>
      * <dt>{@link ConfiguredInheritance#PROPERTIES_NONE}</dt><dd>Do not inherit properties</dd></dl></p>
      *
      * @param relPath If not blank, the node will inherit the node specified by this relative path rather than the
      * actual provided node. This can be used to grab a specific property from a subnode.
      * @param nodeTypes If not blank, only ancestors of the anchor with one of the nodeTypes in this comma delimited
      * string will be evaluated.
      * @param nodeInheritance Specify which child components of the ancestors to inherit.
      * @param propertyInheritance Specify which properties of the ancestors to inherit.
      *
      * @see info.magnolia.templating.inheritance.DefaultInheritanceContentDecorator
      * @see info.magnolia.rendering.template.configured.ConfiguredInheritance
      */
     public Node inherit(Node content, String relPath, String nodeTypes, String nodeInheritance, String propertyInheritance) throws RepositoryException {
         if (content == null) {
             return null;
         }
 
         ConfiguredInheritance configuredInheritance = new ConfiguredInheritance();
         if (StringUtils.isNotEmpty(nodeTypes)) {
             configuredInheritance.setNodeTypes(Arrays.asList(StringUtils.split(nodeTypes, ",")));
         }
         if (StringUtils.isNotEmpty(nodeInheritance)) {
             configuredInheritance.setComponents(nodeInheritance);
         }
         if (StringUtils.isNotEmpty(propertyInheritance)) {
             configuredInheritance.setProperties(propertyInheritance);
         }
 
         Node inheritedNode = wrapForInheritance(content, configuredInheritance);
 
         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;
     }
 
     /**
      * See {@link #inherit(Node)} for details.
      */
     public ContentMap inherit(ContentMap content) throws RepositoryException {
         return inherit(content, null);
     }
 
     /**
      * See {@link #inherit(Node, String)} for details.
      */
     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);
     }
 
     /**
      * See {@link #inherit(Node, String, String, String, String)} for details.
      */
     public ContentMap inherit(ContentMap content, String relPath, String nodeTypes, String nodeInheritance, String propertyInheritance) throws RepositoryException {
         if (content == null) {
             return null;
         }
         Node node = inherit(content.getJCRNode(), relPath, nodeTypes, nodeInheritance, propertyInheritance);
         return node == null ? null : new ContentMap(node);
     }
 
     /**
      * Returns the inherited property of the node, subject to the standard rules of inheritance.
      * (See {@link info.magnolia.rendering.template.configured.ConfiguredInheritance}.)
      *
      * @param relPath The path to the property. Can reference a property in the current (wrapped) node, or
      * within subnodes via a slash syntax. (i.e. "myNode/mySubNode/myPropertyName")
      */
     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, new ConfiguredInheritance());
             return inheritedNode.getProperty(relPath);
 
         } catch (PathNotFoundException e) {
             // TODO fgrilli: rethrow exception?
         } catch (RepositoryException e) {
             // TODO fgrilli:rethrow exception?
         }
 
         return null;
     }
 
     /**
      * See {@link #inheritProperty(Node, String)} for details.
      */
     public Property inheritProperty(ContentMap content, String relPath) throws RepositoryException {
         if (content == null) {
             return null;
         }
         return inheritProperty(content.getJCRNode(), relPath);
     }
 
     /**
      * Returns the children of the wrapped-for-inheritance subnode obtained as in {@link #inherit(Node, String)}.
      */
     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, new ConfiguredInheritance());
         Node subNode = inheritedNode.getNode(relPath);
         return children(subNode);
     }
 
     /**
      * Returns the children of the wrapped-for-inheritance subnode obtained as in {@link #inherit(Node, String)}.
      */
     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, new ConfiguredInheritance());
         Node subNode = inheritedNode.getNode(relPath);
         return children(new ContentMap(subNode));
     }
 
     /**
      * Returns whether the content is inherited from another node.
      */
     public boolean isInherited(Node content) {
         if (content instanceof InheritanceNodeWrapper) {
             return ((InheritanceNodeWrapper) content).isInherited();
         }
         return false;
     }
 
     /**
      * See {@link #isInherited(Node)} for details.
      */
     public boolean isInherited(ContentMap content) {
         return isInherited(asJCRNode(content));
     }
 
     /**
      * Returns whether the content is an actual child of the current page -
      * i.e. that it was not inherited from another page (or node).
      */
     public boolean isFromCurrentPage(Node content) {
         return !isInherited(content);
     }
 
     /**
      * See {@link #isFromCurrentPage(Node)} for details.
      */
     public boolean isFromCurrentPage(ContentMap content) {
         return isFromCurrentPage(asJCRNode(content));
     }
 
     /**
      * Returns a url for Node identified by nodeIdentifier in the specified workspace.
      * Suitable for use in an html anchor.
      */
     public String link(String workspace, String nodeIdentifier) {
         try {
             return LinkUtil.createLink(workspace, nodeIdentifier);
         } catch (RepositoryException e) {
             handleRepositoryException(e, workspace);
             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;
         }
     }
 
     /**
      * Returns a url for the provided node.
      * Suitable for use in an html anchor.
      */
     public String link(Node content) {
         return content == null ? null : LinkUtil.createLink(content);
     }
 
     /**
      * See {@link #link(Node)} for details.
      */
     public String link(ContentMap contentMap) throws RepositoryException {
         return contentMap == null ? null : this.link(asJCRNode(contentMap));
     }
 
     public String linkPrefix(Node content) {
         if (!MgnlContext.isWebContext()) {
             return MgnlContext.getContextPath();
         }
         String fullLinkToPage = link(content);
         String pagePath = Components.getComponent(URI2RepositoryManager.class).getURI(LinkUtil.createLinkInstance(content));
         int ndx = fullLinkToPage.length();
         for (int cnt = StringUtils.countMatches(pagePath, "/"); cnt > 0; cnt--) {
             ndx = fullLinkToPage.lastIndexOf('/', ndx - 1);
         }
         String linkPrefix = fullLinkToPage.substring(0, ndx);
         return linkPrefix;
     }
 
     /**
      * See {@link #linkPrefix(Node)} for details.
      */
     public String linkPrefix(ContentMap content) {
         return linkPrefix(asJCRNode(content));
     }
 
     /**
      * Returns the querystring and fragment of a url, or an empty string if there are none.
      *
      * @deprecated since 5.3.8 - use {@link #queryStringAndFragment(String) instead.
      */
     @Deprecated
     public String getQueryStringAndFragment(String url) {
         return queryStringAndFragment(url);
     }
 
     /**
      * Returns the querystring and fragment of a url, or an empty string if there are none.
      */
     public String queryStringAndFragment(String url) {
         String result = StringUtils.EMPTY;
         try {
             URI uri = new URI(url);
             String query = uri.getQuery();
             String fragment = uri.getFragment();
 
             if (StringUtils.isNotEmpty(query)) {
                 result += "?" + query;
             }
             if (StringUtils.isNotEmpty(fragment)) {
                 result += "#" + fragment;
             }
         } catch (URISyntaxException e) {
             log.warn("URL cannot be parsed. {0}, {1}", url, e.getMessage());
             return StringUtils.EMPTY;
         }
         return result;
     }
 
     /**
      * Get the language used currently.
      *
      * @return The language as a String.
      */
     public String language() {
         return i18nContentSupport.get().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;
         }
         // Anchors should not be prepended with protocol
         if (!hasProtocol(externalLink) && !externalLink.startsWith("#")) {
             externalLink = "http://" + externalLink;
         }
         return EscapeUtil.escapeXss(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);
     }
 
     /**
      * Returns whether the request is from the Page editor edit mode.
      * Specifically whether the request is on the author instance and not from the page editor in preview mode.
      * Useful for providing messages in the page to assist the editors.
      */
     public boolean isEditMode() {
         // TODO : see CmsFunctions.isEditMode, which checks a couple of other properties.
         return isAuthorInstance() && !isPreviewMode();
     }
 
     /**
      * Returns whether the request is from the Page editor preview mode.
      */
     public boolean isPreviewMode() {
         return this.webContextProvider.get().getAggregationState().isPreviewMode();
     }
 
     /**
      * Returns whether the request is from an author instance.
      */
     public boolean isAuthorInstance() {
         return Components.getComponent(ServerConfiguration.class).isAdmin();
     }
 
     /**
      * Returns whether the request is from a public instance.
      */
     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.
      *
      * @deprecated since 5.3.3 use {@link #contentByPath(String)} or {@link #nodeByPath(String)} instead
      */
     @Deprecated
     public Node content(String path) {
         return content(RepositoryConstants.WEBSITE, path);
     }
 
     /**
      * Return the Node for the given path from the given repository.
      *
      * @deprecated since 5.3.3 use {@link #contentByPath(String, String)} or {@link #nodeByPath(String, String)} instead
      */
     @Deprecated
     public Node content(String repository, String path) {
         return SessionUtil.getNode(repository, path);
     }
 
     /**
      * Return the Node by the given identifier from the website repository.
      *
      * @deprecated since 5.3.3 use {@link #contentById(String)} or {@link #nodeById(String) instead
      */
     @Deprecated
     public Node contentByIdentifier(String id) {
         return contentByIdentifier(RepositoryConstants.WEBSITE, id);
     }
 
     /**
      * Return the Node by the given identifier from the given repository.
      *
      * @deprecated since 5.3.3 use {@link #contentById(String, String)} or {@link #contentByPath(String, String)} instead
      */
     @Deprecated
     public Node contentByIdentifier(String repository, String id) {
         return SessionUtil.getNodeByIdentifier(repository, id);
     }
 
     /**
      * Return the ContentMap for the given path from the website repository.
      */
     public ContentMap contentByPath(String path) {
         return contentByPath(path, RepositoryConstants.WEBSITE);
     }
 
     /**
      * Return the ContentMap for the given path from the given repository.
      */
     public ContentMap contentByPath(String path, String workspace) {
         return asContentMap(nodeByPath(path, workspace));
     }
 
     /**
      * Return the ContentMap by the given identifier from the website repository.
      */
     public ContentMap contentById(String id) {
         return contentById(id, RepositoryConstants.WEBSITE);
     }
 
     /**
      * Return the ContentMap by the given identifier from the given repository.
      */
     public ContentMap contentById(String id, String workspace) {
         return asContentMap(nodeById(id, workspace));
     }
 
     /**
      * Return the Node for the given path from the website repository.
      */
     public Node nodeByPath(String path) {
         return nodeByPath(path, RepositoryConstants.WEBSITE);
     }
 
     /**
      * Return the Node for the given path from the given repository.
      */
     public Node nodeByPath(String path, String workspace) {
         try {
             String pathToNode = new URI(path).getPath();
             return webContextProvider.get().getJCRSession(workspace).getNode(pathToNode);
         } catch (URISyntaxException e) {
             log.warn("Path cannot be parsed. {0}, {1}", path, e.getMessage());
             return null;
         } catch (RepositoryException e) {
             handleRepositoryException(e, workspace);
             return null;
         }
     }
 
     /**
      * Return the Node by the given identifier from the website repository.
      */
     public Node nodeById(String id) {
         return nodeById(id, RepositoryConstants.WEBSITE);
     }
 
     /**
      * Return the Node by the given identifier from the given repository.
      */
     public Node nodeById(String id, String workspace) {
         try {
             return webContextProvider.get().getJCRSession(workspace).getNodeByIdentifier(id);
         } catch (RepositoryException e) {
             handleRepositoryException(e, workspace);
             return null;
         }
     }
 
     private void handleRepositoryException(RepositoryException e, String workspace) {
         final AggregationState aggregationState = webContextProvider.get().getAggregationState();
         String template;
         try {
             template = NodeTypes.Renderable.getTemplate(aggregationState.getCurrentContentNode());
         } catch (RepositoryException e1) {
             template = "unknown";
         }
         log.debug("Exception in '{}' workspace when rendering template '{}' for URI '{}': {}", workspace, template, aggregationState.getOriginalBrowserURI(), e);
 
     }
 
     /**
      * Returns a {@link Node} object which is referenced by its id, stored in
      * the @param propertyName.
      *
      * @param content The node with a property containing the referenced id value.
      * @param idPropertyName The name of the property which contains the id of the referenced {@link Node}.
      * @param referencedWorkspace The workspace in which the referenced {@link Node} exists.
      * @return the referenced {@link Node}
      */
     public Node contentByReference(Node content, String idPropertyName, String referencedWorkspace) throws RepositoryException {
         if (content.hasProperty(idPropertyName)) {
             final String identifier = PropertyUtil.getString(content, idPropertyName);
             final Node node = NodeUtil.getNodeByIdentifier(referencedWorkspace, identifier);
             return encode(wrapForI18n(node));
         }
         return null;
     }
 
     /**
      * See {@link #contentByReference(Node, String, String)} for details.
      */
     public ContentMap contentByReference(ContentMap content, String idPropertyName, String referencedWorkspace) throws RepositoryException {
         Node node = asJCRNode(content);
         return asContentMap(contentByReference(node, idPropertyName, referencedWorkspace));
     }
 
     /**
      * Returns a List of {@link ContentMap} objects for the provided collection of {@link Node} objects.
      * Useful for working with a collection of Nodes in a template.
      */
     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;
     }
 
     /**
      * Returns a List of {@link Node} objects for the provided collection of {@link ContentMap} objects.
      * Useful for working with a collection of ContentMaps in java code.
      */
     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.
      */
     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 &lt;br/&gt; tags.
      */
     public ContentMap encode(ContentMap content) {
         return content != null ? new ContentMap(new HTMLEscapingNodeWrapper(content.getJCRNode(), true)) : null;
     }
 
     /**
      * Adds escaping of HTML on properties as well as changing line breaks into &lt;br/&gt; tags.
      */
     public Node encode(Node content) {
         return content != null ? new HTMLEscapingNodeWrapper(content, true) : null;
     }
 
     /**
      * Adds escaping of HTML on normal text as well as changing line breaks into &lt;br/&gt; tags.
      */
     public String encode(String text) {
         return new HTMLEscapingContentDecorator(true).decorate(text);
     }
 
     /**
      * Wraps content into {@link info.magnolia.jcr.wrapper.I18nNodeWrapper} so properties are in visitor's language.
      */
     public Node wrapForI18n(Node content) {
         return content != null ? new I18nNodeWrapper(content) : null;
     }
 
     /**
      * Wraps content into {@link info.magnolia.jcr.wrapper.I18nNodeWrapper} so properties are in visitor's language.
      */
     public ContentMap wrapForI18n(ContentMap content) {
         return content != null ? new ContentMap(wrapForI18n(content.getJCRNode())) : null;
     }
 
     /**
      * Wraps node in {@link DefaultInheritanceContentDecorator} so that the node will appear to contain
      * inherited components and/or properties of the ancestors of the template (typically the page).
      */
     private Node wrapForInheritance(Node destination, ConfiguredInheritance configuredInheritance) throws RepositoryException {
         configuredInheritance.setEnabled(true);
         return new DefaultInheritanceContentDecorator(destination, configuredInheritance).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 [{}] used to query for meta data property on node [{}]", property, NodeUtil.getPathIfPossible(content));
             }
         } catch (RepositoryException e) {
             log.error("An error occured while trying to get [{}] property at [{}]", property, NodeUtil.getNodePathIfPossible(content), e);
             return null;
         }
 
         return returnValue instanceof Calendar ? ISO8601.format((Calendar) returnValue) : returnValue != null ? returnValue.toString() : null;
     }
 
     /**
      * See {@link #metaData(Node, String)} for details.
      */
     public String metaData(ContentMap content, String property) {
         return metaData(content.getJCRNode(), property);
     }
 
     /**
      * Executes query and returns result as Collection of Nodes.
      *
      * @deprecated since 5.4 - use <code>SearchTemplatingFunctions#searchContent(String, String, String, String, long, long)</code> from <code>info.magnolia.templating:magnolia-templating-essentials-models</code> instead.
      * @param statement has to be in formal form for chosen language
      */
     @Deprecated
     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.
      *
      * @deprecated since 5.4 - use <code>SearchTemplatingFunctions#searchContent(String, String, String, String, long, long)</code> from <code>info.magnolia.templating:magnolia-templating-essentials-models</code> instead.
      * @param statement should be set of labels target has to contain inserted as one string each separated by comma
      * @param startPath can be inserted, for results without limitation set it to slash
      */
     @Deprecated
     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;
     }
 
     /**
      * Returns the site's root of the {@link Node}.
      * <p>
      * The root {@link Node} is defined as the page {@link Node} having template type {@link info.magnolia.rendering.template.type.DefaultTemplateTypes#SITE_ROOT}. If no ancestor page exists with type {@link info.magnolia.rendering.template.type.DefaultTemplateTypes#SITE_ROOT}, the JCR workspace root is returned.
      * </p>
      *
      * @param content The node to determine its site root
      * @return The site root {@link Node} of the passed content {@link Node}
      */
     public Node siteRoot(Node content) {
         return this.siteRoot(content, DefaultTemplateTypes.SITE_ROOT);
     }
 
     /**
      * See {@link #siteRoot(Node)} for details..
      */
     public ContentMap siteRoot(ContentMap content) {
         return this.siteRoot(content, DefaultTemplateTypes.SITE_ROOT);
     }
 
     /**
      * See {@link #siteRoot(Node, String)} for details.
      */
     public ContentMap siteRoot(ContentMap content, String siteRootTemplateType) {
         return asContentMap(siteRoot(content.getJCRNode(), siteRootTemplateType));
     }
 
     /**
      * Returns the site's root of the passed {@link Node}.
      * <p>
      * The root {@link Node} is defined as the page {@link Node} with the passed template type (see: {@link info.magnolia.rendering.template.type.DefaultTemplateTypes}). If no ancestor page exists with provided type, the JCR workspace root is returned.
      * </p>
      *
      * @param content The node to determine its site root
      * @param siteRootTemplateType The template type value of the site root to detect.
      * @return The site root {@link Node} of the passed content {@link Node}
      */
     public Node siteRoot(Node content, String siteRootTemplateType) {
         if (siteRootTemplateType == null) {
             siteRootTemplateType = DefaultTemplateTypes.SITE_ROOT;
         }
         try {
             final Node page = page(content);
             final Node root = parentWithTemplateType(page, siteRootTemplateType);
             return (root == null) ? (Node) page.getAncestor(0) : root;
         } catch (RepositoryException e) {
             throw new RuntimeException("Can't access site root.", e);
         }
     }
 
     /**
      * Returns the type of the template assigned to a node.
      * <p>
      * If the assigned template is not a {@link info.magnolia.rendering.template.TemplateDefinition} it defaults to {@link DefaultTemplateTypes#CONTENT} and if there is no template assigned or the assigned template doesn't exists it returns the empty string.
      * </p>
      */
     public String templateType(Node pageNode) {
         return templateTypeHelper.getTemplateTypeOrDefault(pageNode);
     }
 
     /**
      * See {@link #templateType(Node)}.
      */
     public String templateType(ContentMap page) {
         return templateType(asJCRNode(page));
     }
 
     /**
      * Returns the subtype of the template assigned to a node.
      * <p>
      * If the assigned template is not a {@link info.magnolia.rendering.template.TemplateDefinition} it defaults to {@link DefaultTemplateTypes#CONTENT} and if there is no template assigned or the assigned template doesn't exists it returns the empty string.
      * </p>
      */
     public String templateSubtype(Node pageNode) {
         return templateTypeHelper.getTemplateSubtypeOrDefault(pageNode);
     }
 
     /**
      * See {@link #templateSubtype(Node)} for details.
      */
     public String templateSubtype(ContentMap page) {
         return templateSubtype(asJCRNode(page));
     }
 
     /**
      * Checks whether the given page-{@link javax.jcr.Node} has the specified <code>templateType</code>.
      */
     public boolean hasTemplateOfType(Node pageNode, String templateType) {
         return templateTypeHelper.hasTemplateOfType(pageNode, templateType);
     }
 
     /**
      * See {@link #hasTemplateOfType(Node, String)} for details.
      */
     public boolean hasTemplateOfType(ContentMap page, String templateType) {
         return hasTemplateOfType(asJCRNode(page), templateType);
     }
 
     /**
      * Finds a parent {@link javax.jcr.Node} of given {@link javax.jcr.Node} with the specified <code>templateType</code>.
      */
     public Node parentWithTemplateType(Node pageNode, String templateType) throws RepositoryException {
         return templateTypeHelper.findParentWithTemplateType(pageNode, templateType);
     }
 
     /**
      * See {@link #parentWithTemplateType(Node, String)}.
      */
     public ContentMap parentWithTemplateType(ContentMap page, String templateType) throws RepositoryException {
         return asContentMap(parentWithTemplateType(asJCRNode(page), templateType));
     }
 
     /**
      * Find content objects with the given template type (and optionally subtype) below given search root.
      *
      * @param searchRoot the {@link javax.jcr.Node} to use as root of the search
      * @param templateType the TemplateType to search for
      * @param templateSubtype the TemplateSubtype to search for (optional)
      * @param maxResultSize setting this can drastically improve query performance, if you are interested only in a fixed number of leading result objects
      * @param andClause an additional "AND" clause in SQL syntax, excluding the "AND" itself, e.g. "date IS NOT NULL"
      * @param orderByClause an "ORDER BY" clause in SQL syntax, excluding the "ORDER BY" itself, e.g. "date desc" or "date asc"
      */
     public List<Node> contentListByTemplateType(Node searchRoot, String templateType, String templateSubtype, int maxResultSize, String andClause, String orderByClause) throws RepositoryException {
         return templateTypeHelper.getContentListByTemplateType(searchRoot, templateType, templateSubtype, maxResultSize, andClause, orderByClause);
     }
 
     /**
      * See {@link #contentListByTemplateType(Node, String, String, int, String, String)} for details.
      */
     public List<ContentMap> contentListByTemplateType(ContentMap searchRoot, String templateType, String templateSubtype, int maxResultSize, String andClause, String orderByClause) throws RepositoryException {
         return asContentMapList(contentListByTemplateType(asJCRNode(searchRoot), templateType, templateSubtype, maxResultSize, andClause, orderByClause));
     }
 
     /**
      * See {@link #contentListByTemplateType(Node, String, String, int, String, String)} for details.
      */
     public List<Node> contentListByTemplateType(Node siteRoot, String templateType, String templateSubtype) throws RepositoryException {
         return contentListByTemplateType(siteRoot, templateType, templateSubtype, Integer.MAX_VALUE, null, null);
     }
 
     /**
      * See {@link #contentListByTemplateType(Node, String, String, int, String, String)} for details.
      */
     public List<ContentMap> contentListByTemplateType(ContentMap siteRoot, String templateType, String templateSubtype) throws RepositoryException {
         return asContentMapList(contentListByTemplateType(asJCRNode(siteRoot), templateType, templateSubtype, Integer.MAX_VALUE, null, null));
     }
 
     /**
      * Find content objects with one of the given template IDs below a given search root.
      *
      * @param searchRoot the {@link javax.jcr.Node} to use as root of the search
      * @param templateIds a {@link java.util.Set} of template IDs to search for
      * @param maxResultSize setting this can drastically improve query performance, if you are interested only in a fixed number of leading result objects
      * @param andClause an additional "AND" clause in SQL syntax, excluding the "AND" itself, e.g. "date IS NOT NULL"
      * @param orderByClause an "ORDER BY" clause in SQL syntax, excluding the "ORDER BY" itself, e.g. "date desc" or "date asc"
      */
     public List<Node> contentListByTemplateIds(Node searchRoot, Set<String> templateIds, int maxResultSize, String andClause, String orderByClause) throws RepositoryException {
         return templateTypeHelper.getContentListByTemplateIds(searchRoot, templateIds, maxResultSize, andClause, orderByClause);
     }
 
     /**
      * See {@link #contentListByTemplateIds(Node, Set, int, String, String)} for details.
      */
     public List<ContentMap> contentListByTemplateIds(ContentMap searchRoot, Set<String> templateIds, int maxResultSize, String andClause, String orderByClause) throws RepositoryException {
         return asContentMapList(contentListByTemplateIds(asJCRNode(searchRoot), templateIds, maxResultSize, andClause, orderByClause));
     }
 
     /**
      * See {@link #contentListByTemplateId(Node, String, int, String, String)} for details.
      */
     public List<Node> contentListByTemplateId(Node searchRoot, String templateId) throws RepositoryException {
         return contentListByTemplateIds(searchRoot, Collections.singleton(templateId), Integer.MAX_VALUE, null, null);
     }
 
     /**
      * Find content objects with the given template ID below a given search root.
      *
      * @param searchRoot the {@link javax.jcr.Node} to use as root of the search
      * @param templateId a template ID to search for
      * @param maxResultSize setting this can drastically improve query performance, if you are interested only in a fixed number of leading result objects
      * @param andClause an additional "AND" clause in SQL syntax, excluding the "AND" itself, e.g. "date IS NOT NULL"
      * @param orderByClause an "ORDER BY" clause in SQL syntax, excluding the "ORDER BY" itself, e.g. "date desc" or "date asc"
      */
     public List<Node> contentListByTemplateId(Node searchRoot, String templateId, int maxResultSize, String andClause, String orderByClause) throws RepositoryException {
         return contentListByTemplateIds(searchRoot, Collections.singleton(templateId), maxResultSize, andClause, orderByClause);
     }
 
     /**
      * Shortens a {@link java.lang.String} to provided length and adds a custom suffix.
      */
     public String abbreviateString(String stringToAbbreviate, int length, String suffix) {
         if (stringToAbbreviate == null) {
             return null;
         }
 
         if (stringToAbbreviate.length() > length) {
             final int lengthMinusSuffix = length - suffix.length();
             String abbreviatedString = StringUtils.left(stringToAbbreviate, lengthMinusSuffix);
 
             // If the character after the cut was a space, no word was cut: no cutting on last space needed
             String firstCharAfterCut = stringToAbbreviate.substring(lengthMinusSuffix, lengthMinusSuffix + 1);
             if (!" ".equals(firstCharAfterCut)) {
                 abbreviatedString = StringUtils.substringBeforeLast(abbreviatedString, " ");
             }
 
             return abbreviatedString + suffix;
         }
 
         return stringToAbbreviate;
     }
 
     /**
      * Shortens a {@link java.lang.String} to provided length and adds suffix "<code> ...</code>".
      */
     public String abbreviateString(String stringToAbbreviate, int length) {
         return abbreviateString(stringToAbbreviate, length, " ...");
     }
 
     /**
      * Returns the file extension of a filename by returning the suffix after the last <code>.</code> (dot).
      */
     public String fileExtension(String fileName) {
         return PathUtil.getExtension(fileName);
     }
 
     /**
      * Returns a human friendly string for a file size.
      *
      * @see org.apache.commons.io.FileUtils#byteCountToDisplaySize(long)
      */
     public String readableFileSize(long sizeBytes) {
         return FileUtils.byteCountToDisplaySize(sizeBytes);
     }
 
     /**
      * Checks if given language is current locale (set in {@link AggregationState}).
      */
     public boolean isCurrentLocale(String language) {
         return StringUtils.equals(webContextProvider.get().getAggregationState().getLocale().toString(), language);
     }
 
     /**
      * Creates a link of current URI to given language.
      *
      * <p><i>Note</i>: This currently only works with links to pages in the website repository. It is not possible to
      * generate localized links for URIs that point to another workspace or links that are forwarded.</p>
      *
      * @see <a href="https://wiki.magnolia-cms.com/display/DEV/Concept+-+Link+API+overhaul">Concept+-+Link+API+overhaul</a>
      */
     public Map<String, String> localizedLinks() throws RepositoryException {
         final Node currentNode = webContextProvider.get().getAggregationState().getCurrentContentNode();
 
         return localizedLinks(currentNode);
     }
 
     /**
      * Creates a map of localized links to the node for all supported languages.
      *
      * See {@link #localizedLinks()} for details.
      */
     public Map<String, String> localizedLinks(Node content) throws RepositoryException {
         final Node pageNode = page(content);
 
         final String pageIdentifier = pageNode.getIdentifier();
         final Collection<Locale> locales = i18nContentSupport.get().getLocales();
         if (i18nContentSupport.get().isEnabled() && locales.size() > 1) {
             final Map<String, String> map = new LinkedHashMap<>();
             for (Locale locale : locales) {
                 final String uri = createURI(pageIdentifier, locale);
                 // Using toString() method in order to be able to create link to e.g.
                 // de_CH, de_DE, de_AT
                 final String label = locale.toString();
                 map.put(label, uri);
             }
             return map;
         }
 
         return Collections.emptyMap();
     }
 
     /**
      * Creates a localized link by setting/resetting the {@link Locale} in the {@link AggregationState}.
      *
      * @see LinkUtil
      */
     private String createURI(final String identifier, final Locale locale) {
         // we are going to change the context language, this is ugly but is safe
         // as only the current Thread is modified
         final Locale currentLocale = i18nContentSupport.get().getLocale();
         String uri = null;
         final AggregationState aggregationState;
 
         if (Components.getComponent(RenderingEngine.class).getEscapeHtml()) {
             aggregationState = new HTMLEscapingWebContextWrapper(webContextProvider.get()).getAggregationState();
         } else {
             aggregationState = webContextProvider.get().getAggregationState();
         }
         try {
             aggregationState.setLocale(locale);
             uri = LinkUtil.createAbsoluteLink(RepositoryConstants.WEBSITE, identifier);
         } catch (RepositoryException e) {
             log.error("Error creating a localized link to node with identifier {} for locale {}", identifier, locale.toString());
         } finally {
             // make sure that we always reset to the original locale
             aggregationState.setLocale(currentLocale);
         }
 
         final String selector = aggregationState.getSelector();
         if (StringUtils.isNotBlank(selector)) {
             final String defaultExtension = Components.getComponent(ServerConfiguration.class).getDefaultExtension();
             if (StringUtils.isNotBlank(defaultExtension)) {
                 uri = StringUtils.substringBeforeLast(uri, "." + defaultExtension) + SelectorUtil.SELECTOR_DELIMITER + selector + SelectorUtil.SELECTOR_DELIMITER + "." + defaultExtension;
             } else {
                 uri = uri + SelectorUtil.SELECTOR_DELIMITER + selector + SelectorUtil.SELECTOR_DELIMITER;
             }
         }
 
         return uri;
     }
 
 }