Sling Servlet Archives - Sourced Code

Handling Http Requests, HttpClient, in AEM

briankasingli — Sat, 24 Feb 2024 18:13:27 +0000

When integrating with external services or APIs from Adobe Experience Manager (AEM), utilizing the HttpClient for outbound HTTP requests is a common requirement. It’s crucial to handle these connections efficiently, securely, and in a way that is compatible with AEM’s architecture to ensure optimal performance and maintainability of your code.

AEM provides a specialized factory, HttpClientFactory, designed to streamline the creation and configuration of HttpClient instances. This factory not only simplifies the process of instantiating HttpClient objects but also ensures that the instances are optimized for use within the AEM environment.

By leveraging HttpClientFactory, developers can take advantage of built-in connection pooling and configuration optimizations that are specifically tailored for AEM applications. Furthermore, using AEM’s HttpClientFactory significantly facilitates the unit testing of code that makes HTTP requests, allowing for more maintainable and testable codebases.

Quick Links

1. Utilize AEM’s HttpClientFactory
1.1 OSGi Components & Sling Servlets
12 Sling Models & Workflows
2. Ensure Proper Resource Management
3. Configure HttpClient Securely
4. Reuse HttpClient Instances Wisely
5. Monitor and Log HttpClient Activity

1. Utilize AEM’s HttpClientFactory

Leverage AEM’s HttpClientFactory or the OSGi HttpClientBuilderFactory for creating instances of HttpClient. This ensures you benefit from connection pooling, proper configuration, and optimizations tailored for AEM. Avoid manually creating HttpClient instances as it bypasses these optimizations and can lead to resource leakage and scalability issues.

1.1 OSGi Components & Sling Servlets

OSGi Components: Custom services, event handlers, schedulers, and any other Java class defined as an OSGi component can use this code pattern below. OSGi components are the backbone for modular development in AEM, allowing for dynamic module management within the application.

Sling Servlets: Sling Servlets are another type of OSGi component that can use HttpClientBuilderFactory for making HTTP requests; using the code pattern below. Sling Servlets handle HTTP requests and can be used for various purposes, including interfacing with external systems.

1
2
3
4
5
6
7
8
9
10

@Reference
private HttpClientBuilderFactory httpClientBuilderFactory;

public void executeHttpRequest() {
try (CloseableHttpClient httpClient = httpClientBuilderFactory.newBuilder().build()) {
// Perform HTTP operations with httpClient
} catch (IOException e) {
// Handle exceptions
}
}

1.2 Sling Models & Workflows

Sling Models: While not typically using @Reference (as they are not OSGi components themselves), Sling Models can still access OSGi services like HttpClientBuilderFactory through the use of the @OSGiService annotation or by adapting from a Sling resource or request; using the code pattern below. This allows Sling Models to utilize services for fetching or sending data to external systems as part of their logic.

Workflows: Custom workflow steps can interact with OSGi services, including HttpClientBuilderFactory, to perform operations like sending data to external systems or integrating with RESTful services as part of the workflow process. These custom steps are developed as OSGi components and can use the @Reference annotation to inject necessary services.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Model(adaptables = Resource.class)
public class ExampleSlingModel {

@OSGiService
private HttpClientBuilderFactory httpClientBuilderFactory;

public void executeHttpRequest() {
try (CloseableHttpClient httpClient = httpClientBuilderFactory.newBuilder().build()) {
// Perform HTTP operations with httpClient
} catch (IOException e) {
// Handle exceptions
}
}
}

2. Ensure Proper Resource Management

Always close HttpClient, HttpResponse, and any InputStream or Entity objects to release system resources and avoid connection leaks. Utilize try-with-resources or finally blocks to ensure resources are closed even if exceptions occur.

1
2
3
4
5
6

try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
// Process the response
EntityUtils.consume(response.getEntity());
} catch (IOException e) {
// Handle exceptions
}

3. Configure HttpClient Securely

Pay attention to security configurations when setting up your HttpClient. This includes setting up SSL context correctly, enabling hostname verification, and configuring timeouts to prevent attacks that target resource consumption. Avoid disabling SSL verification or other security features unless absolutely necessary and understood.

1
2
3
4
5
6
7
8
9
10
11

RequestConfig requestConfig = RequestConfig.custom()
.setConnectTimeout(5000)
.setSocketTimeout(5000)
.build();
try (CloseableHttpClient httpClient = httpClientBuilderFactory.newBuilder()
.setDefaultRequestConfig(requestConfig)
.build()) {
// Securely configured HttpClient
} catch (IOException e) {
// Handle exceptions
}

4. Reuse HttpClient Instances Wisely

For efficiency, reuse HttpClient instances across requests whenever possible. This approach benefits from the HTTP connection pooling managed by AEM, reducing the overhead of establishing connections for each request. However, ensure that any client-specific configurations do not unintentionally affect subsequent requests.

5. Monitor and Log HttpClient Activity

Implement logging and monitoring around your HTTP requests to diagnose issues, track performance, and understand dependencies on external services. Use AEM’s logging capabilities to log request details, response times, and errors. This can aid in troubleshooting and optimizing the use of HttpClient in your application.

1
2
3
4
5
6

try (CloseableHttpResponse response = httpClient.execute(httpGet)) {
// Log the status line
LOG.debug("HTTP response status: {}", response.getStatusLine());
} catch (IOException e) {
LOG.error("HTTP request execution failed", e);
}

By adhering to these five rules, developers can ensure their AEM projects make the most out of HttpClient for external communications, balancing efficiency with robust security practices. Utilizing AEM’s HttpClientFactory not only streamlines the development process but also enhances the ease of unit testing, making it an indispensable practice for AEM development.

The post Handling Http Requests, HttpClient, in AEM appeared first on Sourced Code.

Benefits of SlingSafeMethodsServlet with Code Examples

briankasingli — Sat, 02 Dec 2023 19:34:29 +0000

A robust security strategy is pivotal to safeguarding applications. As an AEM developer, we must really understand the SlingSafeMethodsServlet, an invaluable feature within the Apache Sling framework. This article explores the core concepts, practical benefits, and the heightened security it brings to servlet development.

The org.apache.sling.api.servlets.SlingSafeMethodsServlet is an extension of the trusted HttpServlet in Apache Sling, introduces a focused approach to reinforcing security by limiting HTTP methods to read-only operations. This deep dive into its functionality unveils the foundation upon which secure servlets can be built.

Quick Links

Advantages of SlingSafeMethodsServlet
SlingSafeMethodsServlet in Action: Example Use Case

Advantages of SlingSafeMethodsServlet

Read-Only Operations:

At its core, SlingSafeMethodsServlet champions a read-only paradigm. This deliberate limitation ensures that servlets exclusively respond to safe HTTP methods, fortifying applications against unintentional data modifications.
Guard Against CSRF Attacks:

