Background: Redirect Map Manager vs. Redirect Manager in AEMaaCS

Previously, ACS Commons Redirect Map Manager was unsupported on AEMaaCS, limiting options for handling redirects. As a workaround, customers needed to use ACS Commons Redirect Manager, which came with several challenges:

• Reliance on Dispatcher Rules: Redirect Manager required that all redirect requests pass through the Dispatcher’s rules to reach the AEM publishers, where Redirect Manager rules could then be executed. This dependency on Dispatcher configurations often led to complications. Only requests meeting specific Dispatcher criteria reached the publisher, and requests blocked by earlier Dispatcher rules (e.g., rules for file types or specific paths) would bypass the publisher entirely, causing some redirects to fail.
• Potential for Conflicting Rules: Dispatcher has its own rewrite rules, which can sometimes interfere with redirects set in Redirect Manager. If a Dispatcher rewrite rule processes a request before it reaches Redirect Manager, it can override the redirect, leading to unexpected behaviors or even redirect loops. This makes troubleshooting and coordinating rules more challenging.
• Increased Maintenance and Complexity: Coordinating Dispatcher rules with Redirect Manager required ongoing adjustments to ensure consistency across both levels. This setup added maintenance overhead, as new rules or configurations in the Dispatcher required verification to avoid interfering with existing redirects.

With AEM version 18311 and the support for ACS Commons Redirect Map Manager, these limitations are greatly reduced. Redirect Map Manager now allows redirect processing to be handled entirely at the edge by the Dispatcher, minimizing reliance on AEM publishers and aligning with Adobe’s best practices for cloud environments.

Key Benefits of the New Setup

1. Offloading Redirects to the Dispatcher

With ACS Commons Redirect Map Manager, redirect processing is managed at the Dispatcher level, reducing the need for requests to be handled by publishers. This shift improves performance and scalability:

• Previous Configuration with Redirect Manager: The first request for a redirect had to be processed by the AEM publisher, placing load on the AEM instance until CDN caching took effect. For high-traffic sites, this dependency on the publisher created potential performance bottlenecks.
• New Configuration with Redirect Map Manager: Redirects are processed directly by the Dispatcher, with CDN caching supporting subsequent requests. This reduces publisher load and improves response times, allowing for smoother handling of large-scale redirects.

2. Simplified Management with Fewer Conflicts

Redirect Map Manager reduces the likelihood of conflicts with Apache’s Dispatcher rewrite rules:

• Better Coordination with Dispatcher Rules: With redirect processing fully managed at the Dispatcher, Redirect Map Manager rules are less likely to conflict with existing rewrite rules, eliminating the need to pass through complex Dispatcher configurations to reach the publisher.
• Reduced Complexity: Redirect Map Manager’s edge-based handling simplifies redirect rule management, enabling more consistent behavior and reducing the need for Dispatcher-publisher coordination.

3. Greater Flexibility for Business Users

This update provides a more accessible and flexible redirection setup for business users who need to control redirects but may lack access to development pipelines:

• User-Friendly Management Interface: ACS Commons Redirect Map Manager offers an intuitive interface within AEM for managing redirects. Business users can easily create, edit, and organize large numbers of redirects without requiring deployments or extensive pipeline configurations.
• Scalability for Large-Scale Operations: Redirect Map Manager supports thousands of redirects directly within AEM, making it ideal for business-driven redirect management at scale.

How to Configure Pipeline-Free URL Redirects with Redirect Map Manager

Setting up pipeline-free redirects with the ACS Commons Redirect Map Manager in AEMaaCS is straightforward:

1. Define Redirect Maps: In the managed-rewrite-maps.yaml file, specify paths to redirect files stored in the publish repository.
2. Manage Redirects in Redirect Map Manager: Use the Redirect Map Manager’s user interface to set up and organize redirect mappings. The tool’s UI allows direct integration with Dispatcher for a streamlined process.
3. Configure Apache RewriteMap:
   • Set up the RewriteMap directive in Apache to ensure optimal redirect caching and performance at the Dispatcher level. Here’s a sample configuration:

   1 2 3

   RewriteMap map.foo dbm=sdbm:/tmp/rewrites/my.map RewriteCond ${map.foo:$1} !"" RewriteRule ^(.*)$ ${map.foo:$1|/} [L,R=301]

For a deeper dive into this feature, visit Adobe’s full article: Pipeline-Free URL Redirects.

Visit the official ACS Commons Redirect Map Manager Page.

Conclusion

The introduction of ACS Commons Redirect Map Manager support in AEMaaCS marks a significant improvement in URL redirection management. By handling redirects at the Dispatcher, this feature enhances performance, reduces complexity, and minimizes publisher load, all while aligning with Adobe’s best practices for AEM Cloud environments.

With these changes, managing large-scale redirects in AEMaaCS becomes more efficient, flexible, and scalable, making it easier for teams to maintain high performance and consistency across their AEM implementations.

The post Pipeline-Free URL Redirects & ACS Commons Redirect Map Manager Now Supported on AEMaaCS appeared first on Sourced Code.

As an AEM (Adobe Experience Manager) engineer, you might be feeling the weight of these challenges. Perhaps you’re seeing fewer full-time positions, rejections are piling up, or you’re struggling to even secure interviews. It’s understandable that you might start wondering if AEM is becoming obsolete or that your career path is in jeopardy.

But here’s the truth: AEM is far from dead. In fact, with the rise of AEM as a Cloud Service (AEMaaCS), the platform is only growing in relevance as more organizations adopt cloud-native digital experience solutions. Now, more than ever, AEM engineers should stay the course. Here’s why.

1. Why AEM Engineers Shouldn’t Give Up

It’s no secret that the current recession has made it harder for AEM engineers to find long-term roles. Companies are in survival mode, focusing on cost-cutting, which often means pausing hiring for major projects. As an AEM engineer, you might feel like opportunities are shrinking.

But this downturn is temporary. AEM has proven resilient over the years, evolving alongside the digital landscape. AEMaaCS is a game-changer, and it’s helping businesses stay nimble in the cloud-first world. As companies move to cloud platforms, the demand for AEM experts is not disappearing—it’s evolving.

While full-time roles may be harder to find, many businesses are still in need of AEM consultants and freelancers to keep their digital platforms running smoothly. Whether it’s handling content migrations, site optimizations, or cloud transitions, there are still plenty of contract-based opportunities out there to help you stay active in the industry in this temporary downturn.

2. AEM Engineers and ANMGA: Opportunities in the Top 5 Tech Companies

If you’ve ever dreamed of working for a major tech company, the landscape has changed. What was once referred to as FANG (Facebook, Apple, Netflix, Google) has evolved into ANMGA—the top 5 tech companies in the world: Apple, NVIDIA, Microsoft, Google, and Amazon. And here’s the great news: AEM is a critical tool in the digital ecosystems of these tech giants.

In fact, Apple, Microsoft, and NVIDIA all use Adobe Experience Manager to manage their digital presence. This significantly boosts the chances for an AEM engineer to land a role at a top 5 tech company. As these organizations continue to scale and expand their digital operations, the demand for skilled AEM engineers will remain strong.

Top 5 Tech Companies Using AEM (ANMGA):

• Apple: Known for its innovation and user-centric experiences, Apple uses AEM to manage vast amounts of content across its digital channels.
• NVIDIA: A leader in AI and graphics processing, NVIDIA leverages AEM to streamline its digital experiences for customers and partners.
• Microsoft: As a global tech powerhouse, Microsoft uses AEM to handle the complex, large-scale content needs of its diverse digital products and services.
• Google: Does not use AEM.
• Amazon: Does not use AEM.

3. The Rise of AEM as a Cloud Service (AEMaaCS)

