1. Element and Attribute Visibility

When using the data-sly-attribute directive, it’s important to understand how it affects the visibility of elements and their attributes:

Element Visibility: The HTML element to which the data-sly-attribute directive is applied will always be rendered in the DOM. This means that the element itself will always be visible, regardless of the attributes set or not set by the directive.

Even if dynamicClass is empty or undefined, the paragraph will still appear in the DOM.

Element Content: The content inside the HTML element will also always be displayed. The data-sly-attribute directive only affects the attributes of the element, not its content. This ensures that the inner content remains intact and visible to the users.

Even if dynamicId is empty or undefined, the text “Content remains visible” will still be displayed within the span element.

2. Attribute Value Options

The attribute value in data-sly-attribute is optional and can be of different types:

String: Used to set the content of the attribute.

Example:

Boolean: Used for setting boolean attributes.

Example:

Object: Used for setting multiple attributes simultaneously.

Example:

If the attribute value is omitted, the attribute will be removed.

3. Attribute Identifier

The attribute identifier, which is the name of the attribute, is also optional. It must be omitted only if the attribute value is an Object.

Detailed Explanation:

When using the data-sly-attribute directive, you can specify the name of the attribute you want to set. This is called the attribute identifier. However, when you are using an Object to set multiple attributes at once, you do not need to specify individual attribute names.

Code Examples:

Specifying Attribute Identifier:

When setting a single attribute, you provide the attribute name directly.

Omitting Attribute Identifier (Using an Object):

When setting multiple attributes simultaneously, you use an Object and omit the attribute name.

In this case, the keys of the Object (id and class) are used as attribute names, and their corresponding values (dynamicDiv and dynamicClass) are assigned to those attributes.

4. Using `data-sly-attribute`

You can define attributes either directly through an expression or by using a data-sly-attribute.* attribute. This approach allows designers to annotate HTML without modifying the mock content.

Example: Overwriting an Attribute

Example: Creating a New Attribute

5. Injecting Multiple Attributes

The data-sly-attribute block element, when used without specifying an attribute name, allows the injection of multiple attributes that have been prepared in a map object containing key-value pairs.

Example: Injecting Multiple Attributes

6. More Examples

Example: Setting Multiple Attributes on a Button

Example: Conditional Attribute Setting

Conclusion

The data-sly-attribute directive in HTL provides a versatile way to manage HTML attributes dynamically. Whether you’re setting a single attribute or multiple attributes at once, this feature can help you create more dynamic and flexible web components. By leveraging data-sly-attribute, you can ensure that your HTML remains clean and maintainable, while still being able to handle complex attribute logic.

Feel free to explore and use these examples to enhance your AEM projects, making your components more dynamic and interactive.

The post Understanding `data-sly-attribute` in AEM Sightly (HTL) appeared first on Sourced Code.

In this article, we will step through how developers can incorporate and retrieve context-aware configurations from AEM backend development.

1. Overview of Context-Aware Configurations

Adobe Experience Manager (AEM) introduces Context-Aware Configurations to empower developers to define adaptable application settings based on the specific contexts of sites or content. This functionality simplifies configuration management across different environments, facilitating dynamic behavior adjustments of applications without necessitating changes to the core code.

2. Accessing Configurations via Java

To harness context-aware configurations, the process starts with fetching the relevant content resource using the ResourceResolver:

Following resource retrieval, adapt it to a ConfigurationBuilder to fetch the specific configuration:

MyConfig is a developer-defined interface that encapsulates the configuration parameters influencing the application’s functionality.

4. Configuration Interface Example

Define the MyConfig interface with configuration parameters as follows from the code below. Making sure that my code is scalable, I usually place CaConfig under the path com.sourcedcode.core.caconfig.*

5. Utilizing the Configuration in an OSGi Component

Implement the configuration within an AEM component or service as shown below:

This example demonstrates the dynamic adjustment of application functionality based on retrieved configurations, highlighting the flexibility and maintainability that Context-Aware Configurations bring to AEM development.

The post AEM Context-Aware Configurations in Java Backend Example Code appeared first on Sourced Code.

In this article we will step through how to use the caconfig global variable in HTL Sightly.

References: https://sling.apache.org/documentation/bundles/context-aware-configuration/context-aware-configuration.html

The post HTL caconfig Global Variable for Context-Aware Configuration in AEM appeared first on Sourced Code.