By constraining actions to safe methods, SlingSafeMethodsServlet provides an inherent defense against Cross-Site Request Forgery (CSRF) attacks. This proactive measure significantly reduces the risk of unauthorized manipulations.
Built-In Support for Idempotent Methods:

The servlet seamlessly integrates with idempotent methods like GET and HEAD, aligning with industry best practices. This default behavior enhances the predictability and reliability of request handling.
Resource-Based Permissions:

Leveraging Sling’s resource resolution capabilities, SlingSafeMethodsServlet dynamically inherits permissions tied to resolved resources. This ensures a granular and secure access control model.

SlingSafeMethodsServlet in Action: Example Use Case

In this practical example, the ContentDisplayServlet:line17 showcases the seamless integration of SlingSafeMethodsServlet. The provided code exemplifies its application in retrieving and securely rendering content, encapsulating the essence of secure servlet development.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingSafeMethodsServlet;
import org.osgi.service.component.annotations.Component;
import org.json.JSONObject;

import javax.servlet.ServletException;
import java.io.IOException;

@Component(
service = {javax.servlet.Servlet.class},
property = {
"sling.servlet.resourceTypes=yourapp/components/content",
"sling.servlet.methods=GET"
}
)
public class ContentDisplayServlet extends SlingSafeMethodsServlet {

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws ServletException, IOException {
// Fetch and render content
// ...

// Send JSON response
JSONObject jsonResponse = new JSONObject();
jsonResponse.put("success", true);

response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");
response.getWriter().write(jsonResponse.toString());
}
}

The post Benefits of SlingSafeMethodsServlet with Code Examples appeared first on Sourced Code.

AEM Convert Excel to JSON Simple Servlet Example

briankasingli — Thu, 02 Nov 2023 01:28:53 +0000

In this article, I present a straightforward yet powerful solution that demonstrates how to seamlessly convert Excel data into JSON format using Adobe Experience Manager (AEM). By implementing a custom servlet, I will illustrate the process of converting an Excel sheet named ‘example.xlsx’ into structured JSON data; it can be downloaded below for you following this tutorial. This tutorial is validated on both AEM 6.5 with the latest Service Pack and AEM as a Cloud Service (AEMaaCS), ensuring its compatibility with diverse AEM environments.

Resource File:
example.xlsx

Request URI:
The request URI for accessing the JSON output through the ExampleServlet that we’ve been discussing would typically look like this:

1	http://localhost:4502/bin/exportexcelfortext.json

JSON Output:

1
2
3
4
5
6
7
8

{
"people": [
{ "name": "Brian", "age": "100" },
{ "name": "Doris", "age": "20" },
{ "name": "Stuart", "age": "103" },
{ "name": "David", "age": "5" }
]
}

Servlet Implementation ExcelExampleServlet.java:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

package com.sourcedcode.core.servlets;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.servlets.SlingSafeMethodsServlet;
import org.osgi.service.component.annotations.Component;
import javax.servlet.Servlet;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import com.day.cq.dam.api.Asset;

@Component(
service = { Servlet.class },
property = {
"sling.servlet.paths=/bin/exportexcelfortext",
"sling.servlet.extensions=json",
"sling.servlet.methods=GET"
}
)
public class ExcelExampleServlet extends SlingSafeMethodsServlet {
@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws IOException {
try {
// Get the Excel file path in DAM
String excelFilePath = "/content/dam/example/example.xlsx";

// Get the resource resolver
ResourceResolver resourceResolver = request.getResourceResolver();

// Check if the Excel file exists
Resource excelResource = resourceResolver.getResource(excelFilePath);
if (excelResource == null) {
response.setStatus(HttpServletResponse.SC_NOT_FOUND);
return;
}

// Adapt the resource to an Asset
Asset asset = Objects.requireNonNull(excelResource).adaptTo(Asset.class);
if (asset == null) {
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
return;
}

// Get an InputStream from the Asset's original
InputStream excelInputStream = Objects.requireNonNull(asset).getOriginal().getStream();

// Process the Excel content and convert it to JSON
Workbook workbook = new XSSFWorkbook(excelInputStream);
List<Map<String, String>> jsonData = new ArrayList<>();

// Iterate through the Excel rows and columns
Sheet sheet = workbook.getSheetAt(0); // Assuming it's the first sheet
Row headerRow = sheet.getRow(0); // Assuming the first row is the header row
int totalColumns = headerRow.getLastCellNum();

for (int i = 1; i < sheet.getPhysicalNumberOfRows(); i++) {
Row dataRow = sheet.getRow(i);
Map<String, String> rowMap = new LinkedHashMap<>();

for (int j = 0; j < totalColumns; j++) {
Cell headerCell = headerRow.getCell(j);
Cell dataCell = dataRow.getCell(j);

if (headerCell != null && dataCell != null) {
// Check the cell type to handle numeric and string values
if (dataCell.getCellType() == CellType.STRING) {
rowMap.put(headerCell.getStringCellValue(), dataCell.getStringCellValue());
} else if (dataCell.getCellType() == CellType.NUMERIC) {
// Handle numeric values as integers (remove decimals)
int age = (int) dataCell.getNumericCellValue();
rowMap.put(headerCell.getStringCellValue(), String.valueOf(age));
}
}
}

jsonData.add(rowMap);
}

// Prepare the JSON response
List<Map<String, String>> peopleList = new ArrayList<>();
for (Map<String, String> personData : jsonData) {
Map<String, String> person = new LinkedHashMap<>();
person.put("name", personData.get("Name"));
person.put("age", personData.get("Age"));
peopleList.add(person);
}

Map<String, List<Map<String, String>>> jsonResponse = new LinkedHashMap<>();
jsonResponse.put("people", peopleList);

// Set response content type and write JSON content to the response
response.setContentType("application/json");
response.getWriter().write(new ObjectMapper().writeValueAsString(jsonResponse));
} catch (Exception e) {
response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
}
}
}

Servlet Depdendencies:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<dependencies>

<dependency>
<groupId>org.apache.poigroupId>
<artifactId>poiartifactId>
<version>5.2.3version>
dependency>
<dependency>
<groupId>org.apache.poigroupId>
<artifactId>poi-ooxmlartifactId>
<version>5.2.3version>
dependency>

<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-coreartifactId>
<version>2.13.0version>
dependency>
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
<version>2.13.0version>
dependency>
dependencies>

The post AEM Convert Excel to JSON Simple Servlet Example appeared first on Sourced Code.

JCR SQL2 ISDESCENDANTNODE Multiple Paths Example

briankasingli — Wed, 18 Oct 2023 02:01:56 +0000