In recent years, AEM has evolved into AEM as a Cloud Service (AEMaaCS), Adobe’s cloud-native version of the platform. This shift has been a game-changer. Many organizations are transitioning to AEMaaCS because of the inherent benefits it offers over traditional on-premise solutions.

The introduction of AEM as a Cloud Service (AEMaaCS) is transforming how businesses use Adobe’s powerful content management platform. AEMaaCS is a cloud-native version of the platform, designed to be more flexible, scalable, and efficient than ever before.

Benefits of AEMaaCS:

1. Scalability: AEMaaCS automatically adjusts to the needs of businesses, scaling up or down based on traffic demands. This flexibility ensures that enterprises don’t have to worry about over- or under-provisioning resources.
2. Continuous Updates: One of the most significant advantages of AEMaaCS is the automatic updates. Instead of waiting for major release cycles, companies get regular updates with new features, improvements, and security patches, ensuring they are always running the latest version.
3. Faster Time to Market: AEMaaCS eliminates the need for on-premise infrastructure management, allowing developers and content creators to focus on delivering content and experiences faster. This leads to reduced time-to-market for new campaigns and features.
4. Cost Efficiency: With AEMaaCS, companies pay only for the resources they use, which makes it a cost-effective solution for businesses looking to optimize their content management processes.
5. Global Availability: AEMaaCS provides enhanced performance and uptime across regions, making it ideal for global companies that require consistent and reliable digital experiences across the globe.
6. Scalability: AEMaaCS automatically adjusts to the needs of businesses, scaling up or down based on traffic demands. This dynamic auto-scaling means that organizations no longer need to manually adjust infrastructure to accommodate fluctuations in traffic. It also eliminates the need for in-house DevOps teams to manage server capacity, performance, or uptime. By leveraging this built-in scalability, businesses can significantly reduce costs associated with AEM DevOps management. This is a key advantage for companies looking to optimize resources without sacrificing the ability to deliver seamless digital experiences during high-demand periods, such as product launches or marketing campaigns.

4. AEM 6.5: Still Going Strong with No Plans for Deprecation

While AEMaaCS is gaining widespread adoption, it’s important to note that AEM 6.5—the on-premise or managed service version of AEM—is not going anywhere either. Adobe has no plans to deprecate AEM 6.5, and it will continue to be fully supported for the foreseeable future.

Why?

Many enterprise companies rely on highly customized AEM implementations that simply can’t be replicated in a cloud environment. These businesses have complex content workflows, integrations, and security requirements that are uniquely tailored to their operations. AEM 6.5 provides the flexibility and control needed to meet these specific needs.

One of the most important reasons companies stick with AEM 6.5 on-premise is data privacy. Many industries—such as finance, healthcare, and government—have strict regulatory requirements for storing and processing sensitive customer data. By using AEM 6.5 on-premise, organizations maintain full control over their data, ensuring compliance with industry regulations and safeguarding against potential breaches that might occur in a cloud-based environment.

Additional reasons why businesses choose AEM 6.5 on-premise include:

• Customization: Companies with unique workflows or integrations that require more control over their system prefer the flexibility of AEM 6.5.
• Security: With on-premise AEM 6.5, organizations have greater control over their security measures, which is crucial for industries handling sensitive data.
• Infrastructure Control: For enterprises that need to manage their own infrastructure, AEM 6.5 allows full control over servers, storage, and other resources.
• Performance Optimization: Businesses with high-performance needs may prefer to optimize and tune their own infrastructure for speed, reliability, and custom use cases.

5. AEM Thrives in Major Enterprises

It’s not just ANMGA adopting AEMaaCS—many of the world’s largest enterprises continue to rely on AEM to manage their digital content and experiences. These organizations understand the power of AEM when it comes to delivering personalized, scalable, and consistent content to millions of users.

Here’s a list of companies that currently use AEM (including AEMaaCS) to power their digital platforms:

• Apple
• Microsoft
• NVIDIA
• LinkedIn
• McDonald’s
• Canada.ca
• Canadian Tire
• TD Bank
• Tiffany & Co.
• Budget Rent-a-Car
• Visa
• Mastercard
• Coca-Cola
• Caesars Entertainment
• Toyota
• Sun Life Financial
• Home Depot
• Tangerine Bank
• L’Occitane
• Cisco
• Bose
• Ledcor
• Phonak
• Advanced Bionics
• Premier Inn
• Finning

6. AEM is Evolving—Not Dying

As businesses increasingly move towards cloud-native solutions, AEMaaCS positions itself as a vital player in the future of digital experience management. Adobe continues to invest in AEM, ensuring that it remains a leading digital experience platform for enterprises.

Why You Should Stick with AEM:

• Cloud-Native Solutions: With AEMaaCS, you’re not just working on a legacy platform—you’re engaging with a cutting-edge, cloud-native solution designed for the future.
• Enterprise Adoption is Growing: Some of the largest and most influential companies in the world (ANMGA) use AEM to run their digital ecosystems. This increases the potential for you, as an AEM engineer, to work at a top-tier organization.
• Opportunities in Consulting and Freelancing: Even during economic downturns, AEM specialists are in demand for freelance projects and consulting roles.
• AEM 6.5 is Here to Stay: For businesses with complex, custom requirements, AEM 6.5 remains a vital option, and Adobe will continue to support it for years to come.
• The Market Will Rebound: The current recession won’t last forever. As companies ramp up their digital transformation efforts, the need for AEM expertise will grow.

7. Conclusion: AEM is Alive and Thriving

Despite the economic uncertainty, AEM is not going anywhere. With the rise of AEMaaCS, the platform is becoming even more crucial for businesses looking to deliver personalized, cloud-based digital experiences. AEM 6.5 also remains a key solution for businesses with complex, custom requirements that can’t be easily migrated to the cloud.

AEM engineers shouldn’t give up—continue to hone your skills, embrace the opportunities available today, and be ready for the surge in demand once the market rebounds. Whether it’s working for a global enterprise or a top 5 tech company like Apple, NVIDIA, or Microsoft, AEM is still a powerful career path with endless possibilities.

AEM isn’t dead—it’s evolving. The future for AEM engineers is bright.

The post AEM is Dead in 2024 and Beyond, Blog for AEM Engineers appeared first on Sourced Code.

1. Rolling Deployment Process in AEMaaCS

During a production deployment, AEMaaCS follows a rolling deployment strategy to minimize downtime and ensure continuous availability. Here’s how it works:

1. Deploy AEM Packages to Author:
   • The deployment begins by pushing the updated AEM packages to the author instance. This ensures that the author environment is updated first, preparing it for any content authoring that might be needed post-deployment.
2. Detach Dispatcher1 from the Load Balancer:
   • The first Dispatcher (dispatcher1) is temporarily removed from the load balancer. This prevents it from serving any requests during the deployment, ensuring that users do not access potentially outdated or unstable content.
3. Deploy AEM Packages to Publish1 and Dispatcher1:
   • With dispatcher1 detached, the deployment of AEM packages to the first publish instance (publish1) and the corresponding Dispatcher package to dispatcher1 occurs simultaneously.
   • After the deployment, the Dispatcher cache is flushed. This step is critical as it clears the old cache, ensuring that the updated content is served once the Dispatcher is brought back online.
4. Reattach Dispatcher1 to the Load Balancer:
   • Once the deployment to publish1 and the cache flush on dispatcher1 are complete, dispatcher1 is added back to the load balancer. It can now serve requests with the updated content and configurations.
5. Repeat for Dispatcher2:
   • The process is repeated for the second Dispatcher (dispatcher2). Dispatcher2 is detached from the load balancer, the deployment is made to publish2 and dispatcher2, the cache is flushed, and then dispatcher2 is reattached to the load balancer.
