A Synonym filter can help to map different terms that have the same meaning, such as “cat” and “feline”. A LowerCase filter can help to normalize the case of the terms, so that “cats and dogs” and “Cats and Dogs” are treated the same.

To push a code fix into the current release candidate, the best practice is to cherry-pick the fix commit into the release candidate branch. Cherry-picking allows you to apply specific changes from one branch to another, ensuring that only the necessary fixes are included without introducing unrelated changes.

Here’s how to cherry-pick a commit:

Identify the Commit: Locate the commit hash of the fix you need to apply. This can be found in your version control system (e.g., Git).

Checkout the Release Candidate Branch:

git checkout release-candidate-branch

Cherry-pick the Commit:

git cherry-pick

Resolve Conflicts(if any): If there are conflicts, resolve them manually and then continue the cherry-pick process:

git add

git cherry-pick --continue

 Test the Changes: Ensure that the changes are tested thoroughly in the release candidate environment to confirm the fix works as expected.

 Push the Changes:

git push origin release-candidate-branch

Cherry-picking ensures that only the required changes are applied to the release candidate, maintaining the stability and integrity of the codebase.

References:

Git Cherry-pick Documentation

When installing a package in AEM and you want to ensure that existing content in the repository is not overwritten while ensuring that content not present in the repository is not removed, you should use the update import mode.

The update import mode performs the following actions:

It updates existing content nodes in the repository with the nodes from the package being installed.

It does not remove any existing nodes or properties in the repository that are not present in the package.

It adds any new nodes or properties from the package to the repository.

This mode is particularly useful when you want to preserve any manual changes or additions that might have been made to the repository content outside of the package installations.

Here’s how you can specify the import mode during package installation:

Access Package Manager: Log into your AEM instance and navigate to the CRX Package Manager (e.g., http://localhost:4502/crx/packmgr/index.jsp).

Upload the Package: If the package is not already uploaded, click on "Upload Package" and select the package file from your local system.

Install the Package: Click on "Install" for the package you wish to install.

Choose the Import Mode: During the installation process, you will have the option to choose the import mode. Select update from the available options.

AEM Package Manager - Import Mode

Complete Installation: Proceed with the installation. The content will be updated according to the rules defined by the update import mode.

By using the update mode, you ensure that your repository content is updated without losing any existing nodes or properties that are not part of the package.

References:

Adobe Experience Manager Package Manager Documentation

AEM Import Modes

These steps ensure that you manage content updates in a controlled manner, preserving existing repository content while incorporating updates from the installed package.

The order of resolution for OSGi configurations at runtime in AEM is as follows:

Web Console Configuration:

Changes made through the OSGi Web Console take immediate effect and have the highest precedence. This is because these configurations are considered the most direct way to adjust OSGi settings at runtime.

References:OSGi Configuration in AEM

/apps Configuration:

Configurations in the /apps directory take precedence over those in the /libs directory. This allows custom configurations to override the default configurations provided by AEM.

References:AEM Project Structure

/libs Configuration:

Configurations in the /libs directory are the default configurations provided by AEM. They are overridden by any configurations in the /apps directory.

References:AEM Configuration

By understanding this order, developers can effectively manage and prioritize their OSGi configurations to ensure the desired behavior of their AEM instances.

In AEM as a Cloud Service environment, the repository areas /apps and /libs are considered as immutable, meaning that they cannot be modified at runtime by any means. These areas contain application code and configuration that are deployed via Cloud Manager and are read-only for security and performance reasons. Any changes to these areas require a new deployment via Cloud Manager. References: https://experienceleague.adobe.com/docs/experience-manager-cloud-service/implementing/deploying/overview.html?lang=en#repository-restrictions https://experienceleague.adobe.com/docs/experience-manager-cloud-service/implementing/developing/aem-project-content-package-structure.html?lang=en#repository-restrictions

To implement a new component called "Page Headline" which takes the text from the current page title instead of jcr:title, you should create a proxy component from the core title component and implement a Sling Model accordingly. Option C demonstrates the correct approach to achieve this functionality.

Here is a detailed explanation of Option C:

Create Proxy Component:

Create a new component in your project that will act as a proxy to the core title component. This involves creating a new component node in the repository that inherits from the core title component.

Example path: /apps/myproject/components/pageHeadline with sling:resourceSuperType set to core/wcm/components/title/v2/title.

Implement Sling Model:

Implement a Sling Model that adapts from SlingHttpServletRequest and Title.class, ensuring it overrides the text fetching logic to retrieve the title from the current page's title.

The model will use @ScriptVariable to inject the current page and @Self to access the core title component's logic.

@Model(adaptables = SlingHttpServletRequest.class, adapters = Title.class, resourceType = "myproject/components/pageHeadline")

public class PageHeadline implements Title {

@ScriptVariable

private Page currentPage;

@Self @Via(type = ResourceSuperType.class)

private Title title;

@Override

public String getText() {

return currentPage.getTitle();

}

@Override

public String getType() {

return title.getType();

}

}

@Model Annotation: Specifies that this class is a Sling Model and adapts from SlingHttpServletRequest. It is also an adapter for Title.class and applies to the myproject/components/pageHeadline resource type.

@ScriptVariable: Injects the current Page object, which allows access to the current page's properties.

@Self @Via(type = ResourceSuperType.class): Injects the core title component, allowing the reuse of existing logic.

getText() Method: Overrides the getText() method to return the title from the current page instead of the jcr:title.

getType() Method: Delegates to the core title component's getType() method to maintain existing functionality.

This approach leverages the power of Sling Models and the core components to extend functionality while keeping the implementation clean and maintainable.

References:

Adobe Experience Manager - Core Components

Sling Models Documentation

The Apache Sling Logging Logger Configuration and Apache Sling Logging Writer Configuration are the OSGi configurations that the developer should use to create a Logger and Writer pair for the company’s application logging. The Logger Configuration defines the log level and the log file name for a given logger name or category. The Writer Configuration defines the file size, number of files, and file location for a given log file name. References:https://experienceleague.adobe.com/docs/experience-manager-65/deploying/configuring/configure-logging.html?lang=en#configuring-log-files

Option B and Option D are two implementations that will support the HTL snippet. Option B uses the @Model annotation with the adaptables parameter set to Resource.class. This allows the Sling Model to adapt from a resource object and access its properties using the ValueMap interface. Option B also uses the @Inject annotation with the name parameter set to “./text” to inject the value of the text property into the text field. Option D uses the @Model annotation with the defaultInjectionStrategy parameter set to OPTIONAL. This allows the Sling Model to use optional injection for all fields and avoid null pointer exceptions if a property is missing. Option D also uses the @Inject annotation without any parameters to inject the value of the text property into the text field, using the field name as the default property name. References: https://sling.apache.org/documentation/bundles/models.html https://experienceleague.adobe.com/docs/experience-manager-htl/using-htl/htl-block-statements.html?lang=en#use

The aemanalyser-maven-plugin is a Maven plugin that checks if all the requirements declarations made in OSGi bundles are satisfied by the capabilities declarations of other bundles included in the Maven project. This plugin ensures that the OSGi bundles are consistent and can be resolved at runtime. The plugin also checks for other issues such as API compatibility, package versioning, and bundle start order. References: https://experienceleague.adobe.com/docs/experience-manager-cloud-service/implementing/developing/aem-project-content-package-structure.html?lang=en#build-analyzer-maven-plugin https://github.com/adobe/aemanalyser-maven-plugin

Creating a heap dump and a thread dump are two steps that should be taken after confirming the problem is related to a memory issue. A heap dump is a snapshot of the memory usage of the Java Virtual Machine (JVM) at a given point in time. A heap dump can be used to identify memory leaks, memory consumption patterns, and objects that occupy large amounts of memory. A thread dump is a snapshot of the state of all threads that are part of the JVM process. A thread dump can be used to identify deadlocks, blocked threads, and CPU-intensive threads. References: https://experienceleague.adobe.com/docs/experience-manager-65/deploying/configuring/memory-analysis.html?lang=en https://experienceleague.adobe.com/docs/experience-manager-65/deploying/configuring/thread-dump-analysis.html?lang=en

To create Sling Models that can export data in a human-readable yaml format, the following steps are required:

Create Sling models to export as yaml. Sling models are Java classes that can be used to represent resources in AEM. Sling models can use annotations to define how they can be adapted from a resource and how they can export data in different formats. To export data in yaml format, the Sling model class needs to use the @Model annotation with the resourceType parameter set to the resource type of the resource that the model represents. The Sling model class also needs to implement the org.apache.sling.models.annotations.Exporter annotation with the name parameter set to “jackson” and the extensions parameter set to “yaml”. The Sling model class also needs to use the @JsonProperty annotation on the fields or methods that need to be exported in yaml format.

Configure mime type in Apache Sling MIME Type Service. The Apache Sling MIME Type Service is an OSGi service that maps file extensions to MIME types and vice versa. To enable the yaml format for Sling models, the MIME Type Service needs to be configured with a new entry for the yaml extension and its corresponding MIME type, which is “application/x-yaml”. This can be done by creating an OSGi configuration for the org.apache.sling.commons.mime.internal.MimeTypeServiceImpl service and adding the entry “yaml=application/x-yaml” to the mime.types property. References: https://sling.apache.org/documentation/bundles/models.html https://sling.apache.org/documentation/bundles/mime-type-support-commons-mime.html

The WorkflowProcess interface is the interface to be used for automatic workflow steps implemented in Java. Classes implementing this interface define Java based processes that can be attached to a WorkflowNode and executed by the workflow engine. The method execute takes a WorkItem, a WorkflowSession and a MetaDataMap as parameters and performs thelogic of the custom process step. References: https://developer.adobe.com/experience-manager/reference-materials/6-5/javadoc/com/adobe/granite/workflow/exec/WorkflowProcess.html https://experienceleague.adobe.com/docs/experience-manager-learn/forms/adaptive-forms/custom-process-step-aem-workflow.html?lang=en

The /glob attribute is mandatory for all filter rules in the dispatcher configuration. It specifies a pattern that is matched against the incoming request URL. If the pattern matches, the rule is applied. The /glob attribute can use wildcards (*) and placeholders ($1, $2, etc.) to match parts of the URL. References:https://experienceleague.adobe.com/docs/experience-manager-dispatcher/using/configuring/dispatcher-configuration.html?lang=en#filter-rules

The Auto Replicate via On Off Trigger Configuration is a feature that allows content to be replicated as soon as the On Time and Off Times are reached. This feature can be enabled by creating an OSGi configuration for the com.day.cq.wcm.core.impl.servlets.OnOffTimeServlet service. This service listens for changes in the On Time and Off Time properties of pages and triggers replication accordingly. References: https://experienceleague.adobe.com/docs/experience-manager-65/deploying/configuring/replication.html?lang=en#on-off-time https://experienceleague.adobe.com/docs/experience-manager-65/deploying/configuring/replication.html?lang=en#auto-replication

AEM SPA integration provides various design models for different levels of authoring capabilities and developer control. In the design model where AEM is used as a headless CMS without using the SPA Editor SDK framework, the developer has full control over the app and can use any SPA framework or library. However, this also means that the content author cannot edit the app using AEM’s content authoring experience, the SPA is not compatible with the template editor, and the developer cannot enable authoring in restricted areas of the app.References:https://experienceleague.adobe.com/docs/experience-manager-learn/spa-editor-overview/spa-overview.html?lang=en#design-models

To design a workflow that collects data from the participant and then determines the reviewer/approver branch to proceed further, the developer should use theDynamic Participant Step. This workflow step allows for dynamic determination of participants based on the data collected or any other logic implemented in the workflow.

Here’s how to implement a Dynamic Participant Step in AEM:

Create the Workflow Model:

In AEM, navigate to Tools > Workflow > Models.

Create a new workflow model or edit an existing one.

Add Dynamic Participant Step:

Drag and drop the Dynamic Participant Step into your workflow model.

Configure the Dynamic Participant Step:

Click on the Dynamic Participant Step and configure it by specifying the participant chooser class. This class should implement the logic to determine the next participant.

@Component(service = ParticipantStepChooser.class, property = {

"service.description=Dynamic Participant Chooser"

})

public class CustomParticipantStepChooser implements ParticipantStepChooser {

@Override

public String getParticipant(WorkItem workItem, WorkflowSession workflowSession, MetaDataMap metaDataMap) {

// Custom logic to determine the participant based on workflow data

String reviewer = // logic to determine reviewer

return reviewer;

}

}

Implement Participant Chooser Logic:

The CustomParticipantStepChooser class should contain the logic to determine the next participant based on the workflow data. This can include reading workflow variables, making decisions based on conditions, or any other custom logic.

Deploy and Test:

Save the workflow model and test it by starting a new workflow instance. Ensure that the dynamic participant determination works as expected.

By using the Dynamic Participant Step, you can create flexible workflows that adapt to the data and context, ensuring that the appropriate participants are chosen dynamically.

References:

Adobe Experience Manager Workflow

AEM Dynamic Participant Step

The recommended path to override /libs standard functionality is /apps. The /apps folder contains application-specific code and configuration that can extend or override the default functionality provided by /libs. The /apps folder has precedence over the /libs folder, meaning that if there are two resources with the same path under both folders, the one under /apps will be used. References: https://experienceleague.adobe.com/docs/experience-manager-cloud-service/implementing/developing/aem-project-content-package-structure.html?lang=en#repository-restrictions https://experienceleague.adobe.com/docs/experience-manager-learn/foundation/development/set-up-a-local-aem-development-environment.html?lang=en#the-aem-repository

The issue arises because the anonymous user does not have the necessary read permissions for the /content directory. When using Sling context-aware configurations, access to the configuration resource is required. If the anonymous user lacks read permissions, the configuration cannot be retrieved, resulting in a null value.

To fix this issue, you need to grant read permissions to the anonymous user for the /content directory.

Steps to apply read permissions:

Access CRXDE Lite: Log into your AEM instance and navigate to CRXDE Lite (http://localhost:4502/crx/de).

Navigate to the /content Directory: In the CRXDE Lite interface, browse to the /content directory.

Set Permissions:

Right-click on the /content directory and select "Permissions".

Add the anonymous user (if not already present).

Grant read permissions to the anonymous user.

Save Changes: Apply the changes and ensure that they are saved correctly.

Test the Configuration: Log out of the AEM instance and test the context-aware configuration as an anonymous user to ensure that the configuration resource can now be retrieved.

By granting read permissions to the anonymous user for the /content directory, you allow access to the necessary configuration resources, resolving the issue.

References:

Adobe Experience Manager Security Permissions