While working with the JCR SQL2 Queries, you may encounter scenarios where content is distributed across various branches of the repository. Querying these branches efficiently is key to implement features to capture requirements. In this article, we will focus o how to collect and query for distributed across various branches of the repository. Using the ISDESCENDANTNODE feature of the JCR SQL Query proves it possible.

Understanding ISDESCENDANTNODE

ISDESCENDANTNODE is a condition in JCR SQL2 that checks if a node is a descendant of another, based on their paths. It is particularly beneficial for querying content hierarchies. Imagine you have content in different branches (content tree) of your AEM repository. You want to search across these branches simultaneously, without running separate queries. This is where ISDESCENDANTNODE shines.

By specifying multiple paths within the ISDESCENDANTNODE condition, you can search for content across these paths concurrently, streamlining your queries. This powerful feature simplifies and optimizes the content retrieval process in AEM.

Finding all cq:Pages under 1 path
with the jcr:content/jcr:title CONTAINS %terms%

1
2
3

SELECT * FROM [cq:Page]
WHERE ISDESCENDANTNODE('/content/sourcedcode/us/')
AND CONTAINS([jcr:content/jcr:title], 'terms')

Finding all cq:Pages under 2 paths
with the jcr:content/jcr:title CONTAINS %terms%

1
2
3
4