6. Continue for All Instances:
   • This rolling deployment process continues until all publish and Dispatcher instances in the topology have been updated. By updating one Dispatcher at a time, AEMaaCS ensures that there is always at least one Dispatcher available to serve requests, thus maintaining high availability throughout the deployment.

2. Why Is This Process Important?

Flushing the Dispatcher cache after code deployment is essential for ensuring that users receive the latest content and that no outdated files are served. The rolling deployment strategy employed by AEMaaCS automates this process, making it seamless and reducing the risk of downtime or content inconsistencies.

3. Additional Considerations

While AEMaaCS automates much of the deployment and cache flushing process, it’s important to ensure that your Dispatcher configurations are optimized for this process. Properly configured .stat files and cache invalidation rules help to ensure that the cache is only flushed when necessary, preserving performance while ensuring content freshness.

For more detailed information on the rolling deployment process and how AEMaaCS handles cache invalidation, refer to the official Adobe Experience Manager documentation .

This step-by-step approach ensures a smooth transition during code deployments, keeping your AEM environment optimized and responsive.

The post How to Clear & Flush AEMaaCS Cache After Code Deployment appeared first on Sourced Code.

1. Why Disable Logs During Unit Tests?

Logging during unit tests can add unnecessary overhead, especially in large projects where tests generate extensive logs. While logging is essential in production and development environments for debugging, it offers little value during unit tests where the focus is on verifying the correctness of isolated components. Disabling logs during tests provides several benefits:

• Reduced I/O Overhead: Logging operations require I/O, which can slow down test execution. Disabling logging eliminates this overhead, leading to faster tests.
• Cleaner Test Output: With logs disabled, test outputs are cleaner, making it easier to focus on test results without the distraction of log entries.
• Improved Test Performance: Benchmarks have shown that disabling logs can significantly speed up test execution.

2. Adding slf4j-nop to Your Project

To disable logging, you can add the slf4j-nop dependency to your pom.xml:

For multi-module AEM projects, ensure this dependency is also included in the core/pom.xml file.

https://mvnrepository.com/artifact/org.slf4j/slf4j-nop

3. Benchmarks and Examples

Here’s a comparison of test execution times to illustrate the impact of disabling logs:

• JUnit 5 (with logging):
  • Run from IntelliJ IDEA: 9.276 seconds
  • Run with mvn clean test: 8.696 seconds
• JUnit 5 (with slf4j-nop):
  • Run from IntelliJ IDEA: 2.116 seconds
  • Run with mvn clean test: 1.892 seconds

These results clearly demonstrate that disabling logging can drastically reduce test execution times, allowing for faster feedback during development.

4. Further Optimizing AEM Tests

In addition to disabling logging, further optimization can be achieved by selecting the appropriate AemContext:

• NoResourceResolverTypeAemContext (Fastest): Ideal for tests that don’t require resource resolution.
• ResourceResolverMockAemContext (Default): Best for tests that need a mocked resource resolver.
• JcrMockAemContext: Useful for tests requiring JCR features like indexing.
• JcrOakAemContext (Slowest): Necessary for simulating a full JCR, though it’s the slowest option.

By combining these strategies—disabling unnecessary logging and selecting the appropriate context—you can achieve significantly faster and more efficient unit tests.

Implementing these strategies ensures your unit tests are optimized, allowing you to maintain high development velocity without being slowed down by lengthy test runs.

The post How to Speed Up Unit Tests in JUnit 5 AEM Projects with SLF4J-NOP appeared first on Sourced Code.

As of the latest Adobe updates, AEM 6.5 is officially classified under Long-Term Support (LTS), ensuring it remains fully supported with service packs, security updates, and enhancements for the foreseeable future.

This means AEM 6.5 is not deprecated or end-of-life — and continues to be a strategic solution alongside AEM as a Cloud Service (AEMaaCS).

➡️ View official LTS release notes here: AEM 6.5 LTS Release Notes

Adobe Experience Manager (AEM) has gone through significant evolution since its inception as CQ, continually enhancing its capabilities. With the introduction of AEM as a Cloud Service (AEMaaCS) in 2020, Adobe has pivoted towards cloud-based solutions, while gradually phasing out support for older on-premises versions. Here, we outline the history of AEM releases and their respective support timelines, focusing on the latest updates and future direction. In this article we will share you the History of AEM Versions and Support Timeline based on Adobe’s Documentation.

1. History of AEM Versions and Support Timeline

Adobe Experience Manager (AEM) has undergone significant development since its early days as CQ. Here’s a brief overview of its versions and their support timelines:

• CQ 5.4:
  • Released on February 22, 2011
  • Ended core support on February 22, 2014
  • Ended extended support on February 22, 2016
• CQ 5.5:
  • Released on February 25, 2012
  • Ended core support on February 25, 2015
  • Ended extended support on February 25, 2017
• AEM 5.6:
  • Released on February 8, 2013
  • Ended core support on February 8, 2016
  • Ended extended support on February 8, 2018
• AEM 6.0:
  • Released on May 22, 2014
  • Ended core support on May 31, 2017
  • Ended extended support on May 31, 2019
• AEM 6.1:
  • Released on May 28, 2015
  • Ended core support on May 31, 2018
  • Ended extended support on May 31, 2020
• AEM 6.2:
  • Released on April 21, 2016
  • Ended core support on April 30, 2019
  • Ended extended support on April 30, 2021
• AEM 6.3:
  • Released on April 26, 2017
  • Ended core support on April 30, 2020
  • Ended extended support on April 30, 2022
• AEM 6.4:
  • Released on April 4, 2018
  • Ended core support on April 30, 2021
  • Ended extended support on April 30, 2023
• AEM 6.5:
  • Released on April 8, 2019
  • No end date for core or extended support announced yet

Click here to view the official end of support, Adobe Matrix – https://helpx.adobe.com/ca/support/programs/eol-matrix.html

2. Transition to AEM as a Cloud Service (AEMaaCS)

As Adobe continues to support AEM 6.5, the focus is increasingly shifting towards AEM as a Cloud Service (AEMaaCS). AEMaaCS, launched in 2020, offers modern cloud-native capabilities, including seamless updates and scalable infrastructure. This shift is aimed at providing a more flexible and cost-effective solution compared to traditional on-premises installations.

3. Key Points for AEMaaCS

• Continuous Updates: AEMaaCS ensures users always have access to the latest features and security updates without manual intervention.
• Scalability and Flexibility: The cloud infrastructure allows for easy scaling based on business requirements, eliminating the need for managing physical servers.
• Reduced Total Cost of Ownership (TCO): By removing the need for dedicated hardware and maintenance, AEMaaCS can reduce overall costs associated with content management.

Organizations currently using older on-premises versions of AEM should consider migrating to AEMaaCS to benefit from these modern capabilities. For further details on support lifecycle and migration strategies, refer to Adobe’s official support documentation.

The post When is the End of Support for AEM On-Prem? appeared first on Sourced Code.

Ensuring that users receive the latest updates—such as new client libraries (CSS and JS)—requires a carefully managed caching strategy. This article explores how cache invalidation is handled upon releasing new code, particularly clientlibs, and uses the Adobe WKND project as an example to explain the process.

1. Introduction

In this article, we will step through how typically an AEMaaCS website serves newly released client-libraries JS and CSS to users, and we will take a look at the Adobe WKND project as an example.

2. Automatic Cache Invalidation: How It Works

