Java tutorial
/* * #%L * ACS AEM Commons Bundle * %% * Copyright (C) 2016 Adobe * %% * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * #L% */ package com.adobe.acs.commons.wcm.properties.shared.impl; import com.adobe.acs.commons.wcm.PageRootProvider; import com.adobe.acs.commons.wcm.properties.shared.SharedComponentProperties; import com.day.cq.wcm.api.Page; import com.day.cq.wcm.api.PageInfoProvider; import com.day.cq.wcm.api.components.Component; import com.day.cq.wcm.api.components.ComponentManager; import com.google.common.base.Function; import com.google.common.collect.Maps; import org.apache.felix.scr.annotations.Activate; import org.apache.felix.scr.annotations.Deactivate; import org.apache.felix.scr.annotations.Reference; import org.apache.felix.scr.annotations.Service; import org.apache.sling.api.SlingHttpServletRequest; import org.apache.sling.api.resource.Resource; import org.apache.sling.api.resource.ResourceResolver; import org.apache.sling.api.resource.ResourceResolverFactory; import org.apache.sling.commons.json.JSONArray; import org.apache.sling.commons.json.JSONException; import org.apache.sling.commons.json.JSONObject; import org.apache.sling.jcr.api.SlingRepository; import org.apache.sling.jcr.base.util.AccessControlUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.jcr.LoginException; import javax.jcr.Node; import javax.jcr.RepositoryException; import javax.jcr.Session; import javax.jcr.observation.Event; import javax.jcr.observation.EventIterator; import javax.jcr.observation.EventListener; import javax.jcr.observation.ObservationManager; import javax.jcr.security.AccessControlManager; import javax.jcr.security.Privilege; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; /** * PageInfoProvider which indicates that shared component properties * are enabled, and for which component types. Note that this provider * requires Page Root Provider to be configured. * <p> * https://docs.adobe.com/docs/en/cq/5-6-1/developing/pageinfo.html#Creating a Page Information Provider */ @org.apache.felix.scr.annotations.Component @Service(PageInfoProvider.class) public class SharedComponentPropertiesPageInfoProvider implements PageInfoProvider, EventListener { private static final Logger log = LoggerFactory.getLogger(SharedComponentPropertiesPageInfoProvider.class); private static final String SERVICE_NAME = "shared-component-props"; @Reference private PageRootProvider pageRootProvider; @Reference private SharedComponentProperties sharedComponentProperties; @Reference private ResourceResolverFactory resourceResolverFactory; @Reference private SlingRepository repository; private Session respositorySession; private ObservationManager observationManager; private Map<String, List<Boolean>> componentsWithSharedProperties; private long scheduledSharedComponentsMapUpdate = -1L; /** * Add a "sharedComponentProperties" section to pageInfo so that JS libs in the authoring interface * can determine whether or not to enable shared/global properties for a component on a site. */ @Override public void updatePageInfo(SlingHttpServletRequest request, JSONObject info, Resource resource) throws JSONException { if (scheduledSharedComponentsMapUpdate > 0 && System.currentTimeMillis() > scheduledSharedComponentsMapUpdate) { scheduledSharedComponentsMapUpdate = -1L; updateSharedComponentsMap(); } JSONObject props = new JSONObject(); props.put("enabled", false); Page page = pageRootProvider.getRootPage(resource); if (page != null) { Session session = request.getResourceResolver().adaptTo(Session.class); try { AccessControlManager accessControlManager = AccessControlUtil.getAccessControlManager(session); Privilege privilegeAddChild = accessControlManager.privilegeFromName("jcr:addChildNodes"); Privilege privilegeModifyProps = accessControlManager.privilegeFromName("jcr:modifyProperties"); Privilege[] requiredPrivs = new Privilege[] { privilegeAddChild, privilegeModifyProps }; if (accessControlManager.hasPrivileges(page.getPath() + "/jcr:content", requiredPrivs)) { props.put("enabled", true); props.put("root", page.getPath()); props.put("components", Maps.transformValues(componentsWithSharedProperties, (Function<List<Boolean>, Object>) JSONArray::new)); } else { log.debug("User does not have [ {} ] on [ {} ]", requiredPrivs, page.getPath() + "/jcr:content"); } } catch (RepositoryException e) { log.error("Unexpected error checking permissions to modify shared component properties", e); } } else { log.debug("No Page Root could be found for [ {} ]", resource.getPath()); } info.put("sharedComponentProperties", props); } /** * Listen for add/update/delete of shared dialog nodes, in order to trigger an update of the * map of components that have shared property dialogs. * * Technically a delete may not be caught if a node higher in the ancestry is deleted (thus * deleting its children) but having a stale entry in the map does not cause any problems. */ @Override public void onEvent(EventIterator eventIterator) { while (eventIterator.hasNext()) { Event event = eventIterator.nextEvent(); try { String[] pathPieces = event.getPath().split("/"); String nodeName = pathPieces[pathPieces.length - 1]; switch (nodeName) { case "dialogglobal": case "dialogshared": case "dialog_global": case "dialog_shared": scheduleSharedComponentsMapUpdate(); break; default: break; } } catch (Exception e) { log.error("Error determining if event affects list of components with shared/global properties", e); } } } /** * Schedule an update of the map of components with shared/global properties to be updated * 5 seconds from now. * * This handles race conditions where the map calculation happens before all nodes are installed, * and also prevents stampedes from multiple JCR update events such as during a package installation. */ private void scheduleSharedComponentsMapUpdate() { log.debug("Flagging for rebuild of the map of components with shared properties dialogs"); scheduledSharedComponentsMapUpdate = System.currentTimeMillis() + 5000; } /** * Traverse the entire set of components in the /apps directory and create a map of all component types * that have shared/global config dialogs. * * This is used by the JS libs in the authoring interface to determine if a component should show the * options for editing shared/global configs. */ private void updateSharedComponentsMap() { ResourceResolver resourceResolver = null; try { log.debug("Calculating map of components with shared properties dialogs"); Map<String, Object> authInfo = Collections.singletonMap(ResourceResolverFactory.SUBSERVICE, (Object) SERVICE_NAME); resourceResolver = resourceResolverFactory.getServiceResourceResolver(authInfo); resourceResolver.refresh(); ComponentManager componentManager = resourceResolver.adaptTo(ComponentManager.class); Map<String, List<Boolean>> localComponentsWithSharedProperties = new HashMap<>(); for (Component component : componentManager.getComponents()) { if (component.getPath().startsWith("/apps")) { boolean hasSharedDialogForTouch = componentHasTouchDialog(component, "dialogshared"); boolean hasGlobalDialogForTouch = componentHasTouchDialog(component, "dialogglobal"); boolean hasSharedDialogForClassic = componentHasClassicDialog(component, "dialog_shared"); boolean hasGlobalDialogForClassic = componentHasClassicDialog(component, "dialog_global"); if (hasSharedDialogForTouch || hasGlobalDialogForTouch || hasSharedDialogForClassic || hasGlobalDialogForClassic) { localComponentsWithSharedProperties.put(component.getResourceType(), Arrays.asList(hasSharedDialogForTouch, hasGlobalDialogForTouch, hasSharedDialogForClassic, hasGlobalDialogForClassic)); } } } componentsWithSharedProperties = Collections.unmodifiableMap(localComponentsWithSharedProperties); log.debug("Calculated map of components with shared properties dialogs: {}", componentsWithSharedProperties); } catch (org.apache.sling.api.resource.LoginException e) { log.error( "Unable to log into service user to determine list of components with shared properties dialogs", e); } catch (RepositoryException e) { log.error("Unexpected error attempting to determine list of components with shared properties dialogs", e); } finally { if (resourceResolver != null) { resourceResolver.close(); } } } /** * Determine if a component has a Classic UI dialog for shared or global configs. */ private boolean componentHasClassicDialog(Component component, String dialogName) throws RepositoryException { Resource dialog = component.getLocalResource(dialogName); return dialog != null && dialog.adaptTo(Node.class).isNodeType("cq:Dialog"); } /** * Determine if a component has a Touch UI dialog for shared or global configs. */ private boolean componentHasTouchDialog(Component component, String dialogName) { Resource dialog = component.getLocalResource(dialogName); return dialog != null && dialog.isResourceType("cq/gui/components/authoring/dialog"); } @Activate public void activate(final Map<String, String> config) throws RepositoryException { componentsWithSharedProperties = new HashMap<>(); // Schedule the initial calculation of components that have shared/global property dialogs. scheduleSharedComponentsMapUpdate(); try { // Add an event listener on the /apps directory for component adds/removals to recalculate // the set of components that have shared/global property dialogs. respositorySession = repository.loginService(SERVICE_NAME, null); observationManager = respositorySession.getWorkspace().getObservationManager(); // Need to listen for "nt:folder" else "nt:unstructured" nodes created/deleted from // CRD DE are not captured. String[] nodeTypes = { "nt:folder", "nt:unstructured" }; int eventTypes = Event.NODE_ADDED | Event.NODE_REMOVED; observationManager.addEventListener(this, eventTypes, "/apps", true, null, nodeTypes, true); log.info("Activated JCR event listener for components with shared/global properties"); } catch (LoginException le) { log.error( "Could not get an admin resource resolver to listen for components with shared/global properties"); } catch (Exception e) { log.error("Error activating JCR event listener for components with shared/global properties", e); } } @Deactivate public void deactivate(final Map<String, String> config) throws RepositoryException { scheduledSharedComponentsMapUpdate = -1L; try { if (observationManager != null) { observationManager.removeEventListener(this); log.info("Deactivated JCR event listener for components with shared/global properties"); } } catch (RepositoryException re) { log.error("Error deactivating JCR event listener for components with shared/global properties", re); } finally { if (respositorySession != null) { respositorySession.logout(); respositorySession = null; } } } }