SELECT * FROM [cq:Page]
WHERE (ISDESCENDANTNODE('/content/sourcedcode/us/')
OR ISDESCENDANTNODE('/content/sourcedcode/ca/')
AND CONTAINS([jcr:content/jcr:title], 'terms')

Finding all cq:Pages under 3 paths
with the jcr:content/jcr:title CONTAINS %terms%

1
2
3
4
5

SELECT * FROM [cq:Page]
WHERE (ISDESCENDANTNODE('/content/sourcedcode/us/')
OR ISDESCENDANTNODE('/content/sourcedcode/ca/')
OR ISDESCENDANTNODE('/content/sourcedcode/pl/'))
AND CONTAINS([jcr:content/jcr:title], 'terms')

The post JCR SQL2 ISDESCENDANTNODE Multiple Paths Example appeared first on Sourced Code.

Retrieving the Current Page in an AEM Servlet via ResourceType

briankasingli — Wed, 06 Sep 2023 03:48:43 +0000

In the context of “Retrieving the Current Page in an AEM Servlet via ResourceType”, it is great to understand how this is done. This guide provides a simplified walkthrough on how you can adeptly achieve this. In the code example, we will associating the servlet with a resourceType.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package com.example.aem.servlets;

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingAllMethodsServlet;
import org.apache.sling.models.annotations.injectorspecific.Self;
import org.osgi.service.component.annotations.Component;
import org.apache.sling.api.resource.ResourceResolver;
import com.day.cq.wcm.api.Page;
import com.day.cq.wcm.api.PageManager;

import javax.servlet.Servlet;
import java.io.IOException;
import java.util.Optional;

@Component(service = Servlet.class)
@SlingServletResourceTypes(
resourceTypes="example/components/content/mycomponent",
methods="GET",
extensions="html"
)
public class ResourceTypeServlet extends SlingAllMethodsServlet {

@Self
private SlingHttpServletRequest request;

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws IOException {
Page currentPage = Optional.ofNullable(request.getResourceResolver().adaptTo(PageManager.class))
.map(pm -> pm.getContainingPage(request.getResource()))
.orElse(null);

if(currentPage != null) {
response.getWriter().write("Gotcha! Current page is: " + currentPage.getPath());
} else {
response.getWriter().write("Oops, couldn't find the current page.");
}
}
}

Understanding the AEM Code Snippet

1. request.getResourceResolver().adaptTo(PageManager.class):

request.getResourceResolver(): This fetches a ResourceResolver from the servlet’s request. A ResourceResolver in AEM assists in translating resource paths to actual resources.

.adaptTo(PageManager.class): This method tries to adapt or convert the ResourceResolver into another type, specifically a PageManager. The PageManager in AEM offers utilities for working with pages, such as fetching, creating, or deleting pages.

2. Optional.ofNullable(…)

This wraps the value returned by the preceding code (which might be a PageManager object or null if the adaptation failed) within an Optional object. Optional is a container that may or may not contain a value.

3. .map(pm -> pm.getContainingPage(request.getResource()))

If the Optional contains a non-null PageManager value, the .map method applies the given function to it. Here, it uses the PageManager (denoted as pm in the lambda) to retrieve the containing page of the present resource.

pm.getContainingPage(request.getResource()): This extracts the AEM Page that encompasses the current resource.

4. .orElse(null)

Lastly, if any prior steps don’t succeed (i.e., if the adaptation to PageManager was unsuccessful or if no containing page for the resource exists), the orElse method ensures currentPage is set to null.

The post Retrieving the Current Page in an AEM Servlet via ResourceType appeared first on Sourced Code.

AEM Sling Servlet: resourceTypes for POST & GET Code Example Code

briankasingli — Mon, 28 Aug 2023 06:37:48 +0000

When working with Sling Servlets in AEM, the choice between using a resource type or a sling path as the basis for your servlet’s operation is crucial. This article delves into the benefits of utilizing resource types and provides practical examples of how resource types can streamline your development process for both POST and GET templates.

Resource Type vs. Sling Path

The decision between using a resource type and a sling path as the foundation of your servlet’s functionality can significantly impact your development approach. A resource type is a more flexible and future-proof choice due to its abstraction from specific URLs. Resource types abstract the underlying storage structure, enabling your servlets to work consistently even if the content hierarchy changes. On the other hand, relying on sling paths can lead to brittle implementations, as they are tied to specific URLs that might change over time.

Advantages of Resource Types

Abstraction: Resource types provide an abstraction layer, separating the servlet’s logic from the actual URL structure. This ensures that your servlet remains functional even when the content structure evolves.
Adaptability: With resource types, your servlet can adapt to different parts of the content hierarchy without requiring modifications. This adaptability becomes crucial in scenarios where content structures are reorganized or repurposed.
Consistency: By using resource types, you promote consistency in your application. Different components or pages with the same resource type can share the same servlet logic, enhancing maintainability.

Caveats when using @SlingServletPaths

Path-bound servlets cannot be access-controlled using the default JCR repository ACLs.
Path-bound servlets can only be registered to a path and not a resource type (i.e. no suffix handling).
If a path-bound servlet is not active, e.g. if the bundle is missing or not started, a POST might result in unexpected results. usually creating a node at /bin/xyz which subsequently overlays the servlets path binding. The mapping is not transparent to a developer looking just at the repository.

POST Template using Resource Type

Consider a scenario where you want to handle form submissions via a POST request for multiple types of components. By utilizing resource types, you can create a centralized servlet that handles these submissions consistently, regardless of the content’s location.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

@Component(
service = { Servlet.class },
property = {
"sling.servlet.resourceTypes=yourapp/components/form",
"sling.servlet.methods=POST"
}
)
public class FormSubmitServlet extends SlingAllMethodsServlet {
@Override
protected void doPost(SlingHttpServletRequest request, SlingHttpServletResponse response) throws ServletException, IOException {
// Process form submission
// ...

// Send JSON response
JSONObject jsonResponse = new JSONObject();
jsonResponse.put("success", true);
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");
response.getWriter().write(jsonResponse.toString());
}
}

GET Template using Resource Type

Imagine you need to retrieve data from different types of resources, such as articles and videos, and display them using a single servlet. Utilizing resource types allows you to create a unified servlet to serve diverse content.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

@Component(
service = { Servlet.class },
property = {
"sling.servlet.resourceTypes=yourapp/components/content",
"sling.servlet.methods=GET"
}
)
public class ContentDisplayServlet extends SlingSafeMethodsServlet {
@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws ServletException, IOException {
// Fetch and render content
// ...

// Send JSON response
JSONObject jsonResponse = new JSONObject();
jsonResponse.put("success", true);
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");
response.getWriter().write(jsonResponse.toString());
}
}

Conclusion

Resource types stand as a powerful tool in AEM’s arsenal, offering a versatile and robust approach to developing Sling Servlets for both POST and GET templates. By abstracting the underlying URL structure, resource types enable consistent servlet behavior across different content hierarchies. This approach enhances code maintainability, adaptability, and future-proofing. In contrast, sling paths can result in rigid implementations tied to specific URLs. By embracing resource types, developers can create more flexible, reliable, and adaptable solutions in Adobe Experience Manager.

The post AEM Sling Servlet: resourceTypes for POST & GET Code Example Code appeared first on Sourced Code.

AEM JCR SQL2 Full Text Search Case Insensitive

briankasingli — Mon, 28 Aug 2023 06:06:51 +0000

One of the key features of AEM is its support for searching and querying content stored in its Java Content Repository (JCR). In this article, we will explore how to perform a case-insensitive full-text search using the JCR_SQL2 query language in AEM and provide a practical example of achieving this through a servlet.

Performing Case-Insensitive Full Text Search

A case-insensitive full-text search is a common requirement when you want to retrieve content regardless of the letter casing used in the search query. In AEM, the JCR_SQL2 query language is used to interact with the JCR repository. To perform a case-insensitive full-text search, you can utilize theLOWER()function to convert both the search query and the content being searched to lowercase. This ensures that the search is not case-sensitive.

Example Query Code

Consider a scenario where you want to search for assets that are descendants of a specific path and meet certain criteria, while also performing a case-insensitive search for specific keywords. Below is an example of a JCR_SQL2 query code block that achieves this:

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingAllMethodsServlet;
import org.json.JSONArray;
import org.json.JSONObject;

import javax.servlet.Servlet;
import java.io.IOException;
import javax.jcr.query.Query;
import javax.jcr.Session;
import javax.jcr.Node;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;
import javax.jcr.query.RowIterator;

@Component(
service = { Servlet.class },
property = {
"sling.servlet.methods=GET",
"sling.servlet.paths=/bin/mysearchservlet"
}
)
public class MySearchServlet extends SlingAllMethodsServlet {

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws IOException {
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");

// Retrieve the search query parameter
String queryParameter = request.getParameter("query");

// Validate if the query parameter is not null or empty
if (queryParameter == null || queryParameter.isEmpty()) {
JSONObject errorResponse = new JSONObject();
errorResponse.put("error", "Missing query parameter");
response.getWriter().write(errorResponse.toString());
return;
}

// Retrieve the JCR session
Session session = request.getResourceResolver().adaptTo(Session.class);

try {
// Define your query
String queryString = "SELECT * FROM [cq:Page] AS page " +
"WHERE ISDESCENDANTNODE(page, '/content/myproject')" +
" AND (" +
" LOWER(page.[jcr:content/jcr:title]) LIKE '%" + queryParameter + "%'" +
" OR LOWER(page.[jcr:content/cq:template]) LIKE '%" + queryParameter + "%'" +
" OR LOWER(page.[jcr:content/jcr:description]) LIKE '%" + queryParameter + "%'" +
" )" +
"ORDER BY [jcr:score] DESC";

// Get the QueryManager and create the query
QueryManager queryManager = session.getWorkspace().getQueryManager();
Query query = queryManager.createQuery(queryString, Query.JCR_SQL2);

// Execute the query
QueryResult result = query.execute();

// Process the results and build JSON response
JSONArray resultsArray = new JSONArray();
RowIterator rows = result.getRows();
while (rows.hasNext()) {
Node pageNode = rows.nextRow().getNode("page");
JSONObject pageData = new JSONObject();
pageData.put("title", pageNode.getProperty("jcr:content/jcr:title").getString());
pageData.put("template", pageNode.getProperty("jcr:content/cq:template").getString());
pageData.put("description", pageNode.getProperty("jcr:content/jcr:description").getString());
resultsArray.put(pageData);
}

// Respond with JSON search results
response.getWriter().write(resultsArray.toString());
} catch (Exception e) {
JSONObject errorResponse = new JSONObject();
errorResponse.put("error", e.getMessage());
response.getWriter().write(errorResponse.toString());
return;
} finally {
// Close the JCR session
session.logout();
}
}
}

Example Try Catch

When utilizing service users in Java, it’s essential to incorporate try-catch blocks for exception handling. Java introduced enhanced try-catch blocks, which allow you to catch multiple exceptions using a single catch block, in version 7. Before Java 7, try-catch blocks could only handle one exception type per catch block. With the improvements in Java 7, developers gained the ability to efficiently catch and manage various types of exceptions within a structured framework. These enhanced try-catch blocks serve as a powerful means of error management, preventing application crashes, facilitating user-friendly error messages, assisting in the debugging process, and bolstering overall code reliability.

Moreover, when working with service users, it’s important to remember that the JCR session should always be properly closed. Failing to close the session can lead to lingering threads and resource leaks. Incorporating try-with-resources or explicit session closure ensures that resources are released and system resources are utilized optimally. This practice contributes to maintaining the stability and efficiency of your application.

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingAllMethodsServlet;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceResolverFactory;
import org.json.JSONArray;
import org.json.JSONObject;

import javax.servlet.Servlet;
import java.io.IOException;
import java.util.Collections;
import java.util.Map;

@Component(
service = { Servlet.class },
property = {
"sling.servlet.methods=GET",
"sling.servlet.paths=/bin/mysearchservlet"
}
)
public class MySearchServlet extends SlingAllMethodsServlet {

@Reference
private ResourceResolverFactory resolverFactory;

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws IOException {
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");

// Retrieve the search query parameter
String queryParameter = request.getParameter("query");

// Validate if the query parameter is not null or empty
if (queryParameter == null || queryParameter.isEmpty()) {
JSONObject errorResponse = new JSONObject();
errorResponse.put("error", "Missing query parameter");
response.getWriter().write(errorResponse.toString());
return;
}

final Map<String, Object> authInfo = Collections.singletonMap(
ResourceResolverFactory.SUBSERVICE,
"sourcedCodeSystemUser");

try (ResourceResolver resourceResolver = resolverFactory.getServiceResourceResolver(authInfo)) {
// Define your query
String queryString = "SELECT * FROM [cq:Page] AS page " +
"WHERE ISDESCENDANTNODE(page, '/content/myproject')" +
" AND (" +
" LOWER(page.[jcr:content/jcr:title]) LIKE '%" + queryParameter + "%'" +
" OR LOWER(page.[jcr:content/cq:template]) LIKE '%" + queryParameter + "%'" +
" OR LOWER(page.[jcr:content/jcr:description]) LIKE '%" + queryParameter + "%'" +
" )" +
"ORDER BY [jcr:score] DESC";

// Get the QueryManager and create the query
QueryManager queryManager = resourceResolver.adaptTo(QueryManager.class);
Query query = queryManager.createQuery(queryString, Query.JCR_SQL2);

// Execute the query
QueryResult result = query.execute();

// Process the results and build JSON response
JSONArray resultsArray = new JSONArray();
RowIterator rows = result.getRows();
while (rows.hasNext()) {
Node pageNode = rows.nextRow().getNode("page");
JSONObject pageData = new JSONObject();
pageData.put("title", pageNode.getProperty("jcr:content/jcr:title").getString());
pageData.put("template", pageNode.getProperty("jcr:content/cq:template").getString());
pageData.put("description", pageNode.getProperty("jcr:content/jcr:description").getString());
resultsArray.put(pageData);
}

// Respond with JSON search results
response.getWriter().write(resultsArray.toString());
} catch (Exception e) {
JSONObject errorResponse = new JSONObject();
errorResponse.put("error", "An error occurred while processing the request.");
response.getWriter().write(errorResponse.toString());
return;
}
}
}

Curl Example:

1	curl "http://localhost:4502/bin/mysearchservlet?query=my_search_keyword"

Output:

1
2
3
4
5
6
7
8
9
10
11
12

[
{
"title": "Page Title 1",
"template": "/conf/phonak/settings/wcm/templates/mytemplate",
"description": "This is the description of Page 1"
},
{
"title": "Page Title 2",
"template": "/conf/phonak/settings/wcm/templates/anothertemplate",
"description": "Description for Page 2"
}
]

In this example, theLOWER()function is applied to both the properties being searched and the search queryfulltext This ensures that the search is case-insensitive, allowing you to retrieve relevant assets regardless of letter casing.

Practical Example: Implementing the Search in a Servlet

To practically implement the above query within a servlet in AEM, you would typically perform the following steps:

Create a Java servlet that extendsSlingAllMethodsServletor implementsSlingServlet

In the servlet’sdoGetordoPostmethod, create an instance of theQueryManagerto execute the JCR_SQL2 query.

Use the query string from the example above, replacing placeholders likeproductCFsRootPathandfulltextwith actual values.

Process the query result, extract the relevant data, and respond to the client with the search results.

Conclusion

Performing a case-insensitive full-text search using the JCR_SQL2 query language in Adobe Experience Manager allows you to provide a seamless search experience for users regardless of their choice of letter casing. By utilizing theLOWER()function, you can effectively eliminate case sensitivity from your search queries and retrieve the most relevant content. Incorporating this technique into your AEM projects can enhance user experience and ensure that content discovery is efficient and user-friendly.

The post AEM JCR SQL2 Full Text Search Case Insensitive appeared first on Sourced Code.

How to access Design Dialogue Properties in Sling Model

briankasingli — Fri, 25 Aug 2023 21:37:11 +0000

Design Dialogs are especially useful for creating components that need to be easily configurable through editable template and policies without directly editing the underlying code. They enable a clear separation between content and presentation, allowing content authors to make changes without needing technical expertise. Design Dialogs are defined using the AEM Touch UI Dialog, which is an integral part of the component development process.

In this article we will talk through how to access the design dialogue settings that is configured in editable template policies within Sling Models. This article will be a quick reference, which means we will provide you code examples for the solution.

1. Example _cq_design_dialog.xml configuration

This is a snippet that resides in /apps/core/wcm/components/title/v1/title/_cq_design_dialog.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

<advancedSettings
jcr:primaryType="nt:unstructured"
jcr:title="Advanced Settings"
sling:resourceType="granite/ui/components/coral/foundation/container"
margin="{Boolean}true">
<items jcr:primaryType="nt:unstructured">
<renderLayoutAs
jcr:primaryType="nt:unstructured"
sling:resourceType="granite/ui/components/coral/foundation/form/select"
fieldDescription="Forcing the component to render column layouts as"
fieldLabel="Render Layout As"
name="./renderLayoutAs">
<items jcr:primaryType="nt:unstructured">
<oneColumn
jcr:primaryType="nt:unstructured"
text="Default (One Column)"
selected="{Boolean}true"
value="oneColumn"/>
<twoColumns
jcr:primaryType="nt:unstructured"
text="Two Columns"
selected="{Boolean}true"
value="twoColumns"/>
<threeColumns
jcr:primaryType="nt:unstructured"
text="Three Columns"
value="threeColumns"/>
<fourColumns
jcr:primaryType="nt:unstructured"
text="Four Columns"
value="fourColumns"/>
items>
renderLayoutAs>
items>
advancedSettings>

2. Accessing Design Dialog Properties in Sling Models:

In AEM, Sling Models provide a way to map resource properties to Java objects, making it easier to work with the content of a page. To access Design Dialog properties within a Sling Model, take a look at the example code below.

Take notice, in line:17, we are using Sling Model Specific Annotations, @ScriptVariable, to initiate the currentStyle object. In line:22, we are calling the get method() which is a public method, which here we will attempt to find configuration set via design dialog “renderLayoutAs”. If “renderLayoutAs” is not configured, then String renderLayoutAs == null. Finally in line:24, we will use a switch statement to execute code based on what is configured.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package com.sourcedcode.core.internal.components;

import com.day.cq.wcm.api.designer.Style;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.models.annotations.Model;

import javax.annotation.PostConstruct;
import javax.inject.Inject;

import static org.apache.commons.lang3.StringUtils.isNotEmpty;

@Model(adaptables = SlingHttpServletRequest.class)
public class LayoutColumn {

private static final String RENDER_LAYOUT_AS_PROP = "renderLayoutAs";

@ScriptVariable
private Style currentStyle;

@PostConstruct
public void init() {
String renderLayoutAs = currentStyle.get(RENDER_LAYOUT_AS_PROP, String.class);
if (isNotEmpty(renderLayoutAs)) {
switch (renderLayoutAs) {
case "oneColumn":
break;
case "twoColumns":
break;
case "threeColumns":
break;
case "fourColumns":
break;
default:
System.out.println("Default case");
break;
}
}
}
}

The post How to access Design Dialogue Properties in Sling Model appeared first on Sourced Code.

Send Out Emails with AEM Servlet

briankasingli — Fri, 21 Jan 2022 03:31:31 +0000

In this article, we will be setting up the local AEM author developer’s environment to send out an email utilizing the Day CQ Mail Service. This article includes code snippets to a Sling Servlet that will be used to send out the email.

We will be using a Google Gmail account as the SMTP Mail Server in this article. To learn how to set up your Google Gmail account as the SMTP server, click here.

1. Configure the Day CQ Mail Service

a. Visit http://localhost:4502/system/console/configMgr/com.day.cq.mailer.DefaultMailService

b. Include the configurations below:
Google SMTP Configurations
SMTP server hostname: smtp.gmail.com
SMTP server port: 465, 25 or 587 (test in that order)
SMTP user: @@YOUR_EMAIL_ADDRESS@@
SMTP from emai: @@YOUR_EMAIL_ADDRESS@@
SMTP password: @@YOUR_PASSWORD@@
SMTP TLS/SSL: true

To automate this configuration, you can run a Curl command like the example below. But please be aware, you must use your own Google Gmail account.

To update the Curl command below, use this tool here, Tool: Generate Curl Command to Update OSGI Configurations

curl -u admin:admin 'http://localhost:4502/system/console/configMgr/com.day.cq.mailer.DefaultMailService' --data-raw 'apply=true&action=ajaxConfigManager&%24location=&smtp.host=smtp.gmail.com&smtp.port=587&smtp.user=contact@sourcedcode.com&smtp.password=p4ssw0rd&from.address=contact@sourcedcode.com&smtp.ssl=true&propertylist=smtp.host%2Csmtp.port%2Csmtp.user%2Csmtp.password%2Cfrom.address%2Csmtp.ssl'

2. Create the SendEmailServletExample AEM Servlet

Create a Java class named, SendEmailServletExample.java, copy and paste the code below, replace line:44 with your own email, and then use your Java Maven skills to build the servlet in AEM.

Once when the SendEmailServletExample.java is built into AEM, visit http://localhost:4502/bin/sendemail,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

package com.sourcedcode.core.servlet;

import com.day.cq.mailer.MessageGateway;
import com.day.cq.mailer.MessageGatewayService;
import org.apache.commons.mail.Email;
import org.apache.commons.mail.EmailException;
import org.apache.commons.mail.HtmlEmail;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingAllMethodsServlet;
import org.json.JSONException;
import org.json.JSONObject;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Reference;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.Servlet;
import java.io.IOException;

import static org.apache.sling.api.servlets.ServletResolverConstants.SLING_SERVLET_PATHS;

@Component(
service = { Servlet.class },
property = {
SLING_SERVLET_PATHS + "=/bin/sendemail"
}
)
public class SendEmailServletExample extends SlingAllMethodsServlet {

private static Logger log = LoggerFactory.getLogger(SendEmailServletExample.class);

@Reference
private MessageGatewayService messageGatewayService;

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response) throws IOException {
JSONObject jsonResponse = new JSONObject();
boolean sent = false;
try {
String[] recipients = { "contact@sourcedcode.com" };
sendEmail("This is an test email",
"This is the email body", recipients);
response.setStatus(200);
sent = true;
} catch (EmailException e) {
response.setStatus(500);
}
try {
jsonResponse.put("result", sent ? "done" : "something went wrong");
} catch (JSONException e) {
e.printStackTrace();
}
response.getWriter().write(jsonResponse.toString());
}

private void sendEmail(String subjectLine, String msgBody, String[] recipients) throws EmailException {
Email email = new HtmlEmail();
for (String recipient : recipients) {
email.addTo(recipient, recipient);
}
email.setSubject(subjectLine);
email.setMsg(msgBody);
MessageGateway<Email> messageGateway = messageGatewayService.getGateway(HtmlEmail.class);
if (messageGateway != null) {
log.debug("sending out email");
messageGateway.send((Email) email);
} else {
log.error("The message gateway could not be retrieved.");
}
}
}

