@Override protected Resource getElement() { if (currentIterator == null) { currentIterator = resolver.findResources(query, "JCR-SQL2"); } if (currentIterator.hasNext()) { return currentIterator.next(); } else { return null; } } }
public Iterator<Resource> getResults() { String query = "SELECT * FROM [" + type + "] AS s WHERE CONTAINS(s.*, '" + term + "')"; if (StringUtils.isNotEmpty(path)) { query += " AND ISDESCENDANTNODE([" + path + "])"; } log.debug("Searching for content with {}", query); return request.getResourceResolver().findResources(query, Query.JCR_SQL2); } }
@Override public int doEndTag() { log.trace("doEndTag"); log.debug("Finding resources using query: {} of language {}", query, language); ResourceResolver resolver = getResourceResolver(); final Iterator<Resource> resources = resolver.findResources(query, language); log.debug("Saving resources to variable {}", var); pageContext.setAttribute(var, resources); return EVAL_PAGE; }
/** * Get the immediate resources under the blog path that relate to blog posts * e.g. [/content/blog/2014, /content/blog/2015, /content/blog/2016]. * * @return resources related to blog posts directly under the blog path */ public Iterator<Resource> getPosts() { return getResourceResolver().findResources("SELECT * FROM [nt:unstructured] WHERE ISCHILDNODE('" + PublickConstants.BLOG_PATH + "') AND NAME() <> 'jcr:content'", Query.JCR_SQL2); } }
/** * Get all Comments in the order of newest to oldest. * * @param request The current request * @return List of all comments */ public List<Resource> getComments(final SlingHttpServletRequest request) { final List<Resource> comments = new ArrayList<>(); final Iterator<Resource> queryResults = request.getResourceResolver().findResources(BLOG_QUERY, Query.JCR_SQL2); while (queryResults.hasNext()) { comments.add(queryResults.next()); } return comments; }
/** * Load aliases Search for all nodes inheriting the sling:alias * property */ private Map<String, Map<String, String>> loadAliases(final ResourceResolver resolver) { final Map<String, Map<String, String>> map = new ConcurrentHashMap<>(); final String queryString = "SELECT sling:alias FROM nt:base WHERE sling:alias IS NOT NULL"; final Iterator<Resource> i = resolver.findResources(queryString, "sql"); while (i.hasNext()) { final Resource resource = i.next(); loadAlias(resource, map); } return map; }
/** * Searches for resources using the given query formulated in the given * language. * * @param resourceResolver * the resource resolver to use to find resources with the specified * query * @param query * The query string to use to find the resources. * @param language * The language in which the query is formulated. * @return An Iterator of Resource objects matching the query. */ public static Iterator<Resource> findResources(ResourceResolver resourceResolver, String query, String language) { log.trace("findResources"); Iterator<Resource> resources = null; if (resourceResolver != null) { log.debug("Finding resources with query {} of type {}", query, language); resources = resourceResolver.findResources(query, language); } else { log.warn("Null resolver specified"); } return resources; }
/** * Wraps and returns the {@code Iterator} obtained by calling {@code findResources} on the wrapped resource resolver. * * @param query The query string to use to find the resources. * @param language The language in which the query is formulated. The * language should always be specified. However for * compatibility with older version, if no language * is specified, "xpath" is used. * @return a wrapped iterator obtained through the wrapped resource resolver */ @NotNull @Override public Iterator<Resource> findResources(@NotNull String query, String language) { return new ResourceIteratorWrapper(this, wrapped.findResources(query, language)); }
private static Set<String> getPathsFromQuery(ResourceResolver resourceResolver, String language, String query) { if (StringUtils.isBlank(query)) { return Collections.EMPTY_SET; } Set<String> paths = new HashSet<String>(); language = StringUtils.defaultIfEmpty(language, "xpath"); Iterator<Resource> resources = resourceResolver.findResources(query, language); while (resources.hasNext()) { paths.add(resources.next().getPath()); } return paths; }
private static Set<String> getPathsFromQuery(ResourceResolver resourceResolver, String language, String query) { if (StringUtils.isBlank(query)) { return Collections.emptySet(); } Set<String> paths = new HashSet<>(); language = StringUtils.defaultIfEmpty(language, "xpath"); Iterator<Resource> resources = resourceResolver.findResources(query, language); while (resources.hasNext()) { paths.add(resources.next().getPath()); } return paths; }
public static Set<Resource> flattenResourceTree(Resource root, boolean inclusive) { Iterator<Resource> typedResourceIterator = root.getResourceResolver().findResources(TYPED_COMPONENT_QUERY.replace("{path}", root.getPath()), Query.JCR_SQL2); Set<Resource> flattenedResourceTree = Sets.newHashSet(typedResourceIterator); if (inclusive) { flattenedResourceTree.add(root); } return flattenedResourceTree; }
@Override protected Iterator<Resource> computeOutput() throws Exception { String query = getExpr(); if (StringUtils.isNotBlank(query)){ logger.info("Executing query: {}", query); return resource.getResourceResolver().findResources(query, Query.XPATH); } return EMPTY_ITERATOR; } }
private void loadComponents() { Iterator<Resource> components = resolver .findResources("SELECT * FROM [sling:Component] WHERE [componentType] IS NOT NULL", Query.JCR_SQL2); componentCache = new HashMap<>(); while (components.hasNext()) { Resource cmpRsrc = components.next(); Component component = cmpRsrc.adaptTo(Component.class); if (component != null) { for (String type : component.getComponentType()) { if (!componentCache.containsKey(type)) { componentCache.put(type, new ArrayList<Component>()); } componentCache.get(type).add(component); } } } } }
protected Collection<PipeMonitor> getMonitoredPipes() { Collection<PipeMonitor> beans = new ArrayList<>(); if (serviceUser != null) { try (ResourceResolver resolver = factory.getServiceResourceResolver(serviceUser)) { for (Iterator<Resource> resourceIterator = resolver.findResources(MONITORED_PIPES_QUERY, Query.XPATH); resourceIterator.hasNext(); ) { beans.add(new PipeMonitor(this, getPipe(resourceIterator.next()))); } } catch (LoginException e) { log.error("unable to retrieve resolver for collecting exposed pipes", e); } catch (Exception e) { log.error("failed to execute the pipe", e); } } else { log.warn("no service user configured, pipes can't be monitored"); } return beans; } }
public Set<String> getKeys() { if (keys.isEmpty()) { Iterator<Resource> messageEntries = resource.getResourceResolver().findResources( "SELECT * FROM [sling:MessageEntry] AS s WHERE ISDESCENDANTNODE([" + resource.getPath() + "])", Query.JCR_SQL2); while (messageEntries.hasNext()) { Resource entry = messageEntries.next(); keys.add(entry.getValueMap().get("sling:key", String.class)); } } return keys; }
public void init() { log.debug("Finding references to {}", resource.getPath()); String query = "SELECT * FROM [nt:base] AS s WHERE NOT ISDESCENDANTNODE([/jcr:system/jcr:versionStorage]) AND CONTAINS(s.*, '" + resource.getPath() + "')"; Set<String> paths = new HashSet<>(); Iterator<Resource> resources = resource.getResourceResolver().findResources(query, Query.JCR_SQL2); log.debug("Checking for references with: {}", query); while (resources.hasNext()) { Resource r = resources.next(); if (!paths.contains(r.getPath())) { checkReferences(r); paths.add(r.getPath()); } } }
private Set<String> loadPotentialLanguageRoots(ResourceResolver resourceResolver, Locale locale, String baseName) { final String localeString = locale.toString(); final String localeStringLower = localeString.toLowerCase(); final String localeRFC4646String = toRFC4646String(locale); final String localeRFC4646StringLower = localeRFC4646String.toLowerCase(); final Set<String> paths = new LinkedHashSet<>(); final Iterator<Resource> bundles = resourceResolver.findResources(QUERY_LANGUAGE_ROOTS, "xpath"); while (bundles.hasNext()) { Resource bundle = bundles.next(); ValueMap properties = bundle.adaptTo(ValueMap.class); String language = properties.get(PROP_LANGUAGE, String.class); if (language != null && language.length() > 0) { if (language.equals(localeString) || language.equals(localeStringLower) || language.equals(localeRFC4646String) || language.equals(localeRFC4646StringLower)) { // basename might be a multivalue (see https://issues.apache.org/jira/browse/SLING-4547) String[] baseNames = properties.get(PROP_BASENAME, new String[]{}); if (baseName == null || Arrays.asList(baseNames).contains(baseName)) { paths.add(bundle.getPath()); } } } } return Collections.unmodifiableSet(paths); }
private void removeNodesFromDayFolder(Resource dayResource, Calendar until) throws PersistenceException { final ResourceResolver resolver = dayResource.getResourceResolver(); String oldActionsQuery = String.format(OLD_ACTIONS_QUERY, dayResource.getPath(), ISO8601.format(until)); Iterator<Resource> oldActions = resolver.findResources(oldActionsQuery, Query.JCR_SQL2); while (oldActions.hasNext()) { resolver.delete(oldActions.next()); } resolver.commit(); }
private List<MapEntry> gatherEntries(RedirectConfigModel config) { log.trace("gatherEntries"); log.debug("Getting all of the entries for {}", config.getResource()); List<MapEntry> entries = new ArrayList<>(); String pageQuery = "SELECT * FROM [cq:Page] WHERE [jcr:content/" + config.getProperty() + "] IS NOT NULL AND (ISDESCENDANTNODE([" + config.getPath() + "]) OR [jcr:path]='" + config.getPath() + "')"; log.debug("Finding pages with redirects with query: {}", pageQuery); entries.addAll(addItems(config, resourceResolver.findResources(pageQuery, Query.JCR_SQL2), ".html")); String assetQuery = "SELECT * FROM [dam:Asset] WHERE [jcr:content/" + config.getProperty() + "] IS NOT NULL AND (ISDESCENDANTNODE([" + config.getPath() + "]) OR [jcr:path]='" + config.getPath() + "')"; log.debug("Finding assets with redirects with query: {}", assetQuery); entries.addAll(addItems(config, resourceResolver.findResources(assetQuery, Query.JCR_SQL2), "")); return entries; }
@Override protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws ServletException, IOException { final ResourceResolver resolver = request.getResourceResolver(); final String vanityPath = request.getParameter("vanityPath"); final String pagePath = request.getParameter("pagePath"); log.debug("vanity path parameter passed is {}; page path parameter passed is {}", vanityPath, pagePath); response.setContentType("application/json"); response.setCharacterEncoding("UTF-8"); List<String> paths = new ArrayList<>(); if (StringUtils.isNotBlank(vanityPath)) { String xpath = "//element(*)[" + NameConstants.PN_SLING_VANITY_PATH + "='" + vanityPath + "']"; @SuppressWarnings("deprecation") Iterator<Resource> resources = resolver.findResources(xpath, Query.XPATH); while (resources.hasNext()) { Resource resource = resources.next(); String path = resource.getPath(); if (path.startsWith("/content") && !path.equals(pagePath)) { paths.add(path); } } } Gson gson = new Gson(); gson.toJson(paths, response.getWriter()); }