1. Root Cause of the Issue

This error typically arises when AEM’s repository encounters problems, either due to corrupted data, locking issues, or misconfigurations in the initialization scripts. Such issues prevent AEM from authenticating requests, leading to the aforementioned error.

2. Removing Lock Files

Lock files are created to ensure exclusive access to the repository by an AEM instance. However, if these files become corrupted or are not released properly upon a shutdown, they can cause startup issues.

• Files to Delete:
  • crx-quickstart/repository/segmentstore/repo.lock
  • crx-quickstart/launchpad/felix/cache.lock

Deleting these lock files can free up the repository and allow the AEM instance to start correctly.

3. Clearing Repository Index Files

Index files are essential for AEM’s search capabilities. Corruption or outdated index files can lead to significant errors, including authentication issues.

• Paths to Clear:
  • crx-quickstart/repository/index/*

Removing these files prompts AEM to rebuild the indexes, potentially resolving the authentication issue.

4. Resetting Custom Initialization Scripts

Custom repoinit scripts under the crx-quickstart/launchpad/config/org/apache/sling/jcr/repoinit directory can interfere with repository initialization, causing authentication and other services to fail.

• Paths to Clear:
  • crx-quickstart/launchpad/config/org/apache/sling/jcr/repoinit/*

By deleting these scripts, you ensure that no custom initialization interferes with the repository’s proper startup process.

5. Restarting Your AEM Instance

After performing the above steps, restart your AEM instance. This process will initiate a clean startup sequence, allowing AEM to rebuild necessary files and indexes.

Conclusion

The “AuthenticationSupport service missing. Cannot authenticate request” OR the “HTTP ERROR 404 Not Found org.apache.felix.http.base.internal.dispatch.DispatcherServlet”errors can be a daunting obstacle, but by following the outlined steps, you can swiftly return your AEM development environment to a functional state. This guide provides a comprehensive approach to troubleshooting and resolving one of the more perplexing issues in AEM development, ensuring you can continue your work with minimal interruption.

Remember, careful manipulation of the file system and adherence to the recommended procedures are paramount to successfully overcoming this challenge. This guide aims to empower AEM developers, particularly those in the early stages of their journey, with the knowledge to tackle such issues confidently.

The post AuthenticationSupport service missing. Cannot authenticate request. appeared first on Sourced Code.

Why Indexing is Important

Indexing AEM is critical for optimizing performance and managing content efficiently. The Oak Index, a key feature of AEM, improves search query speed by organizing data for quicker retrieval. This not only boosts system performance but also supports customization for specific project requirements. Efficient indexing enables scalable and responsive AEM sites, ensuring they can handle growing content without compromising on speed. Understanding and utilizing the Oak Index effectively is essential for maintaining high-performance AEM projects that meet modern digital experience demands.

Using the Oak Index Definition Generator

Creating custom Oak indexes with the Oak Index Definition Generator is a straightforward process:

1. Open the Oak Index Definition Generator at http://oakutils.appspot.com/generate/index.
2. Input your query in the Queries field.
3. Click “Generate” to create your custom Oak index.
4. Copy the XML into your AEM project for further adjustments.

Conclusion

It’s essential for developers to familiarize themselves with the AEM index definition structure to maximize the effectiveness of their custom indexes. Adobe provides resources such as a cheat sheet on AEM index definition structure, offering guidance on how to properly configure indexes for optimal performance.

The post Generate Custom Oak Indexes with the Oak Index Definition Generator appeared first on Sourced 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.

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 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.

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.

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.

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.

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.

Follow this step-by-step guide below as we transparently outline each phase of our process to resolve this issue.

The post AEM 6.5.5 Not Indexing Problem *Fixed* appeared first on Sourced Code.

This has only been tested on AEMaaCS.

1. Understanding Authoring Modes in AEM:

AEM’s editor.html supports multiple authoring modes, each serving a specific purpose in the content creation workflow. These modes include edit mode, preview mode, layout mode, developer mode, MSM (Multi-Site Manager) mode, and time warp mode. To enhance the authoring experience, it’s crucial to apply targeted CSS to components based on the current authoring mode.

2. Targeting Components in Different Authoring Modes:

To achieve a seamless authoring experience, developers can leverage specific CSS classes associated with each authoring mode in AEM. The following example demonstrates how to target a custom component called “.my-component” in different authoring modes:

In the above example, each CSS rule targets the “.my-component” class in a specific authoring mode, applying distinct styles to improve visibility or provide context for authors working in that mode.

3. Benefits of Targeting CSS in AEM Editor:

1. Improved Visibility: By applying different background colors or borders in various authoring modes, developers can enhance the visibility of components, making it easier for authors to identify and manipulate them.
2. Contextual Styling: Tailoring styles based on the authoring mode provides contextual information to content authors. For instance, applying a distinctive style in developer mode can signify that the component is currently being modified at a code level.
   Optimized Workflows:
3. Optimized Workflows: Targeted CSS in the editor.html file optimizes authoring workflows by reducing confusion and streamlining the content creation process. Authors can quickly grasp the current mode and focus on the relevant tasks.

4. Conclusion:

Customizing the authoring experience in AEM by targeting CSS in the editor.html file is a powerful way to enhance usability and streamline content creation workflows. By understanding and leveraging the specific CSS classes associated with each authoring mode, developers can provide a more intuitive and visually informative environment for content authors using AEMaaCS.

And one more last thing to note is, please ensure that these rules are added into your clientlibs.author structure, so that these rules will never be exposed on production.

The post Targeting CSS in the Editor.html for AEM Components for AEMaaCS appeared first on Sourced Code.

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.

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.

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

The adoption of “Try-With-Resources” in your code exemplifies a commitment to clean, efficient, and error-resistant Java programming. By embracing this feature, you not only reduce boilerplate code but also mitigate the risk of resource leaks, ensuring the reliable closure of the session. The article underscores the significance of “Try-With-Resources” within the broader theme of never forgetting to close the session, offering developers valuable insights into crafting resilient and maintainable code.

Try-With-Resources AEM Example Code

In the spirit of “Try-With-Resources,” your code exemplifies the essence of effective resource management. The central focus is on ensuring the closure of the session resource, a critical component in Java Content Repository (JCR) operations.

Understanding the Code:

Within the try block, the “ResourceResolver” and its associated “Session” resource are declared using “Try-With-Resources.” The factory object, presumably an instance of a ResourceResolverFactory, facilitates obtaining a service resource resolver with specific authentication information (authInfo). The resolver is seamlessly adapted to a session, streamlining the process.

As the code interacts with the JCR node located at “/content/sourcedcode/jcr:content,” the session enables the manipulation of node properties. The try-with-resources statement guarantees that both the “ResourceResolver” and the “Session” are automatically closed at the conclusion of the block, eliminating the need for explicit closure statements.

The post Try-With-Resources: Ensuring Session Closure, AEM Code Example appeared first on Sourced Code.

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:

JSON Output:

Servlet Implementation ExcelExampleServlet.java:

Servlet Depdendencies:

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

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%

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

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

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

Understanding the Explain Query Tool

The Explain Query Tool essentially breaks down and explains the steps and processes a query goes through in AEM. Think of it as a ‘debug mode’ for your search queries. It provides insights into how the system interprets the query, the indexes it leverages, the estimated cost of the query, and other essential metrics.

Benefits of Using the Explain Query Tool:

• Performance Analysis: By revealing how the system interprets and executes the query, developers can identify bottlenecks or inefficiencies.
• Better Indexing: Developers can understand which indexes are being used and optimize or create new ones accordingly.
• Debugging: It becomes easier to pinpoint issues in complex queries when developers can visualize each step.

Using Explain Query Tool with Different AEM Backend Search APIs

1. SQL2:

SQL2 is the SQL-like query language used in AEM, and it’s one of the primary ways developers retrieve data from the JCR (Java Content Repository).

How to Use:

Navigate to the AEM Query Performance Tool, and select on the “Explain Query” tab. Choose the “Language” drop down to be SQL-JCR2, and input the JCR-SQL2 query that you are trying to test. Now click on explain, and you’ll see a breakdown of the query’s interpretation and execution.

AEM Query Performance Tool
http://localhost:4502/libs/granite/operations/content/diagnosistools/queryPerformance.html

2. Query Builder API:

Query Builder API allows developers to build search queries programmatically using a more intuitive map-based syntax. It abstracts some complexities of the JCR, offering a more accessible way to retrieve content.

How to Use:

Navigate to the AEM Query Performance Tool, and select on the “Explain Query” tab. Choose the “Language” drop down to be Query Builder, and input your Query Builder query that you are trying to test. Now click on explain, and you’ll see a breakdown of the query’s interpretation and execution.

AEM Query Performance Tool
http://localhost:4502/libs/granite/operations/content/diagnosistools/queryPerformance.html

3. XPath:

XPath is another way of querying the JCR in AEM. While it’s less commonly used than SQL2, it can be more expressive and powerful for certain hierarchical data structures.

How to Use:

Navigate to the AEM Query Performance Tool, and select on the “Explain Query” tab. Choose the “Language” drop down to be XPath, and input the XPath Query that you are trying to test. Now click on explain, and you’ll see a breakdown of the query’s interpretation and execution.

AEM Query Performance Tool
http://localhost:4502/libs/granite/operations/content/diagnosistools/queryPerformance.html

Other Options for the AEM Query Performance Tool

1. Include Execution Time: Execution time will be reported after running the query. Please note that long running queries will report an explanation with a delay.
2. Read first page of results: The first 20 results will be read after running the query. Please note that long running queries will report an explanation with a delay, and the overall execution will timeout after 60 seconds.
3. Include Node Count: The node count is calculated by iterating the full result set of the query. Please note that long running queries will report an explanation with a delay, and the overall execution will timeout after 60 seconds.

AEM Query Performance Tool
http://localhost:4502/libs/granite/operations/content/diagnosistools/queryPerformance.html

Conclusion

The Explain Query Tool in AEM is a powerful ally for developers, especially those heavily invested in ensuring the performance and accuracy of their search queries. By familiarizing oneself with this tool across the various backend search APIs, developers can optimize their AEM platform for both performance and maintainability, ensuring that the content delivery is swift and relevant.

The post Optimizing & Debugging Search Queries, Explain Query Tool AEM appeared first on Sourced Code.

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.

In this article we will walk through step by step how to embed the Adobe AEM Core Components into your project, so when your code is built via maven, your maven module will contain instructions for your AEM environment to install the Adobe AEM Core Components as expected.

1. Add dependencies to parent pom.xml

2. Add dependencies to your target maven module

In this example, we will target all/pom.xml

3. Configure com.day.jcr.vault’s <subPackages><subPackage> to target maven module

In this example, we will target all/pom.xml

The post AEM 6.5 On-Prem, Embed AEM Core Component’s to the Project appeared first on Sourced Code.

Throughout this article, we will delve into the step-by-step process of configuring, installing, embedding, and deploying the wcm.io Context-Aware Configuration Editor. By following these instructions, you’ll be able to harness the capabilities of this editor to automatically install configuration changes across all environments when your code is built via Maven and deployed to AEM. When it comes to deploying the wcm.io Context-Aware Configuration Editor, automation is key.

1. Add dependencies to parent pom.xml

2. Add dependencies to your target maven module

In this example, we will target all/pom.xml

3. Configure com.day.jcr.vault’s <embeded> to target maven module

In this example, we will target all/pom.xml, and yes, step 2 and 3 are configuration added to the same file.

4. Add template to create and manage wcm.io caConfigs

./ui.apps/src/main/content/jcr_root/apps/sourcedcode/templates/caconfig-template/content.xml

5. Context-Aware Configuration bnd plugin

A bnd plugin is provided that scans the classpath of a bundle Maven project at build time and automatically generates a Sling-ContextAware-Configuration-Classes bundle header for all annotation classes annotated with @Configuration. It can be used by both maven-bundle-plugin and bnd-maven-plugin, as both use the bnd library internally.

Standard Configuration
Place the configuration from the root pom.xml as such:

If you use the bnd-maven-plugin and raw bnd statements, you have to configure it with this bnd statement:
Place the configuration from the root pom.xml as such:

Sling Context Aware Configuration context-aware-configuration-bnd-plugin not working as expected
If both installations from the top are not working as expected, please try the configuration as below. Place the configuration from the root pom.xml as such. Take a look at line 21, where you can see we have kept org.apache.sling.caconfig.bndplugin.ConfigurationClassScannerPlugin, org.apache.sling.bnd.models.ModelsScannerPlugin in one line of code, with a comma as the delimiter.

6. Absolute Parent Context Path Strategy

io.wcm.caconfig.extensions.contextpath.impl.AbsoluteParentContextPathStrategy-sourcedcode.config

In this crucial step, we introduce the Absolute Parent Context Path Strategy, found in the io.wcm.caconfig.extensions.contextpath.impl.AbsoluteParentContextPathStrategy-.config. This feature allows you to create tailored configurations for specific folders within your content repository. For instance, you can now establish separate configurations for ‘/content/sourcedcode/en’ and ‘/content/sourcedcode/fr,’ effectively breaking the chain of inheritance. This newfound freedom permits you to cancel inheritance at various levels, from 1 to 4, enabling you to fine-tune configurations to align with your folder structure. This level of precision and customization is pivotal in optimizing your content management experience.

7. Root Template Context PathStrategy

io.wcm.caconfig.extensions.contextpath.impl.RootTemplateContextPathStrategy-sourcedcode.config

In this step, we focus on configuring the io.wcm.caconfig.extensions.contextpath.impl.RootTemplateContextPathStrategy-.config. This feature allows you to establish a foundational template for your content, ensuring a well-structured content hierarchy in your AEM project. By defining a root template, you simplify content management and maintain consistency throughout your project. Whether you’re building a website, an application, or a digital experience, configuring a root template is a fundamental step in aligning your content with your project’s objectives.

8. Absolute Parent Context Path Strategy, Folder Level Ca Configs

io.wcm.caconfig.extensions.persistence.impl.PagePersistenceStrategy.config

If you intend to maintain the default Sling implementation, there are two options for handling the configurations: you can either package them from the author environment to the publish environment or replicate them from CRXDE Lite. If you opt for the wcm.io editor, it offers a feature that facilitates configuration replication by saving configurations as cq:Page nodes. To activate replication within the editor page, you should utilize the “PagePersistenceStrategy” provided by the “caconfig.extension” package, which must be deployed in AEM. Additionally, you need to enable the “io.wcm.caconfig.extensions.persistence.impl.PagePersistenceStrategy” OSGi configuration within the ui.apps module. Failing to complete this step will result in ca configurations being stored as folders, which necessitates setting the resourceType to nt:unstructured.

The post How to Embed wcm.io Context-Aware Configuration Editor appeared first on Sourced Code.

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

1. 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.
2. 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.
3. 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

1. Path-bound servlets cannot be access-controlled using the default JCR repository ACLs.
2. Path-bound servlets can only be registered to a path and not a resource type (i.e. no suffix handling).
3. 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.

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.

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.

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:

Example Try Catch

Curl Example:

Output:

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:

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.

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

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.

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

I’m here to make it super simple for you. This JCR SQL 2 Unit Tests w/ Sling Servlet blog post will only cover the modern approach to unit testing using JUnit 5 and the io.wcm.testing.aem-mock.junit5 library. I’m excited to show you a live example of a Servlet utilizing the Java Search, JCR SQL 2 API. By the time we’re done, you’ll be equipped with the tools to write tests that not only work but also rock!

1. What to test for when testing a Servlet or OSGI Service that utilizes the Java, JCR SQL 2 API?

1a. Query String

In my opinion, it’s crucial to focus on two main areas. First, you should thoroughly test the query string that gets executed. This query string is like the roadmap guiding your code’s behavior. Ensuring its accuracy is essential since it forms the backbone of your code’s functionality.

2b. Results of the Query, Nodes

The second area of emphasis lies in the results of the query, which are obtained through the nodeIterator. This is where the real action happens – think of it as the hub where your code processes data. Testing this part of your code involves ensuring that the data processing via the nodeIterator is in line with your intended modifications.

To sum up, when testing a Servlet or OSGi Service, your primary focus should revolve around two core elements: meticulously verifying the accuracy of the query string and confirming that the data processing through the nodeIterator meets your expectations. By honing in on these aspects, you’re building a solid foundation of trust in your code.

2. Code Examples

2a. GetPagedByPathServlet.java

Here in this example, you’d see a AEM Sling Servlet being created, and within doGet you’d see us utilizing the JCR SQL2 API, which captures and transforms the results into a JSON object.

JSON response

Curl call

2b. GetPagedByPathServletTest.java

Here in this unit test examples. In my opinion, what is mostly effective unit tested for the JCR SQL 2 API, and to test the query string, and next, test the query result. This example does just it. I have tested the code, and it is working as expected.