The post Send Out Emails with AEM Servlet appeared first on Sourced Code.

How to use AEM JCR SQL2 query strings to query for nodes in Java Content Repository

briankasingli — Mon, 02 Apr 2018 19:31:06 +0000

JCR-SQL2 (Java Content Repository – Structured Query Language 2) is domain specific language used to query JCR nodes held in the JCR repository. The syntax for JCR-SQL2 is fairly similar to SQL, so if you have some experience with SQL, this tutorial will be a walk in the park for you.

The best way to learn the power of the JCR-SQL2 language is to try it out on CRX/DE Lite. Without future or do, below will be a lesson on JCR-SQL2. To locate CRX/DE Lite’s query tool, visit http://localhost:4502/crx/de/index.jsp, then select on the tools drop down, and choose query.

2023 Added Section: SQL-JCR2 Snippets

Examples can be found at the bottom of this tutorial, JCR-SQL2 Code Snippets Cheat Sheet, where you can find some examples for real life use cases. Head into your crx-de > tools > query > type:JCR SQL2, and try it our yourself.

JCR-SQL2 Syntax

SELECT Statement
NAME() Statement
ISDESCENDANTNODE Statement
CONTAINS Statement
LIKE Operator
IS NOT NULL Property
ORDER BY Keyword
CAST() Statement
JCR-SQL2 Code Snippets Cheat Sheet (new 2023)
JCR SQL2 Java Code Example Servlet (new 2023)