Upon releasing new client libraries, AEMaaCS uses versioned clientlibs. This involves adding a unique hash (previous understanding of the hash generated is pretty much converting the entire minified CSS and JS into MD5 Hash – ACS Commons Approach) to the filenames of clientlibs, served on newly fresh requested HTML pages from the AEM publishers, which forces the CDN and browser caches to recognize and fetch the new files. This automatic mechanism helps ensure that users are served the updated versions.

And please keep in mind, it’s the fresh uncached version of the AEM .html pages who actually serves the path of the versioned clientlibs files. Lets understand .html are cached invalidated from the dispatcher and CDN cache.

Examples of hashed client libs:
/etc.clientlibs/settings/wcm/designs/gandalf/clientlibs/css/all.en-us.min.LIHASHed376af2042959edf283b2591e37eff9.css

3. Example Configuration: Adobe WKND Project

In this article, we will purely inspect the Adobe WKND project which is production live code examples of recommended rules for cache invalidating .html files. The following configuration from the WKND project shows how HTML pages are handled in terms of caching:

4. Breakdown of the Configuration

1. LocationMatch, Targeting HTML Pages:

– The configuration applies to all HTML pages under the /content/ path.

2. Cache-Control Settings:

• max-age=300: HTML pages are cached for 5 minutes. During this time, the CDN serves the cached content without checking with the origin server.
• stale-while-revalidate=3600: After 5 minutes, if a request is made, the CDN serves the stale content and fetches a new version from the server in the background. This background fetch happens within 1 hour, ensuring minimal disruption.

3. Surrogate-Control for CDN:

• stale-while-revalidate=43200: The CDN can continue serving stale content while fetching fresh content for up to 12 hours.
• stale-if-error=43200: In the event of errors fetching the new content, the CDN serves stale content for up to 12 hours.

4. Age Header:

– Header set Age 0: This resets the age of the content to zero, indicating that it is freshly cached.

5. Key Mechanisms and Timings

Initial Cache Period (max-age=300):

– For the first 300 seconds (5 minutes) after the content is cached, the CDN serves the cached version without rechecking with the origin server.

Stale-While-Revalidate (stale-while-revalidate=3600):

– After 5 minutes, the max-age period expires, if a user requests the content, the CDN serves the stale (cached) content immediately and fetches a new version from the origin server in the background. This mechanism ensures that users receive immediate responses, even if the content is slightly outdated, while the cache is refreshed in the background. And again, it’s the fresh uncached version of the AEM .html pages who actually serves the path of the versioned clientlibs files, which is why invalidation on the HTML file is important here.

After Stale-While-Revalidate:

– If a new version has not been successfully fetched within the stale-while-revalidate window (up to 1 hour), and another request is made, the CDN serves the most recently cached version while attempting to fetch the new version again.

6. Conclusion

The correct dispatcher configurations ensures that new client libraries and other updates are served efficiently. The HTML pages need to reference the new clientlibs versioned paths to reflect the latest updates. Since the WKND configuration sets HTML page caching to a maximum of 5 minutes with additional revalidation periods, the new HTML pages and associated clientlibs may not appear immediately; after 5 minutes, if a user requests the content, the CDN serves the stale (cached) content immediately and fetches a new version from the origin server in the background. This mechanism ensures that users receive immediate responses, even if the content is slightly outdated, while the cache is refreshed in the background, the stale-while-revalidate directive helps ensure users see updated content with minimal disruption. This setup minimizes the impact of cache misses and ensures that updated content is available without noticeable delay to the user. This well-balanced approach allows for efficient content delivery while maintaining a seamless user experience.

The post Serving New Client Library CSS and JS After Release on AEM as a Cloud Service (AEMaaCS) appeared first on Sourced Code.

Supported Symbol of MD (Marque Déposée) All Major Browsers:
ᴹᴰ

1. Why Use ᴹᴰ Instead of MD?

It’s important to use ᴹᴰ, rather than the letters “M” or “D” superscripted because of Search Engine Optimization (SEO) and documentation. The usage of ᴹᴰ ensures that the content is accurately represented and indexed correctly by search engines, which may not recognize plain superscripted letters as the official Marque Déposée symbol. Additionally, using the correct symbols ensures compliance with legal and branding guidelines, preserving the authenticity and recognition of the trademark.

2. Correct Representation Across Browsers and Platforms

Another critical reason for using ᴹᴰ instead of a HTML Entity (🅫 or 🅫), simple “M” and “D” or other symbols is that the Modifier Letter Capital M and D are universally supported across most modern browsers and platforms. In contrast, the 🅫(Raised Md Sign) and other HTML entities may not render consistently, leading to potential misrepresentation of the content. By using ᴹᴰ (ᴹ (Modifier Letter Capital M) and ᴰ (Modifier Letter Capital D)), we ensure that the trademark symbol is correctly displayed to all users, regardless of their browser or device.

3. Steps to Use ᴹᴰ in Your Content

To use ᴹᴰ in your content, you can simply copy to clipboard the characters from here: ᴹᴰ, and paste them directly into your website’s text editor. All major browsers should support these characters and prevents any display issues. If your current font does not support these characters, a default web-safe font would be invoked, and will include the standard font look and feel on your page.

Supported Symbol of MD (Marque Déposée) All Major Browsers:
ᴹᴰ
Take a look at these production example websites who are using on their websites:

1. https://www.purina.ca/fr/beggin/dog-treats/beggin-strips-bacon-peanut-butter
2. https://www.nestleprofessional.ca/fr/nestle-confectionery/miettes-de-smarties
3. https://business.michelin.ca/fr/pneus/michelin-megaxbib

4. Conclusion

Using the correct representation for the French trademark symbol, ᴹᴰ, is essential for both legal compliance and proper content indexing by search engines. By following the guidelines outlined above, you can ensure that your content accurately reflects the Marque Déposée symbol and is correctly displayed across all platforms and browsers. This small but significant detail helps maintain the professionalism and credibility of your website.

This structured approach ensures clarity and compliance with proper usage, enhancing both the legal accuracy and user experience on your site.

The post How can I add the French trademark symbol MD to my Website? appeared first on Sourced Code.

1. What You’ll Find Here

This blog is dedicated to sharing knowledge and fostering a community of learning around AEM. Here’s what you can expect:

• In-Depth Tutorials: Detailed guides and tutorials on various aspects of AEM, from basic concepts to advanced techniques. Whether you’re looking to enhance your skills in AJAX, Java, JavaScript, or HTML within the AEM context, you’ll find comprehensive resources here.
• Latest Updates: Stay informed about the latest developments and updates in the AEM ecosystem. This includes new features, best practices, and industry trends that can help you stay ahead in your projects.
• Practical Insights: Real-world insights and experiences from working with AEM. Learn from case studies, project experiences, and practical advice that can help you tackle common challenges and optimize your AEM implementations.
• Community Engagement: This blog is not just about one-way communication. It’s about building a community. Engage with other AEM professionals, share your thoughts, and collaborate on ideas that push the boundaries of digital experiences.

2. Learning and Collaboration

The AEM Blog is a place for continuous learning and collaboration. Whether you’re looking to solve a specific problem, learn a new skill, or stay updated with the latest in AEM, this blog aims to be a valuable resource.

3. Get Involved

Your participation is what makes this community thrive. Feel free to leave comments, share your own experiences, and connect with like-minded individuals. Together, we can make this blog a vibrant hub for all things AEM.

Thank you for being a part of this journey. Let’s explore the fascinating world of AEM together!

