ComponentPropertyResolver.java

  1. /*
  2.  * #%L
  3.  * wcm.io
  4.  * %%
  5.  * Copyright (C) 2019 wcm.io
  6.  * %%
  7.  * Licensed under the Apache License, Version 2.0 (the "License");
  8.  * you may not use this file except in compliance with the License.
  9.  * You may obtain a copy of the License at
  10.  *
  11.  *      http://www.apache.org/licenses/LICENSE-2.0
  12.  *
  13.  * Unless required by applicable law or agreed to in writing, software
  14.  * distributed under the License is distributed on an "AS IS" BASIS,
  15.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16.  * See the License for the specific language governing permissions and
  17.  * limitations under the License.
  18.  * #L%
  19.  */
  20. package io.wcm.wcm.commons.component;

  22. import java.util.Collection;
  23. import java.util.Map;

  25. import org.apache.commons.collections4.IterableUtils;
  26. import org.apache.commons.lang3.StringUtils;
  27. import org.apache.sling.api.resource.LoginException;
  28. import org.apache.sling.api.resource.Resource;
  29. import org.apache.sling.api.resource.ResourceResolver;
  30. import org.apache.sling.api.resource.ResourceResolverFactory;
  31. import org.apache.sling.api.resource.ResourceUtil;
  32. import org.jetbrains.annotations.NotNull;
  33. import org.jetbrains.annotations.Nullable;
  34. import org.osgi.annotation.versioning.ProviderType;
  35. import org.slf4j.Logger;
  36. import org.slf4j.LoggerFactory;

  38. import com.day.cq.wcm.api.Page;
  39. import com.day.cq.wcm.api.PageManager;
  40. import com.day.cq.wcm.api.components.Component;
  41. import com.day.cq.wcm.api.components.ComponentContext;
  42. import com.day.cq.wcm.api.components.ComponentManager;
  43. import com.day.cq.wcm.api.policies.ContentPolicy;
  44. import com.day.cq.wcm.api.policies.ContentPolicyManager;

  46. import io.wcm.sling.commons.adapter.AdaptTo;

  48. /**
  49.  * Tries to resolve properties with or without inheritance from pages, content policies or component definitions.
  50.  * <p>
  51.  * The lookup can take place in:
  52.  * </p>
  53.  * <ol>
  54.  * <li>Properties of the current page (including the parent pages if inheritance is enabled)</li>
  55.  * <li>Properties from the content policy associated with the current resource</li>
  56.  * <li>Properties defined on the component associated with the current resource (including super components if
  57.  * inheritance is enabled)</li>
  58.  * </ol>
  59.  * <p>
  60.  * By default, only option 3 is enabled (with inheritance).
  61.  * Please make sure to {@link #close()} instances of this class after usage.
  62.  * </p>
  63.  */
  64. @ProviderType
  65. public final class ComponentPropertyResolver implements AutoCloseable {

  67.   private ComponentPropertyResolution componentPropertiesResolution = ComponentPropertyResolution.RESOLVE_INHERIT;
  68.   private ComponentPropertyResolution pagePropertiesResolution = ComponentPropertyResolution.IGNORE;
  69.   private ComponentPropertyResolution contentPolicyResolution = ComponentPropertyResolution.IGNORE;
  70.   private final Page currentPage;
  71.   private final Component currentComponent;
  72.   private final Resource resource;
  73.   private final ResourceResolverFactory resourceResolverFactory;
  74.   private ResourceResolver componentsResourceResolver;
  75.   private boolean initComponentsResourceResolverFailed;

  77.   private static final String SERVICEUSER_SUBSERVICE = "component-properties";

  79.   private static final Logger log = LoggerFactory.getLogger(ComponentPropertyResolver.class);

  81.   /**
  82.    * This constructor is for internal use only, please use {@link ComponentPropertyResolverFactory}.
  83.    * @param page Content page
  84.    * @param resourceResolverFactory Resource resolver factory
  85.    */
  86.   public ComponentPropertyResolver(@NotNull Page page,
  87.       @Nullable ResourceResolverFactory resourceResolverFactory) {
  88.     this(page.getContentResource(), resourceResolverFactory);
  89.   }

  91.   /**
  92.    * This constructor is for internal use only, please use {@link ComponentPropertyResolverFactory}.
  93.    * @param resource Content resource
  94.    * @param resourceResolverFactory Resource resolver factory
  95.    */
  96.   public ComponentPropertyResolver(@NotNull Resource resource,
  97.       @Nullable ResourceResolverFactory resourceResolverFactory) {
  98.     this(resource, false, resourceResolverFactory);
  99.   }

  101.   /**
  102.    * This constructor is for internal use only, please use {@link ComponentPropertyResolverFactory}.
  103.    * @param resource Content resource
  104.    * @param ensureResourceType Ensure the given resource has a resource type.
  105.    *          If this is not the case, try to find the closest parent resource which has a resource type.
  106.    * @param resourceResolverFactory Resource resolver factory
  107.    */
  108.   public ComponentPropertyResolver(@NotNull Resource resource, boolean ensureResourceType,
  109.       @Nullable ResourceResolverFactory resourceResolverFactory) {
  110.     Resource contextResource = null;
  111.     if (ensureResourceType) {
  112.       // find closest parent resource that has a resource type (and not nt:unstructured)
  113.       contextResource = getResourceWithResourceType(resource);
  114.     }
  115.     if (contextResource == null) {
  116.       contextResource = resource;
  117.     }

  119.     ResourceResolver resourceResolver = contextResource.getResourceResolver();
  120.     PageManager pageManager = AdaptTo.notNull(resourceResolver, PageManager.class);
  121.     this.currentPage = pageManager.getContainingPage(contextResource);
  122.     if (hasResourceType(contextResource)) {
  123.       ComponentManager componentManager = AdaptTo.notNull(resourceResolver, ComponentManager.class);
  124.       this.currentComponent = componentManager.getComponentOfResource(contextResource);
  125.     }
  126.     else {
  127.       this.currentComponent = null;
  128.     }
  129.     this.resource = contextResource;
  130.     this.resourceResolverFactory = resourceResolverFactory;
  131.   }

  133.   /**
  134.    * This constructor is for internal use only, please use {@link ComponentPropertyResolverFactory}.
  135.    * @param wcmComponentContext WCM component context
  136.    * @param resourceResolverFactory Resource resolver factory
  137.    */
  138.   public ComponentPropertyResolver(@NotNull ComponentContext wcmComponentContext,
  139.       @Nullable ResourceResolverFactory resourceResolverFactory) {
  140.     this.currentPage = wcmComponentContext.getPage();
  141.     this.currentComponent = wcmComponentContext.getComponent();
  142.     this.resource = wcmComponentContext.getResource();
  143.     this.resourceResolverFactory = resourceResolverFactory;
  144.   }

  146.   /**
  147.    * Lookup for content resource associated with the page component (resource type).
  148.    * @param page Content page
  149.    * @deprecated Please use {@link ComponentPropertyResolverFactory}.
  150.    */
  151.   @Deprecated(since = "1.6.0")
  152.   public ComponentPropertyResolver(@NotNull Page page) {
  153.     this(page, null);
  154.   }

  156.   /**
  157.    * Lookup for content resource associated with a component (resource type).
  158.    * @param resource Content resource
  159.    * @deprecated Please use {@link ComponentPropertyResolverFactory}.
  160.    */
  161.   @Deprecated(since = "1.6.0")
  162.   public ComponentPropertyResolver(@NotNull Resource resource) {
  163.     this(resource, null);
  164.   }

  166.   /**
  167.    * Lookup for content resource associated with a component (resource type).
  168.    * @param resource Content resource
  169.    * @param ensureResourceType Ensure the given resource has a resource type.
  170.    *          If this is not the case, try to find the closest parent resource which has a resource type.
  171.    * @deprecated Please use {@link ComponentPropertyResolverFactory}.
  172.    */
  173.   @Deprecated(since = "1.6.0")
  174.   public ComponentPropertyResolver(@NotNull Resource resource, boolean ensureResourceType) {
  175.     this(resource, ensureResourceType, null);
  176.   }

  178.   /**
  179.    * Lookup with content resource associated with a component (resource type).
  180.    * @param wcmComponentContext WCM component context
  181.    * @deprecated Please use {@link ComponentPropertyResolverFactory}.
  182.    */
  183.   @Deprecated(since = "1.6.0")
  184.   public ComponentPropertyResolver(@NotNull ComponentContext wcmComponentContext) {
  185.     this(wcmComponentContext, null);
  186.   }

  188.   private static boolean hasResourceType(@NotNull Resource resource) {
  189.     return StringUtils.isNotEmpty(resource.getResourceType());
  190.   }

  192.   @SuppressWarnings({ "null", "java:S2589" }) // extra null checks for backward compatibility
  193.   private static @Nullable Resource getResourceWithResourceType(@Nullable Resource resource) {
  194.     if (resource == null) {
  195.       return null;
  196.     }
  197.     String resourceType = resource.getResourceType();
  198.     if (resourceType != null && isPathBasedResourceType(resourceType)) {
  199.       return resource;
  200.     }
  201.     return getResourceWithResourceType(resource.getParent());
  202.   }

  204.   /**
  205.    * Checks if the resource type is a path pointing to a component resource in the repository
  206.    * (where we can lookup properties to inherit from).
  207.    * @param resourceType Resource type
  208.    * @return true for path-based resource types
  209.    */
  210.   private static boolean isPathBasedResourceType(@NotNull String resourceType) {
  211.     return StringUtils.contains(resourceType, "/");
  212.   }

  214.   /**
  215.    * Configure if properties should be resolved in component properties, and with or without inheritance.
  216.    * Default mode is {@link ComponentPropertyResolution#RESOLVE_INHERIT}.
  217.    * @param resolution Resolution mode
  218.    * @return this
  219.    */
  220.   public ComponentPropertyResolver componentPropertiesResolution(@NotNull ComponentPropertyResolution resolution) {
  221.     this.componentPropertiesResolution = resolution;
  222.     return this;
  223.   }

  225.   /**
  226.    * Configure if properties should be resolved in content page properties, and with or without inheritance.
  227.    * Default mode is {@link ComponentPropertyResolution#IGNORE}.
  228.    * @param resolution Resolution mode
  229.    * @return this
  230.    */
  231.   public ComponentPropertyResolver pagePropertiesResolution(@NotNull ComponentPropertyResolution resolution) {
  232.     this.pagePropertiesResolution = resolution;
  233.     return this;
  234.   }

  236.   /**
  237.    * Configure if properties should be resolved from content policies mapped for the given resource.
  238.    * No explicit inheritance mode is supported, so {@link ComponentPropertyResolution#RESOLVE_INHERIT}
  239.    * has the same effect as {@link ComponentPropertyResolution#RESOLVE} in this case.
  240.    * Default mode is {@link ComponentPropertyResolution#IGNORE}.
  241.    * @param resolution Resolution mode
  242.    * @return this
  243.    */
  244.   public ComponentPropertyResolver contentPolicyResolution(@NotNull ComponentPropertyResolution resolution) {
  245.     this.contentPolicyResolution = resolution;
  246.     return this;
  247.   }

  249.   /**
  250.    * Get property.
  251.    * @param name Property name
  252.    * @param type Property type
  253.    * @param <T> Parameter type
  254.    * @return Property value or null if not set
  255.    */
  256.   public @Nullable <T> T get(@NotNull String name, @NotNull Class<T> type) {
  257.     @Nullable
  258.     T value = getPageProperty(currentPage, name, type);
  259.     if (value == null) {
  260.       value = getContentPolicyProperty(name, type);
  261.     }
  262.     if (value == null) {
  263.       value = getComponentProperty(currentComponent, name, type);
  264.     }
  265.     return value;
  266.   }

  268.   /**
  269.    * Get property.
  270.    * @param name Property name
  271.    * @param defaultValue Default value
  272.    * @param <T> Parameter type
  273.    * @return Property value or default value if not set
  274.    */
  275.   public @NotNull <T> T get(@NotNull String name, @NotNull T defaultValue) {
  276.     @Nullable
  277.     @SuppressWarnings("unchecked")
  278.     T value = get(name, (Class<T>)defaultValue.getClass());
  279.     if (value != null) {
  280.       return value;
  281.     }
  282.     else {
  283.       return defaultValue;
  284.     }
  285.   }

  287.   private @Nullable <T> T getComponentProperty(@Nullable Component component,
  288.       @NotNull String name, @NotNull Class<T> type) {
  289.     if (componentPropertiesResolution == ComponentPropertyResolution.IGNORE || component == null) {
  290.       return null;
  291.     }
  292.     @Nullable
  293.     T result;
  294.     if (StringUtils.contains(name, "/")) {
  295.       // if a property in child resource is addressed get property value via local resource
  296.       // because the map behind the getProperties() method does not support child resource access
  297.       String childResourcePath = StringUtils.substringBeforeLast(name, "/");
  298.       String localPropertyName = StringUtils.substringAfterLast(name, "/");
  299.       Resource childResource = getLocalComponentResource(component, childResourcePath);
  300.       result = ResourceUtil.getValueMap(childResource).get(localPropertyName, type);
  301.     }
  302.     else {
  303.       result = component.getProperties().get(name, type);
  304.     }
  305.     if (result == null && componentPropertiesResolution == ComponentPropertyResolution.RESOLVE_INHERIT) {
  306.       result = getComponentProperty(component.getSuperComponent(), name, type);
  307.     }
  308.     return result;
  309.   }

  311.   private @Nullable <T> T getPageProperty(@Nullable Page page,
  312.       @NotNull String name, @NotNull Class<T> type) {
  313.     if (pagePropertiesResolution == ComponentPropertyResolution.IGNORE || page == null) {
  314.       return null;
  315.     }
  316.     @Nullable
  317.     T result = page.getProperties().get(name, type);
  318.     if (result == null && pagePropertiesResolution == ComponentPropertyResolution.RESOLVE_INHERIT) {
  319.       result = getPageProperty(page.getParent(), name, type);
  320.     }
  321.     return result;
  322.   }

  324.   private @Nullable <T> T getContentPolicyProperty(@NotNull String name, @NotNull Class<T> type) {
  325.     if (contentPolicyResolution == ComponentPropertyResolution.IGNORE || resource == null) {
  326.       return null;
  327.     }
  328.     ContentPolicy policy = getPolicy(resource);
  329.     if (policy != null) {
  330.       return policy.getProperties().get(name, type);
  331.     }
  332.     return null;
  333.   }

  335.   /**
  336.    * Get list of child resources.
  337.    * @param name Child node name
  338.    * @return List of child resources or null if not set.
  339.    */
  340.   public @Nullable Collection<Resource> getResources(@NotNull String name) {
  341.     Collection<Resource> list = getPageResources(currentPage, name);
  342.     if (list == null) {
  343.       list = getContentPolicyResources(name);
  344.     }
  345.     if (list == null) {
  346.       list = getComponentResources(currentComponent, name);
  347.     }
  348.     return list;
  349.   }

  351.   private @Nullable Collection<Resource> getComponentResources(@Nullable Component component, @NotNull String name) {
  352.     if (componentPropertiesResolution == ComponentPropertyResolution.IGNORE || component == null) {
  353.       return null;
  354.     }
  355.     Collection<Resource> result = getResources(getLocalComponentResource(component, name));
  356.     if (result == null && componentPropertiesResolution == ComponentPropertyResolution.RESOLVE_INHERIT) {
  357.       result = getComponentResources(component.getSuperComponent(), name);
  358.     }
  359.     return result;
  360.   }

  362.   private @Nullable Collection<Resource> getPageResources(@Nullable Page page, @NotNull String name) {
  363.     if (pagePropertiesResolution == ComponentPropertyResolution.IGNORE || page == null) {
  364.       return null;
  365.     }
  366.     Collection<Resource> result = getResources(page.getContentResource(name));
  367.     if (result == null && pagePropertiesResolution == ComponentPropertyResolution.RESOLVE_INHERIT) {
  368.       result = getPageResources(page.getParent(), name);
  369.     }
  370.     return result;
  371.   }

  373.   @SuppressWarnings("PMD.ReturnEmptyCollectionRatherThanNull")
  374.   private @Nullable Collection<Resource> getContentPolicyResources(@NotNull String name) {
  375.     if (contentPolicyResolution == ComponentPropertyResolution.IGNORE || resource == null) {
  376.       return null;
  377.     }
  378.     ContentPolicy policy = getPolicy(resource);
  379.     if (policy != null) {
  380.       Resource policyResource = policy.adaptTo(Resource.class);
  381.       if (policyResource != null) {
  382.         return getResources(policyResource.getChild(name));
  383.       }
  384.     }
  385.     return null;
  386.   }

  388.   private @Nullable Collection<Resource> getResources(@Nullable Resource parent) {
  389.     if (parent == null) {
  390.       return null;
  391.     }
  392.     Collection<Resource> children = IterableUtils.toList(parent.getChildren());
  393.     if (children.isEmpty()) {
  394.       return null;
  395.     }
  396.     return children;
  397.   }

  399.   /**
  400.    * Get content policy via policy manager.
  401.    * @param resource Content resource
  402.    * @return Policy or null
  403.    */
  404.   private static @Nullable ContentPolicy getPolicy(@NotNull Resource resource) {
  405.     ContentPolicyManager policyManager = AdaptTo.notNull(resource.getResourceResolver(), ContentPolicyManager.class);
  406.     return policyManager.getPolicy(resource);
  407.   }

  409.   /**
  410.    * Get local child resource for component, with a special handling for publish environments where
  411.    * the local child resources for components below /apps are not accessible for everyone.
  412.    * @param component Component
  413.    * @param childResourcePath Child resource path
  414.    * @return Resource or null
  415.    */
  416.   private @Nullable Resource getLocalComponentResource(@NotNull Component component,
  417.       @NotNull String childResourcePath) {
  418.     if (componentsResourceResolver == null
  419.         && resourceResolverFactory != null
  420.         && !initComponentsResourceResolverFailed) {
  421.       try {
  422.         componentsResourceResolver = resourceResolverFactory.getServiceResourceResolver(
  423.             Map.of(ResourceResolverFactory.SUBSERVICE, SERVICEUSER_SUBSERVICE));
  424.       }
  425.       catch (LoginException ex) {
  426.         initComponentsResourceResolverFailed = true;
  427.         if (log.isDebugEnabled()) {
  428.           log.debug("Unable to get resource resolver for accessing local component resource, "
  429.               + "please make sure to grant access to system user 'sling-scripting' for "
  430.               + "bundle 'io.wcm.wcm.commons', subservice '{}'.", SERVICEUSER_SUBSERVICE, ex);
  431.         }
  432.       }
  433.     }
  434.     if (componentsResourceResolver != null) {
  435.       String resourcePath = component.getPath() + "/" + childResourcePath;
  436.       return componentsResourceResolver.getResource(resourcePath);
  437.     }
  438.     // fallback implementation for previous behavior - this will usually not work in publish instances
  439.     return component.getLocalResource(childResourcePath);
  440.   }

  442.   @Override
  443.   public void close() {
  444.     if (componentsResourceResolver != null) {
  445.       componentsResourceResolver.close();
  446.     }
  447.   }

  449. }
Created with JaCoCo 0.8.13.202504020838