1. The JCR-SQL2 SELECT Statement

The SELECT statement is used to select all JCR nodes that matches the JCR node’s primary type.
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5
6
7
8
9

-- nt:base is a primary type that represents every single node in the JCR.
-- returns all nodes in the JCR.
SELECT * FROM [nt:base]

-- returns all [cq:Page] nodes
SELECT * FROM [cq:Page]

-- returns all [dam:Asset] nodes
SELECT * FROM [dam:Asset]

2. The JCR-SQL2 NAME() Statement

Selecting nodes with a specific node name.
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5

-- returns all [cq:Page] nodes WHERE the node's name is equal to "we-retail"
SELECT * FROM [cq:Page] AS nodes WHERE NAME(nodes) = "we-retail"

-- returns all [dam:Asset] nodes WHERE the node's name is equal to "we-retail"
SELECT * FROM [dam:Asset] AS nodes WHERE NAME(nodes) = "we-retail"

3. The JCR-SQL2 ISDESCENDANTNODE Statement

Selecting nodes under a file path.
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5
6
7
8
9
10
11

-- returns all nodes WHERE nodes exist under "/content/we-retail"
select * FROM [nt:base] WHERE ISDESCENDANTNODE ([/content/we-retail])

-- returns all [cq:Page] nodes WHERE nodes exist under "/content/we-retail"
SELECT * FROM [cq:Page] WHERE ISDESCENDANTNODE ([/content/we-retail])