“`

The post AEM Blog appeared first on Sourced Code.

1. Cacheable Requests

The Dispatcher can cache a URL if it meets the following criteria:

• Configured to be Cacheable: The request is explicitly configured as cacheable in the Dispatcher configuration.
• Plain GET Request: The request is a simple HTTP GET request.
• URL with Extension: The request URL must include an extension, such as .html.

2. Non-Cacheable Requests or Responses

There are several scenarios where requests or responses cannot be cached by the Dispatcher:

• Denied by Configuration: Requests that are denied caching by specific configuration settings, such as paths, patterns, or MIME types.
• Special Headers:
  • Responses that include a “Dispatcher: no-cache” header.
  • Responses that include a “Cache-Control: no-cache” or “Cache-Control: private” header.
  • Responses that include a “Pragma: no-cache” header.
• Request with Query Parameters: Any request that contains query parameters.
• URL Without Extension: URLs that do not have an extension cannot be cached.
• URL with Suffix Without Extension: URLs that have a suffix lacking an extension.
• Non-200 Status Code: Responses that return a status code other than 200.
• POST Requests: HTTP POST requests cannot be cached as they typically involve changes to the server state.

3. Conclusion

Understanding which requests and responses are cacheable is crucial for optimizing the performance of your AEM instance. By ensuring that only appropriate content is cached and by configuring your Dispatcher settings correctly, you can improve both the speed and reliability of your website. Keep these rules in mind to ensure effective caching with AEM Dispatcher.

The post AEM Dispatcher Uncacheable Requests appeared first on Sourced Code.

1. URLs Without Extensions Are Not Cached

In AEM, URLs must always have an extension to be cacheable by the Dispatcher. While you can serve URLs without extensions in AEM, these URLs will not be cached by the Dispatcher, leading to potential performance issues.

2. Examples

Cacheable URL:

This URL includes an extension (.html) and is therefore cacheable by the Dispatcher.

Non-cacheable URL:

This URL lacks an extension and will not be cached by the Dispatcher. However, if you use the [PT] pass through to internal AEM resource ending with .html, it will be cached.

3. Using Apache [PT] Pass Through as a Fallback

To handle URLs without extensions and ensure they are still processed correctly, you can use Apache’s [PT] (Pass Through) flag. This allows the URL to be passed through to the backend server, appending .html to the request, thereby enabling it to be cached by the Dispatcher.

Example Apache Configuration

Consider the following common dispatcher configuration to handle extensionless URLs:

With this configuration, when a domain like http://domain.com/en/home is hit, it will actually map to:

For example, if ${CONTENT_FOLDER_NAME} is wknd, the URL http://domain.com/en/home would map to:

This allows the Dispatcher to cache the resource correctly.

4. Additional Examples

Original URL:

Rewritten URL with [PT]:

Original URL:

Rewritten URL with [PT]:

In both examples, the extensionless URLs are mapped to URLs ending in .html, making them cacheable by the Dispatcher.

5. Conclusion

To ensure your pages are cached by the Dispatcher, always add extensions to your URLs. Some may argue that having extensions in URLs could negatively affect SEO rankings. However, an uncached page can lead to slow loading times, which can hurt your SEO rankings even more.

By following these guidelines and using Apache [PT] rules as a fallback, you can optimize your AEM Dispatcher caching strategy and improve the performance and reliability of your AEM instance.

The post Caching AEM Pages with Extensionless (.html) appeared first on Sourced Code.

Basic Embed Code

Start with the basic YouTube embed code (without loop). For example:

Step 1: add Required “loop” Parameter

To enable looping, you need to add loop=1 to the URL parameters.

Step 2: add Required “playlist” Parameter

You also need to include the playlist parameter with the video ID to ensure the video loops. The playlist parameter should have the same video ID as the video you want to loop.

Complete Embed Code

Combine these parameters to create the final embed code. Here’s the complete code to loop the YouTube video:

Example: https://jsfiddle.net/x4z73rjL/

Example Breakdown

• Video ID: 1O0yazhqaxs
• Loop Parameter: loop=1 (enables looping)
• Playlist Parameter: playlist=1O0yazhqaxs (repeats the same video)

Final Embedded Video

Here is the full example of an embedded YouTube video that loops continuously:

Example: https://jsfiddle.net/x4z73rjL/

This will embed the YouTube video on your webpage, and it will loop automatically once it reaches the end.

Additional Tips

• Autoplay: If you want the video to start playing automatically when the page loads, you can add the autoplay=1 parameter to the URL.

  1	<iframe src="https://www.youtube.com/embed/1O0yazhqaxs?loop=1&fs=0&playlist=1O0yazhqaxs&autoplay=1" width="560" height="315" title="3 Second Video" frameborder="0"></iframe>

• Remove Controls: To hide the player controls, add controls=0 to the URL parameters.

  1	<iframe src="https://www.youtube.com/embed/1O0yazhqaxs?loop=1&fs=0&playlist=1O0yazhqaxs&controls=0" width="560" height="315" title="3 Second Video" frameborder="0"></iframe>

By following these steps, you can easily loop embedded YouTube videos on your website, providing a seamless viewing experience for your audience.

The post Embed Youtube Iframe on Website with Video Loop appeared first on Sourced Code.

Step-by-Step Guide

1. Basic Embed Code: Start with the basic YouTube embed code. For example:

   1 2 3 4 5

   <iframe src="https://www.youtube.com/embed/1O0yazhqaxs"             width="560"             height="315"             title="3 Second Video"             frameborder="0"></iframe>

   https://jsfiddle.net/x4z73rjL/1/

2. Add Autoplay and Mute Parameters: To enable autoplay, you must also mute the video. Modern browsers restrict autoplay unless the video is muted. Add the autoplay=1 and mute=1 parameters to the URL.
3. Complete Embed Code: Combine these parameters to create the final embed code. Here’s the complete code to autoplay and mute the YouTube video:

   1 2 3 4 5

   <iframe src="https://www.youtube.com/embed/1O0yazhqaxs?autoplay=1&mute=1"             width="560"             height="315"             title="3 Second Video"             frameborder="0"></iframe>

   https://jsfiddle.net/x4z73rjL/2/

Example Breakdown

• Video ID: 1O0yazhqaxs
• Autoplay Parameter: autoplay=1 (enables autoplay)
• Mute Parameter: mute=1 (mutes the video)

Final Embedded Video

Here is the full example of an embedded YouTube video that autoplays and is muted:

https://jsfiddle.net/fo3yg4w9/

This will embed the YouTube video on your webpage, and it will start playing automatically and be muted.

Additional Tips

• Show Controls: If you want to keep the player controls visible, you can add controls=1 (this is the default setting, so it’s optional).

  1	<iframe src="https://www.youtube.com/embed/1O0yazhqaxs?autoplay=1&mute=1&controls=1" width="560" height="315" title="3 Second Video" frameborder="0"></iframe>

• Loop the Video: To make the video loop, add loop=1 and playlist with the video ID.

  1 2 3 4 5

  <iframe src="https://www.youtube.com/embed/1O0yazhqaxs?autoplay=1&mute=1&loop=1&playlist=1O0yazhqaxs"             width="560"             height="315"             title="3 Second Video"             frameborder="0"></iframe>

  https://jsfiddle.net/8h7vL5md/

By following these steps, you can easily embed YouTube videos on your website with autoplay and mute enabled, enhancing the viewing experience for your audience.

For more details, you can refer to Google’s Autoplay Policy and MDN Web Docs on Autoplay.

The post Embed Youtube Iframe on Website with Auto Play appeared first on Sourced Code.

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.

1. Steps to Restrict Tags for User Groups in AEM

2. Go to Tools > Security > Permissions

Navigate to the permissions section of the AEM author instance to start configuring the permissions for the user group.

3. Find Your User Group

Search for the user group that you want to configure. In this example, we will be using the “WKND Members” group.

4. Click on “Add ACE”

Add a new Access Control Entry (ACE) to define the permissions for the group.

5. Add Path /content/cq:tags

This will hide all the tags from the user group initially.

6. Privileges: Add jcr:read

Grant read privileges to the path /content/cq:tags.

7. Set Permission Type to Deny

This will ensure that the group does not have access to read the tags by default.

8. Add Restrictions rep:glob=/

This restriction will hide all top-level cq:tag resources. It effectively denies access to all tags under /content/cq:tags for the specified group.

Explanation: The rep:glob=/ restriction specifies that the denial applies to all child nodes of the specified path. This means the group will not be able to see any of the tags under /content/cq:tags.

9. Press Add to Save

Confirm and add this ACE to enforce the denial of read access.

10. Allow Access to /content/cq:tags/wknd-shared

Now, we need to explicitly allow access to the specific tags we want the group to manage.

11. Click on “Add ACE”

Add another ACE to define the permissions for the specific tags.

12. Add Path /content/cq:tags/wknd-shared

Specify the path to the tags that should be visible and editable by the group.

13. Set Permission Type to Allow

Ensure that the permission type is set to allow, so the group can manage these tags.

Conclusion

By following these steps, the “WKND Members” user group will be able to create, read, update, and delete nodes under /content/cq:tags/wknd-shared, while being restricted from accessing any other tags under /content/cq:tags/*.

This approach ensures that content authors have the appropriate level of access for their specific brand without exposing unnecessary data or tags.

Managing permissions in a multi-tenant AEM environment is crucial for ensuring that content authors can only access and modify the resources relevant to their brand. By carefully setting up access control entries and restrictions, you can achieve a secure and efficient content authoring process.

The post AEM Multi-tenant Website: Restrict cq:tags for User Groups appeared first on Sourced Code.

1. Understanding AEM User Groups

AEM provides a robust user management system that allows administrators to control access to various parts of the system. User groups in AEM are collections of users who share common permissions and access levels. By assigning users to groups, administrators can efficiently manage permissions across multiple users.

2. The Role of Base Level User Groups

Base level user groups in AEM are pre-configured groups that come with a set of default permissions designed to provide access to the authoring tools and functionalities. These groups are essential for quickly onboarding new users and ensuring they have the necessary permissions to perform their tasks.

3. The “Contributor” Group: Your Go-To Base Level Group

For most authoring needs, the contributor group is the ideal base level user group; which is out of the box with a new existing AEM environment. This group is configured with the necessary permissions to access and utilize the authoring tools in AEM. Assigning new user groups to the contributor group ensures that users have a consistent and functional access level to start with.

Benefits of the “Contributor” Group:

• Pre-configured Permissions: The group comes with predefined permissions suitable for content authors.
• Simplified Management: Reduces the need for manual permission configuration.
• Consistency: Ensures a standardized level of access across users.

4. Steps to Assign a New User Group to the “Contributor” Group

A. Create the New User Group

1. Navigate to Tools > Security > Groups in the AEM author instance.
2. Click on the Create button, provide a title and an ID for the new group, then click Create.

B. Assign the New Group to the “Contributor” Group

1. Go to the “Contributors” group settings.
2. In the Group Membership tab, add the “WKND Members” group.

C. Add Users to the New Group

1. Navigate to Tools > Security > Users.
2. Select the users who need to be added to the new group.
3. Edit each user and add them to the new group.

5. Verifying Access and Permissions

After assigning the new user group to the contributor group, it’s important to verify that users have the expected access:

1. Login Verification: Ensure that users can log in and access the authoring interface.

6. Additional Considerations

While the contributor group is a great starting point, you may need to customize permissions based on specific requirements:

1. Granular Permissions: If certain users need additional permissions (e.g., administrative tasks), consider creating sub-groups with elevated permissions.
2. Security Best Practices: Regularly review user group memberships and permissions to maintain a secure and efficient environment.

7. Conclusion

Assigning new user groups to a base level user group with contributor in AEM 6.5 or AEM as a Cloud Service simplifies user management and ensures that users have the necessary permissions to perform their tasks; revealing the authoring UI. By leveraging the pre-configured permissions of the contributor group, administrators can efficiently manage access and maintain a consistent authoring environment.

Ω

Remember, effective user group management is key to a secure and productive AEM instance. Start with the right base level user group and customize as needed to meet your organization’s unique requirements.

The post Base Level User Group That a New User Group in AEM Should Be Assigned 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.

ChatGPT 3.5:

• General Knowledge Base: ChatGPT 3.5 is a jack-of-all-trades, offering insights and generating content across a myriad of subjects, including technical topics. Its expertise is based on data up until 2021, which may not always reflect the newest trends or developments in technologies, especially those specific to AEM.
• Broad Technical Insights: It provides general technical advice and coding suggestions, but these may not align with the latest or most efficient practices specific to AEM development due to its broader focus.
• Universal Approach: ChatGPT 3.5 lacks specialization in any one technology, limiting its effectiveness for deep technical discussions or solving advanced problems in areas like AEM development.

AEM Developer GPT:

• Focused AEM Expertise: Tailored for Adobe Experience Manager, the AEM Developer GPT excels in offering detailed support, code examples, best practices, and problem-solving solutions specifically for AEM development. It is programmed to stay abreast of the latest AEM technologies, ensuring its guidance is always relevant and up-to-date.
• Continuous Learning Capability: This GPT distinguishes itself by its commitment to continuous learning, regularly updating its knowledge base with the newest AEM technologies, tutorials, and documentation. This ensures it always operates with the latest coding standards and best practices in mind, positioning it as a cutting-edge resource for AEM developers.
• Specialized Resources: It provides direct access to the most current and authoritative AEM resources, including documentation, forums, blogs, and video tutorials, ensuring developers have access to the best information possible.
• Advanced Coding and Testing Support: With a focus on Java 11 and JUnit 5, the AEM Developer GPT offers specialized guidance on writing AEM code and conducting unit testing, tailored specifically to the AEM development environment.

Summary:

The AEM Developer GPT stands in stark contrast to ChatGPT 3.5 by offering a specialized, continuously updated knowledge base focused solely on AEM development. While ChatGPT 3.5 provides broad, generalist knowledge up until 2021, the AEM Developer GPT excels in delivering the latest, most accurate AEM-specific advice, coding best practices, and standards. This specialization makes the AEM Developer GPT an invaluable asset for developers seeking to navigate the complexities of AEM development with the most current information and best practices available.

The post Differences Between Using Free ChatGPT 3.5 vs AEM Developer GPT appeared first on Sourced Code.

At its core, AEM Developer GPT is more than just a question-and-answer tool. Whether you’re grappling with complex Java coding challenges, seeking best practices for Sling Model implementations, or need guidance on the latest AEM project archetype, this AI assistant has you covered. By leveraging real-time updates from primary sources such as Adobe’s official documentation, forums, and leading AEM content platforms, it ensures the advice you receive is not just accurate but also cutting-edge.

Try out the free tool today* – https://bit.ly/aem-developer-gpt-b

2. Why Choose AEM Developer GPT?

Choosing AEM Developer GPT means opting for a tool that understands the nuances of AEM development. Its capabilities are not just about accelerating your workflow but also about ensuring you’re always in tune with the latest AEM trends, techniques, and best practices. And perhaps most importantly, it fosters a community-driven approach to AI, where each interaction helps make the GPT smarter—all at no cost.

Try out the free tool today* – https://bit.ly/aem-developer-gpt-b

3. Relevant AEM Content & Adobe Documentation Response

At its core, AEM Developer GPT is more than just a question-and-answer tool. Whether you’re grappling with complex Java coding challenges, seeking best practices for Sling Model implementations, or need guidance on the latest AEM project archetype, this AI assistant has you covered. By leveraging real-time updates from primary sources such as Adobe’s official documentation, forums, and leading AEM content platforms, it ensures the advice you receive is not just accurate but also cutting-edge.

Try out the free tool today* – https://bit.ly/aem-developer-gpt-b

4. From Concept to Code: Supporting AEM Developers at Every Step

The journey from a concept to a fully functional AEM component is fraught with challenges. AEM Developer GPT simplifies this journey by providing detailed coding examples, troubleshooting advice, and best practices for unit testing with JUNIT5, ensuring your projects adhere to the highest standards of quality and efficiency.

Try out the free tool today* – https://bit.ly/aem-developer-gpt-b

5. Unit Testing: The Cornerstone of Reliable AEM Development

Recognizing the critical role of unit testing in software development, AEM Developer GPT places a strong emphasis on guiding developers through the intricacies of writing effective tests using the wcm.io AEMContext. This focus on quality assurance underscores the tool’s commitment to supporting developers in delivering robust, error-free code.

Try out the free tool today* – https://bit.ly/aem-developer-gpt-b

6. A Call to Join the Community

As we continue to evolve AEM Developer GPT, we invite you, the AEM development community, to join us in this journey. Your questions, feedback, and contributions are not just welcomed but are essential in shaping the future of AEM development. Together, we can ensure that AEM Developer GPT remains a vital resource for developers looking to achieve excellence in their AEM projects.

Try out the free tool today* – https://bit.ly/aem-developer-gpt-b

7. Conclusion

AEM Developer GPT stands as a testament to the power of AI in revolutionizing AEM development. By providing instant access to expert knowledge, facilitating smoother workflows, and fostering a vibrant community of developers,

The post ChatGPT for AEM Developers, AEM Developer GPT 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.

Let’s delve into an approach to reset the Chrome outline CSS property. Our focus will be on two key declarations: outline-color: auto; and outline-color: -webkit-focus-ring-color;.

The post Chrome Reset with the Outline CSS Property appeared first on Sourced Code.

4. Instructions: How to Use the Tool? (Video)

Learn how to make the most of the AEM Chrome Extension with our step-by-step video guide. Watch the video below to discover tips and tricks for seamless navigation within Adobe Experience Manager.

The post AEM Chrome Extension for Content Authors, Developers, and CMS Admins Across All AEM Versions appeared first on Sourced Code.

In this example, we use the ‘js-cookie’ library to handle cookies in a simplified manner. The Cookies.get(‘cq-authoring-mode’) function retrieves the value of the ‘cq-authoring-mode’ key from cookies. If the key exists, the JavaScript logic exits gracefully. Otherwise, you can proceed with implementing your custom functionality.

Benefits of Customized JavaScript in AEM Editor

1. Context-Aware Functionality: By checking for specific conditions, such as the presence of a key in cookies, developers can implement context-aware functionality tailored to the AEM authoring environment.
2. Enhanced Authoring Experience: Custom JavaScript allows for the augmentation of the authoring experience by introducing features that streamline workflows and improve usability for content authors.
3. Graceful Handling of Conditions: Checking for the existence of keys in cookies enables developers to gracefully handle conditions, ensuring that the JavaScript logic behaves appropriately in different scenarios.

Conclusion

Mastering the art of writing JavaScript for the AEM Author Environment empowers developers to create a tailored experience purely for the authoring environment. By incorporating checks for specific conditions, such as cookie existence, developers can introduce intelligent and context-aware functionalities that enhance the content creation process. The provided code snippet serves as a starting point for customizing JavaScript in the AEM Author Environment, offering a foundation for further innovation and optimization.

The post Execute JavaScript in the Author Environment for AEM Components AEM 6.5+ 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.

Why ARIA Attributes Matter: Accessibility isn’t just a choice; it’s a legal requirement. Using ARIA attributes is crucial for inclusive web applications, especially for users relying on assistive tools like screen readers. Compliance with accessibility standards is increasingly enforced, with penalties for major sector websites failing to meet these requirements.

What to Expect: In this blog article, we will provide a quick reference to all ARIA attributes, offering brief descriptions for each and accompanying code snippets. Explore a curated list of ARIA attributes designed to enhance user experience. With this guide, developers can seamlessly integrate ARIA attributes, promoting a digital landscape where everyone, regardless of ability, can engage effortlessly.

Embark on this journey to harness the power of ARIA attributes, creating a web space that truly belongs to all.

The post All Aria Attributes for Web Development Accessibility – Library 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.

1. Why a Self-Praise Document is Your Ticket to Promotion

Imagine this scenario: It’s the end of the year, and you’re sitting down for your annual review or contemplating updating your resume for that coveted promotion. Your mind draws a blank, struggling to recall all the fantastic projects you’ve spearheaded, the challenges you’ve conquered, and the positive impact you’ve had on your team and the company. Enter the self-praise document.

A self-praise document is not just a personal pat on the back; it’s a strategic tool to propel your career forward. It’s a curated list of your professional accomplishments and noteworthy moments, serving as a quick reference guide for those times when you need to showcase your achievements to secure that well-deserved promotion.

2. How to Create Your Self-Praise Document for Promotion Success

2.1 Choose Your Platform

Whether it’s Notion, Evernote, Google Docs, or any other cloud-based tool, the key is to have your self-praise document easily accessible. This ensures you won’t lose your valuable insights, even if you switch jobs or face unexpected computer crashes.

2.2 Identify Impactful Achievements

Focus on entries that made a significant difference in your work or for your team. Did you go above and beyond in a project? Were you instrumental in implementing a new process that saved the company money? These are the details that will set you apart and make a compelling case for promotion.

Examples:
Bad (Basic) Entry: “Led a successful marketing campaign.”

Good (Enhanced) Entry: “Drove a highly successful marketing campaign that exceeded projected ROI by 25%. Through strategic audience targeting and collaboration with cross-functional teams, we not only achieved our sales targets but also enhanced brand visibility, positioning the company as an industry

2.3 Include Specifics

Don’t just jot down a general accomplishment; provide enough details to recreate the scenario later. Your future self will thank you when you’re able to recall the specific challenges you overcame and the impact you had.

Examples:

Bad (Basic) Entry: “Led team to implement project management system for improved efficiency.”

Better (Enhanced) Entry: “As project lead, orchestrated cross-functional team in the seamless integration of an advanced project management system. Overcame challenges like software glitches and team resistance through proactive communication and support. Resulted in a 30% reduction in project timelines, boosting overall team productivity and fostering a culture of collaboration.”

This concise yet detailed approach ensures your future self can vividly recall the specific challenges you conquered and the impactful outcomes of your efforts.

3. Balancing Act: Quality Over Quantity for Promotion Success

While it’s essential to document your achievements, striking the right balance is crucial, especially when eyeing that promotion. Avoid going overboard with every minor success; instead, focus on the accomplishments that truly showcase your skills and contributions. The goal is not just to list achievements but to highlight your capacity to make a meaningful impact and contribute to the company’s growth.

4. The Future You, Promoted and Thankful

Think of your self-praise document as a promotion roadmap. When future opportunities arise, whether it’s a new job, a promotion, or updating your resume, you’ll have a comprehensive and easily accessible record to draw from. Past Steve’s foresight in creating the self-praise document becomes a gift to future Steve, who is not just climbing the career ladder but doing it faster.

So, take a moment to start your self-praise document today with an eye on that promotion. Your career trajectory might just thank you for it. And if you’re looking for inspiration or curious to see what an actual self-praise document looks like, check out my channel for more high-leverage techniques and an inside look at my personal self-praise document. Because success is not just about doing great things; it’s about remembering them when it matters most, especially when promotion season arrives.

The post Why a Self-Praise Document is Your Ticket to Promotion 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.

I’m Brian Li, an enthusiastic AEM technical explorer based in Vancouver(BC, Canada) & of course your AEM Champion 2024-2025. Within my blog, I invite you to join me on a journey through the fascinating world of Adobe Experience Manager (AEM). From the intricacies of AJAX, Java, JavaScript, and HTML to the dynamic landscape of crafting digital experiences, I’m here to share insights, experiences, and the latest developments in the AEM realm.

Before diving into the technical nuances, let me give you a glimpse into my professional adventure. As the AEM Solutions Architect & AEM Technical Lead at MNP Digital, I immerse myself in the creative process of seamlessly integrating cutting-edge AEM requirements. My journey has taken me through roles such as AEM Technical Lead and Lead Software Full Stack Engineer at Finning, where I transformed conceptual ideas into tangible tech realities.

Beyond the borders of Vancouver(BC, Canada), my exploration extended to London(United Kingdom) with Whitbread and HSBC, where I proudly served as the Lead/Senior Software Engineer for four years. During this time, I not only contributed to cutting-edge digital experiences but also pioneered the development of an AEM white label framework—simplifying the creation of new AEM websites for enterprise giants.

In addition to my professional ventures, I actively contribute to the AEM Community Forum. I’ve developed a widely-utilized AEM Chrome extension, making a daily impact on 2800 users globally. My blog, a hub for tech enthusiasts, attracts around 200,000 visitors each year. Holding the AEM Community Advisor Coach Badge, the Adobe Experience Manager Sites Architect Master Certification, the Adobe Experience Manager Sites Lead Developer Certification, the Adobe Experience Manager Sites Expert Developer Certification, I’m dedicated to sharing valuable insights on this blog.

I’m also the creator of the AEM Developer GPT AI tool, which empowers over 25,000 active users with AI-assisted development capabilities.

Education is another facet of my journey—I’m a private AEM instructor, passionate about propelling AEM developers to new levels of expertise. Through this, I aim to empower fellow enthusiasts with the skills necessary to thrive in the ever-evolving AEM landscape.

So, welcome to this digital exploration! Whether you’re a seasoned tech professional or a curious newcomer, I hope this blog becomes a valuable resource for insights, learning, and collaboration. If you’re seeking a passionate and experienced collaborator, I’m here and ready to connect. Let’s work together!

Brian’s Links

Mentor Me on CodeMentor!
https://www.codementor.io/@briankasingli

Linkedin (follow me)
https://www.linkedin.com/in/briankasingli

SourcedCode Premium Tool
AEM Chrome Extension

AEM Developer GPT AI Tool
AEM Developer GPT AI Tool

The post Brian Li AEM Enthusiast and AEM Technical Lead in Vancouver 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.

So, I took a shot at crafting a solid example of a user story. For this one, I’m diving into making a new Accordion Component. It’s gotta be user-friendly, look good, be accessible to everyone, and make life easy for our content authors.

I tried to extend this User Story will a lot of extended requirements and details. It captures:

1. Business Requirements
2. Author Requirements
3. Accessibility Requirements

Curious? Check out my take below. Maybe it’ll help you out the next time you’re scratching your head over a ticket!

Epic: Component Development

Story Title: Accordion Component

User Story:

As a content author,
I want to create an accordion component,
So that I can showcase content in an organized, collapsible format that’s inclusive to all users, including those with accessibility needs.

Description:

We’re gearing up to develop an accordion component that’s not just visually appealing and user-friendly but is also deeply rooted in accessibility principles. This isn’t just a collapsible tool for content, but a beacon of inclusivity, especially for users relying on assistive technologies.

Designs:

[Figma Link or attach mock-ups or wireframes for the Accordion Component.]

Dependencies:

• Collaboration with the QA team is essential for extensive testing across browsers and in terms of accessibility.

Requirements:

• The accordion component should support a hierarchy with headers and corresponding content sections.
• Headers must be clickable, triggering the expansion or collapse of their related content.
• The accordion should have a default style but should also be customizable to fit various website themes.
• Animated transitions for expanding and collapsing sections would enhance the user experience.
• Responsive behavior is essential; the accordion should adapt seamlessly to various screen sizes, including mobile, tablet, and desktop.
• It should be lightweight, ensuring that it doesn’t significantly affect page load times.
• Support for nesting accordions (accordion within an accordion) should be considered.
• An option to search or filter items within the accordion would be a useful feature for content-heavy implementations.

Author Requirements:

• The Touch UI interface should display clear labels or icons indicating functionality, like “Add”, “Re-order”, or “Delete Accordion Item.”
• The Touch UI interface should allow content author’s to customize the accordion title; each accordion title added under the multi-field list will render an accordion content area (accordion body) on the editor.html page.
• Each accordion content area should allow author’s to drag and drop any amount of “Sourced Code Content” Components, allowing for diverse rich content options.
• A preview option should allow authors to view their changes in real-time before saving or publishing.
• Expected Touch UI interface:

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

  ============================================================ Tab1: Items ============================================================ [multifield] -- default: EMPTY + (default) componentType = 'container' + accordion title label ============================================================ Tab2: Properties ============================================================ [checkbox] Single Item Expansion -- default: unchecked -- help: Forces a single accordion item to be expanded at a time. Expanding one item will collapse all others. [dropdown-multi-select] Expanded Items -- default: Select -- help: The items that are expanded by default. [text-field] ID -- default: EMPTY -- help: HTML ID attribute to apply to the component.

Accessibility Requirements:

• ARIA landmarks, roles, and states (like `aria-expanded`) should be implemented for the accordion to convey its status and function to assistive technologies.
• Logical tab order should be maintained, ensuring that keyboard users navigate through accordion elements in a coherent sequence.
• A “skip to content” link should be available, permitting users to bypass the accordion if they don’t wish to interact with it.

Acceptance Criteria:

• The accordion should be responsive, ensuring usability across devices from mobile to desktop.
• Users must be able to expand or collapse content by clicking/tapping the accordion header.
• Clear visual indicators, like ‘+’ for collapsed and ‘−’ for expanded sections, should be present.
• Accordion design should permit a minimum of one item and a maximum of ten items.
• By default, accordion content should remain collapsed unless an author configures it otherwise.
• As styled per Figma.

Author Acceptance Criteria:

• Content authors should be able to drag the accordion component from the component panel and drop it into their desired page location.
• Authors should find easy-to-identify areas or placeholders within the accordion where they can add text, images, videos, or other content types, from the accordion content area.
• Rearranging should involve simple drag-and-drop mechanics from the Touch UI interface. If an author wants to move the third accordion item to the first position, they should be able to do this intuitively.
• Configuration options must be present, allowing authors to set which accordion items are expanded when the page loads, mechanics from the Touch UI interface.
• An easy-to-spot toggle option should let authors expand or collapse all accordion items with a single click, mechanics from the Touch UI interface.

Accessibility Acceptance Criteria:

• Keyboard focus should move sequentially through accordion headers using the Tab key. Reverse navigation should be facilitated with Shift+Tab.
• When focused on an accordion header, pressing Enter should change its state from collapsed to expanded or vice-versa.
• Screen readers should provide feedback on the accordion’s state and content, such as “Item 1 expanded” or “Item 2 collapsed.”
• Text-to-background contrast ratios must adhere to WCAG guidelines, ensuring content is discernible for users with visual challenges.
• Testing should confirm compatibility with widely-used assistive technologies like JAWS and NVDA.

Notes:

In developing the accordion component, it’s paramount to blend aesthetics, functionality, and accessibility. This component reflects our dedication to crafting user-centric and inclusive digital experiences.

The post AEM User Story Example: Accordion Component 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