public static void getOrCreateBasePath(final ResourceResolver resolver, final String path) throws PersistenceException { ResourceUtil.getOrCreateResource(resolver, path, ResourceHelper.RESOURCE_TYPE_FOLDER, ResourceHelper.RESOURCE_TYPE_FOLDER, true); }
/** * Create a configuration resource * @param resolver current resolver * @param path path of the resource * @param type type of the node to be created * @param data map of properties to add * @throws PersistenceException in case configuration resource couldn't be persisted * @return resource created */ protected Resource createResource(ResourceResolver resolver, String path, String type, Map data) throws PersistenceException { return ResourceUtil.getOrCreateResource(resolver, path, data, type, false); }
public static Resource getRootResource(ResourceResolver resourceResolver, String rootPath) throws PersistenceException { Resource resource = ResourceUtil.getOrCreateResource(resourceResolver, rootPath, RESOURCE_FOLDER, RESOURCE_ROOT, true); return resource; }
/** * Create the resource and commit it * @param resolver The resource resolver * @param path The path of the resource * @param props The properties * @return The created resource * @throws PersistenceException If something goes wrong */ public static Resource createAndCommitResource(final ResourceResolver resolver, final String path, final Map<String, Object> props) throws PersistenceException { return ResourceUtil.getOrCreateResource(resolver, path, props, ResourceHelper.RESOURCE_TYPE_FOLDER, true); }
private Resource getOrCreateChecksumStorage(ResourceResolver resolver, String path) { Resource storage = null; try { boolean autoCommit = true; storage = ResourceUtil.getOrCreateResource(resolver, path, JcrConstants.NT_UNSTRUCTURED, JcrConstants.NT_UNSTRUCTURED, autoCommit); } catch (PersistenceException e) { LOG.error("Cannot create storage for script checksum", e); } return storage; } }
private Resource getOrCreateChecksumStorage(ResourceResolver resolver, String path) { Resource storage = null; try { boolean autoCommit = true; storage = ResourceUtil.getOrCreateResource(resolver, path, JcrConstants.NT_UNSTRUCTURED, JcrConstants.NT_UNSTRUCTURED, autoCommit); } catch (PersistenceException e) { LOG.error("Cannot create storage for script checksum", e); } return storage; } }
private Resource createMessageResource(ResourceResolver resolver) throws PersistenceException { final Resource parent = ResourceUtil.getOrCreateResource(resolver, SERIALIZED_ACTIONS, Collections.singletonMap("jcr:primaryType", (Object) "sling:OrderedFolder"), null, false); return resolver.create(parent, UUID.randomUUID().toString(), Collections.singletonMap("jcr:primaryType", (Object) "nt:unstructured")); }
props = Collections.singletonMap(ResourceResolver.PROPERTY_RESOURCE_TYPE, (Object)resourceType); return getOrCreateResource(resolver, path, props, intermediateResourceType, autoCommit);
public void createMissingNode(String path, ResourceResolver rr, Map<String, CompositeVariant> row) throws PersistenceException { String parentPath = StringUtils.substringBeforeLast(path, "/"); Resource parent = ResourceUtil.getOrCreateResource(rr, parentPath, defaultNodeType, defaultNodeType, true); String nodeName = StringUtils.substringAfterLast(path, "/"); if (!row.containsKey(JCR_PRIMARY_TYPE)) { row.put("JCR_TYPE", new CompositeVariant(defaultNodeType)); } Map<String, Object> nodeProps = new HashMap(row); rr.refresh(); rr.create(parent, nodeName, nodeProps); }
public static Resource getOrCreateResource(ResourceResolver resolver, String path, String defaultNodeType, Map<String, Object> properties, ConfigurationManagementSettings configurationManagementSettings) { try { Resource resource = ResourceUtil.getOrCreateResource(resolver, path, defaultNodeType, defaultNodeType, false); if (properties != null) { replaceProperties(resource, properties, configurationManagementSettings); } return resource; } catch (PersistenceException ex) { throw convertPersistenceException("Unable to create resource at " + path, ex); } }
public static Resource createResource(Resource root, DistributionQueueItem queueItem) throws PersistenceException { Resource minuteResource = getOrCreateMinuteResource(root); String entryPath = getUniqueEntryPath(minuteResource); ResourceResolver resourceResolver = root.getResourceResolver(); Map<String, Object> properties = serializeItem(queueItem); properties.put("sling:resourceType", RESOURCE_ITEM); properties.put(ENTERED_DATE, Calendar.getInstance()); Resource resourceItem = ResourceUtil.getOrCreateResource(resourceResolver, entryPath, properties, RESOURCE_FOLDER, true); resourceResolver.commit(); return resourceItem; }
@Override public Pipe build(String path) throws PersistenceException { Resource pipeResource = persistStep(path, NT_SLING_FOLDER, containerStep); if (outputs != null){ ResourceUtil.getOrCreateResource(resolver, path + "/" + OutputWriter.PARAM_WRITER, outputs, NT_SLING_FOLDER, false); } int index = 0; for (Step step : steps){ String name = StringUtils.isNotBlank(step.name) ? step.name : DEFAULT_NAMES.length > index ? DEFAULT_NAMES[index] : Integer.toString(index); index++; persistStep(path + "/" + Pipe.NN_CONF + "/" + name, NT_SLING_ORDERED_FOLDER, step); } resolver.commit(); logger.debug("built pipe under {}", path); return plumber.getPipe(pipeResource); }
@Override protected Iterator<Resource> computeOutput() throws Exception { Iterator<Resource> output = Collections.emptyIterator(); String expr = getExpr(); try { String path = isRootPath(expr) ? expr : getInput().getPath() + SLASH + expr; logger.info("creating path {}", path); if (!isDryRun()) { Resource resource = jcr ? getOrCreateNode(path) : ResourceUtil.getOrCreateResource(resolver, path, resourceType, intermediateType, autosave); output = Collections.singleton(resource).iterator(); } } catch (PersistenceException e){ logger.error ("Not able to create path {}", expr, e); } return output; }
public static Resource getPackagesRoot(ResourceResolver resourceResolver, String packagesRootPath) throws PersistenceException { Resource packagesRoot = resourceResolver.getResource(packagesRootPath); if (packagesRoot != null) { return packagesRoot; } synchronized (repolock) { if (resourceResolver.hasChanges()) { resourceResolver.refresh(); } packagesRoot = ResourceUtil.getOrCreateResource(resourceResolver, packagesRootPath, "sling:Folder", "sling:Folder", true); } return packagesRoot; }
public void persist(ResourceResolver rr, String path) throws PersistenceException, RepositoryException { ModifiableValueMap jcrContent = ResourceUtil.getOrCreateResource(rr, path, getResourceType(), null, false).adaptTo(ModifiableValueMap.class); jcrContent.put("jcr:primaryType", "nt:unstructured"); jcrContent.put("columns", getColumns().toArray(new String[0])); jcrContent.put("name", name); rr.commit(); rr.refresh(); JcrUtil.createPath(path + "/rows", "nt:unstructured", rr.adaptTo(Session.class)); int rowCounter = 0; for (Map<String, Object> row : rows) { // First strip out null values Map<String, Object> properties = row.entrySet().stream().filter(e -> e.getValue() != null).collect(Collectors.toMap(Entry::getKey, Entry::getValue)); rowCounter++; ResourceUtil.getOrCreateResource(rr, path + "/rows/row-" + rowCounter, properties, null, true); } rr.commit(); rr.refresh(); }
private static Resource createResource(Resource root, String relPath) throws PersistenceException { ResourceResolver resourceResolver = root.getResourceResolver(); String path = root.getPath() + "/" + relPath; final String parentPath = ResourceUtil.getParent(path); final String name = ResourceUtil.getName(path); Resource parent = ResourceUtil.getOrCreateResource(resourceResolver, parentPath, RESOURCE_FOLDER, RESOURCE_FOLDER, false); Map<String, Object> props = Collections.singletonMap(ResourceResolver.PROPERTY_RESOURCE_TYPE, (Object) RESOURCE_FOLDER); return resourceResolver.create(parent, name, props); }
public void persistStatus(ResourceResolver rr) throws PersistenceException { try { Map<String, Object> props = new HashMap<>(); props.put(JcrConstants.JCR_PRIMARYTYPE, JcrConstants.NT_FOLDER); ResourceUtil.getOrCreateResource(rr, BASE_PATH, props, null, true); props.put(JcrConstants.JCR_PRIMARYTYPE, "cq:Page"); ResourceUtil.getOrCreateResource(rr, getPath(), props, null, true); ModifiableValueMap jcrContent = ResourceUtil.getOrCreateResource(rr, getPath() + "/jcr:content", ProcessInstance.RESOURCE_TYPE, null, false).adaptTo(ModifiableValueMap.class); jcrContent.put("jcr:primaryType", "cq:PageContent"); jcrContent.put("jcr:title", getName()); ValueMapSerializer.serializeToMap(jcrContent, infoBean); ModifiableValueMap resultNode = ResourceUtil.getOrCreateResource(rr, getPath() + "/jcr:content/result", ProcessInstance.RESOURCE_TYPE + "/result", null, false).adaptTo(ModifiableValueMap.class); resultNode.put("jcr:primaryType", JcrConstants.NT_UNSTRUCTURED); ValueMapSerializer.serializeToMap(resultNode, infoBean.getResult()); rr.commit(); rr.refresh(); } catch (NullPointerException ex) { throw new PersistenceException("Null encountered when persisting status", ex); } }
/** * Get node for storing the renditions additional metadata. * @param asset Asset * @param createIfNotExists if true the node is (tried to be) created automatically if it does not exist * @return Node or null if it does not exist or could not be created */ @SuppressWarnings("null") private Resource getRenditionsMetadataResource(Asset asset, boolean createIfNotExists) { Resource assetResource = asset.adaptTo(Resource.class); String renditionsMetadataPath = assetResource.getPath() + "/" + JCR_CONTENT + "/" + NN_RENDITIONS_METADATA; try { if (createIfNotExists) { return ResourceUtil.getOrCreateResource(assetResource.getResourceResolver(), renditionsMetadataPath, ImmutableMap.<String, Object>of(JCR_PRIMARYTYPE, NT_UNSTRUCTURED), NT_UNSTRUCTURED, false); } else { return assetResource.getChild(renditionsMetadataPath); } } catch (PersistenceException ex) { log.error("Unable to get/create renditions metadata node at " + asset.getPath(), ex); } return null; }
private Resource createActionResource(ResourceResolver resolver, String actionType, String relPath) throws PersistenceException { final String path = createPath(relPath, config.getActionRoot(), config.getRandomPathPattern()); final Resource page = ResourceUtil.getOrCreateResource(resolver, path, Collections.singletonMap(JcrConstants.JCR_PRIMARYTYPE, (Object) "cq:Page"), null, false); final Map<String, Object> contentMap = new LinkedHashMap<String, Object>(); contentMap.put(JcrConstants.JCR_PRIMARYTYPE, "cq:PageContent"); contentMap.put("cq:distribute", false); final Resource content = resolver.create(page, JcrConstants.JCR_CONTENT, contentMap); resolver.commit(); final ModifiableValueMap map = content.adaptTo(ModifiableValueMap.class); map.put(NameConstants.PN_PAGE_LAST_MOD, Calendar.getInstance()); map.put(NameConstants.PN_PAGE_LAST_MOD_BY, resolver.getUserID()); map.put("cq:distribute", true); return content; }
@Override public void replicate(Script script, ResourceResolver resolver) throws ExecutionException, ReplicationException, PersistenceException { eventManager.trigger(Event.BEFORE_REPLICATE, script); final List<Script> includes = new LinkedList<>(); includes.add(script); includes.addAll(scriptManager.findIncludes(script, resolver)); final boolean autocommit = true; final Resource includeDir = ResourceUtil .getOrCreateResource(resolver, REPLICATION_PATH, JcrConstants.NT_UNSTRUCTURED, JcrConstants.NT_UNSTRUCTURED, autocommit); for (final Script include : includes) { final String path = (script.equals(include) ? SCRIPT_PATH : REPLICATION_PATH) + "/" + FilenameUtils .getName(include.getPath()); LOG.warn("Copying {} to {}", include.getPath(), includeDir.getPath()); copy(resolver, include.getPath(), includeDir); resolver.commit(); final Session session = resolver.adaptTo(Session.class); replicator.replicate(session, ReplicationActionType.ACTIVATE, path); } resolver.delete(includeDir); resolver.commit(); eventManager.trigger(Event.AFTER_REPLICATE, script); }