-- returns all [dam:Asset] nodes WHERE nodes exist under "/content/dam/we-retail"
SELECT * FROM [dam:Asset] WHERE ISDESCENDANTNODE ([/content/dam/we-retail])

-- returns all [nt:unstructured] nodes WHERE nodes exist under "/content/we-retail"
SELECT * FROM [nt:unstructured] WHERE ISDESCENDANTNODE([/content/we-retail])

4. The JCR-SQL2 CONTAINS Statement

Selecting nodes where the properties contain a value.
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5

-- returns all nodes WHERE node's property jcr:title CONTAINS "we-retail"
SELECT * FROM [nt:base] AS nodes WHERE CONTAINS(nodes.title, "we-retail")

-- returns all [cq:Page] nodes where node's property jcr:title CONTAINS "we-retail"
SELECT * FROM [cq:Page] AS nodes WHERE CONTAINS(nodes.title, "we-retail")

5. The JCR-SQL2 LIKE Operator

The LIKE operator is used to search for a specified pattern in node properties.
There are two wildcards used in conjunction with the LIKE operator: % and _
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

-- returns all [cq:PageContent] nodes WHERE nodes exist under "/content"
-- AND node's property jcr:title starts with any values and ends with "w"
SELECT * FROM [cq:PageContent] AS nodes WHERE ISDESCENDANTNODE ([/content])
AND nodes.[jcr:title] LIKE "%w"

-- returns all [cq:PageContent] nodes WHERE nodes exist under "/content"
-- AND node's property jcr:title starts with "w" and ends with any values
SELECT * FROM [cq:PageContent] AS nodes WHERE ISDESCENDANTNODE ([/content])
AND nodes.[jcr:title] LIKE "w%"

-- returns all [cq:PageContent] nodes WHERE nodes exist under "/contentl"
-- AND node's property jcr:title matching "w" in any position
SELECT * FROM [cq:PageContent] AS nodes WHERE ISDESCENDANTNODE ([/content])
AND nodes.[jcr:title] LIKE "%w%"

-- returns all [cq:PageContent] nodes WHERE nodes exist under "/content"
-- AND node's property jcr:title start with any values and have "w" in the second position and ends with any values
SELECT * FROM [cq:PageContent] AS nodes WHERE ISDESCENDANTNODE ([/content])
AND nodes.[jcr:title] LIKE "_w%"

6. The JCR-SQL2 IS NOT NULL Property

Used for validation of property’s value is not null.
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5
6
7
8
9

-- returns all nodes WHERE nodes exist under "/content"
-- AND node's property jcr:title IS NOT NULL
SELECT * FROM [nt:base] AS nodes WHERE ISDESCENDANTNODE ([/content])
AND nodes.[jcr:title] IS NOT NULL

-- returns all [cq:PageContent] nodes WHERE nodes exist under "/content"
-- AND node's property jcr:title IS NOT NULL
SELECT * FROM [cq:PageContent] AS nodes WHERE ISDESCENDANTNODE ([/content])
AND nodes.[jcr:title] IS NOT NULL

7. The JCR-SQL2 ORDER BY Keyword

The ORDER BY keyword is used to sort the result-set in ascending or descending order.
Returned values are sorted by default in ascending order.
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5
6
7
8
9

-- returns all nodes WHERE nodes exist under the "/content/we-retail"
-- ORDER BY jcr:created ascending
SELECT * FROM [nt:base] AS nodes WHERE ISDESCENDANTNODE ([/content/we-retail])
ORDER BY nodes.[jcr:created]

-- returns all nodes WHERE nodes exist under the "/content/we-retail"
-- ORDER BY node's property jcr:created descending
SELECT * FROM [nt:base] AS nodes WHERE ISDESCENDANTNODE ([/content/we-retail])
ORDER BY nodes.[jcr:created] DESC

8. The JCR-SQL2 CAST() Statement

Convert an expression from one data type to another.
Cast Types:
- STRING
- BINARY
- DATE
- LONG
- DOUBLE
- DECIMAL
- BOOLEAN
- NAME
- PATH
- REFERENCE
- WEAKREFERENCE
- URI
Returns in CRX/DE Lite: A list of JCR nodes in the results table with their corresponding paths.
Returns in OSGI Bundle (Sling API): All the found nodes stored in the Iterator object.
Returns in OSGI Bundle (JCR API): The QueryResult object where you can call getNodes() method to get the NodeIterator object.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

-- returns all [cq:PageContent] nodes WHERE nodes exist under the "/content/we-retail"
-- AND node's navRoot equals to "true"
SELECT * FROM [cq:PageContent] as nodes WHERE ISDESCENDANTNODE ([/content/we-retail])
AND nodes.[navRoot] = CAST("true" AS BOOLEAN)

-- returns all [cq:PageContent] nodes WHERE nodes exist under the "/content/we-retail"
-- AND node's creation date is greater than "April 1st, 2018"
SELECT * FROM [cq:PageContent] AS nodes WHERE ISDESCENDANTNODE ([/content/we-retail])
AND nodes.[jcr:created] > CAST("2018-04-01T00:00:00.000Z" AS DATE)

-- returns all [cq:PageContent] nodes WHERE nodes exist under the "/content/we-retail"
-- AND node's maxRating is less than "5.0"
SELECT * FROM [cq:PageContent] as nodes WHERE ISDESCENDANTNODE ([/content/we-retail])
AND nodes.[maxRating] < CAST("5.0" AS DECIMAL)

Final Notes: When is the perfect time to use JCR-SQL2?

Build a images and documents search component, if your AEM site that allows consumers to search for images or documents.
Build a blog post search component, If your AEM site has a blog section.
Build a secure resources query API, If you are allowing 3rd party applications to query and find nodes in your AEM site.

There’s many other things to utilize JCR-SQL2 to query nodes, but those are just some quick examples.

9. JCR-SQL2 Code Snippets Cheat Sheet

Use these code snippets below to rapidly build your AEM JCR SQL2 search queries, I will try my best to give you some really great examples:

a. Find all [nt:unstructured] nodes, under the path “/content/we-retail”, where the node name = “root”

1
2
3

SELECT * FROM [nt:unstructured] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND NAME() = "root"

b. Find all components ([nt:unstructured] nodes), under the path “/content/we-retail”, where component resourceType = “weretail/components/content/image”

1
2
3

SELECT * FROM [nt:unstructured] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND [sling:resourceType] = "weretail/components/content/image"

b. Find all components ([nt:unstructured] nodes), under the path “/content/we-retail”, where component resourceType = “weretail/components/content/image” AND the fileReference property contains with “/content/dam/we-retail/en/experiences”

1
2
3
4

SELECT * FROM [nt:unstructured] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND [sling:resourceType] = "weretail/components/content/image"
AND CONTAINS([fileReference], "/content/dam/we-retail/en/experiences")

c. Find all [nt:unstructured] nodes, under the path “/content/we-retail”, where the property(“jcr:title”) contains “Featured products”

1
2
3

SELECT * FROM [nt:unstructured] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND CONTAINS([jcr:title], "Featured products")

d. Find all pages (cq:Page nodes), under the path “/content/we-retail”, where the cq:lastModified date is before or equals to “January 1st, 2000”

1
2
3
4

SELECT page.* FROM [cq:Page] AS page
INNER JOIN [cq:PageContent] AS jcrContentNode ON ISCHILDNODE(jcrContentNode, page)
WHERE ISDESCENDANTNODE(page, "/content/we-retail")
AND jcrContentNode.[cq:lastModified] <= CAST("2023-01-01T00:00:00.000+00:00" AS DATE)

e. Find all pages (cq:Page nodes), under the path “/content/we-retail”, where the jcr:created date is before to “July 1st, 2022”

1
2
3
4

SELECT page.* FROM [cq:Page] AS page
INNER JOIN [cq:PageContent] AS jcrContentNode ON ISCHILDNODE(jcrContentNode, page)
WHERE ISDESCENDANTNODE(page, "/content/we-retail")
AND jcrContentNode.[jcr:created] < CAST("2022-07-01T00:00:00.000+00:00" AS DATE)

f. Find all [cq:PageContent] nodes, under the path “/content/we-retail”, where the cq:template equals to “/conf/we-retail/settings/wcm/templates/hero-page”

This AEM JCR SQ2 Query is an example for how to find all nodes with a specific template, results returned as cq:PageContent node.

1
2
3

SELECT * FROM [cq:PageContent] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND [cq:template] = "/conf/we-retail/settings/wcm/templates/hero-page"

g. Find all pages (cq:Page nodes), under the path “/content/we-retail”, where the cq:template equals to “/conf/we-retail/settings/wcm/templates/hero-page”

This AEM JCR SQ2 Query is an example for how to find all nodes with a specific template, results returned as cq:Page node.

1
2
3
4

SELECT page.* FROM [cq:Page] AS page
INNER JOIN [cq:PageContent] AS jcrContentNode ON ISCHILDNODE(jcrContentNode, page)
WHERE ISDESCENDANTNODE(page, "/content/we-retail")
AND jcrContentNode.[cq:template] = "/conf/we-retail/settings/wcm/templates/hero-page"

h. Find all [cq:PageContent] nodes, under the path “/content/we-retail”, where the cq:tags[] contains “we-retail:gender/men”

1
2
3
4

This AEM JCR SQ2 Query is an example for how to find all nodes with a single cq:tags[], results returned as cq:PageContent node.
SELECT * FROM [cq:PageContent] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND [cq:tags] = "we-retail:gender/men"

i. Find all [cq:PageContent] nodes, under the path “/content/we-retail”, where the cq:tags[] contains “we-retail:gender/men” AND cq:tags[] contains “we-retail:activity/surfing”

1
2
3
4
5

This AEM JCR SQ2 Query is an example for how to find all nodes with multiple cq:tags[], results returned as cq:PageContent node.
SELECT * FROM [cq:PageContent] AS node
WHERE ISDESCENDANTNODE(node, "/content/we-retail")
AND [cq:tags] = "we-retail:gender/men"
AND [cq:tags] = "we-retail:activity/surfing"

9. JCR-SQL2 Java Code Example Servlet (2023)

This is an example of how an AEM servlet would actually utilize the JCR-SQL2 Query with the examples above. It will output a JSON array of the page paths.

import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;

import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.query.Query;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingSafeMethodsServlet;
import org.osgi.service.component.annotations.Component;

import com.google.gson.JsonArray;
import com.google.gson.JsonObject;

@Component(service = javax.servlet.Servlet.class, property = { "sling.servlet.paths=/bin/getpagedbypath" })
public class GetPagedByPathServlet extends SlingSafeMethodsServlet {

@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response)
throws IOException {
try {
// Get the JCR session
Session session = request.getResourceResolver().adaptTo(Session.class);

// Query statement
String queryString = "SELECT page.* FROM [cq:Page] AS page "
+ "INNER JOIN [cq:PageContent] AS jcrContentNode ON ISCHILDNODE(jcrContentNode, page) "
+ "WHERE ISDESCENDANTNODE(page, '/content/we-retail') "
+ "AND jcrContentNode.[cq:lastModified] <= CAST('2023-01-01T00:00:00.000+00:00' AS DATE)";

// Create the query object
QueryManager queryManager = session.getWorkspace().getQueryManager();
Query query = queryManager.createQuery(queryString, Query.JCR_SQL2);

// Execute the query
QueryResult result = query.execute();

// Get the nodes from the query result
NodeIterator nodeIterator = result.getNodes();

// Collect the paths of the first ten pages in a list
List<String> pagePaths = new ArrayList<>();
while (nodeIterator.hasNext()) {
Node pageNode = nodeIterator.nextNode();
String pagePath = pageNode.getPath();
pagePaths.add(pagePath);
}

// Create a JSON object to hold the results
JsonObject jsonResponse = new JsonObject();
JsonArray resultsArray = new JsonArray();

// Add the paths to the JSON array
for (String path : pagePaths) {
resultsArray.add(path);
}

// Add the JSON array to the response object
jsonResponse.add("results", resultsArray);

// Set the response content type
response.setContentType("application/json");

// Write the JSON response to the output
PrintWriter writer = response.getWriter();
writer.print(jsonResponse.toString());
writer.flush();
} catch (RepositoryException e) {
// Handle exception
response.setStatus(SlingHttpServletResponse.SC_INTERNAL_SERVER_ERROR);
response.getWriter().println("Error executing query: " + e.getMessage());
}
}
}

JSON response

1
2
3
4
5
6
7
8
9
10
11
12
13
14

{
"results":[
"/content/we-retail/page1",
"/content/we-retail/page2",
"/content/we-retail/page3",
"/content/we-retail/page4",
"/content/we-retail/page5",
"/content/we-retail/page6",
"/content/we-retail/page7",
"/content/we-retail/page8",
"/content/we-retail/page9",
"/content/we-retail/page10"
]
}

Curl call

1	curl -X GET http://localhost:4502/bin/getpagedbypath

The post How to use AEM JCR SQL2 query strings to query for nodes in Java Content Repository appeared first on Sourced Code.