Blog posts by Ashish Rasal2024-11-07T06:19:16.0000000Zhttps://world.optimizely.com/blogs/ashish-rasal/Optimizely WorldExcludeDeleted(): Prevent Trashed Content from Appearing in Search Results<h3>Introduction</h3>
<p>In Optimizely CMS, content that is moved to the trash can still appear in search results if it’s not explicitly excluded using the <code>IsDeleted</code> property on <code>IContent</code>. This behavior can clutter search results and lead to a confusing user experience, especially if the "deleted" content remains accessible when it shouldn't be. Unfortunately, Optimizely’s documentation lacks a straightforward way to filter out trashed content, so we developed a custom solution that excludes trashed items from search results.</p>
<p>This solution leverages Optimizely Content Events to detect when content is moved to or from the trash and applies an <code>IsDeleted</code> flag to custom page templates that inherit from <code>SitePageData</code>, our project’s base page class. By using these events, we ensure real-time updates to the search index, providing a consistent and clear search experience for users.</p>
<h3>Overview of Optimizely Content Events</h3>
<p>Optimizely Content Events are essential for managing content lifecycle actions such as creation, updates, movement, and deletion. With these events, developers can trigger specific actions in response to content changes, enabling them to integrate with other systems or handle special tasks for particular content types.</p>
<p>Here’s a quick overview of common content events in Optimizely:</p>
<ul>
<li><strong>CreatedContent</strong>: Fired when new content is created.</li>
<li><strong>PublishedContent</strong>: Triggered when content is published.</li>
<li><strong>DeletedContent</strong>: Fires when content is permanently removed from the CMS.</li>
<li><strong>MovedContent</strong>: Activated when content is moved to a new location or to the trash.</li>
<li><strong>SavingContent</strong>: Occurs before content is saved, often used for validation or setting default values.</li>
</ul>
<p>For a more in-depth look at Content Events, check out <a href="/link/a0f73c83f9874dd5aeec4bf69739c27c.aspx"><span>Daniel</span><span> Ovaska’s</span><span> blog</span><span> on</span><span> Content</span><span> Events</span></a>.</p>
<h3>Solution Overview</h3>
<p>Our custom solution involves setting up an <code>OnMovedContentToTrash</code> event handler that:</p>
<ol>
<li>Detects when content is moved to or from the trash.</li>
<li>Sets an <code>IsDeleted</code> flag on custom page types that inherit from <code>SitePageData</code>.</li>
<li>Updates the content index in Optimizely Find to keep search results accurate.</li>
</ol>
<p>We’ll break down each part of this solution below, including a reusable method that dynamically identifies all custom page types derived from <code>SitePageData</code> and efficiently applies the <code>IsDeleted</code> flag.</p>
<h3>Implementation</h3>
<h4>Step 1: Setting up the <code>OnMovedContentToTrash</code> Event Handler</h4>
<p>In our <code>OnMovedContentToTrash</code> method, we monitor if content has been moved to or from the trash. Based on its location, we set the <code>IsDeleted</code> flag to true (if it’s in the trash) or false (if it’s restored). This updated information is saved in the CMS and re-indexed in Optimizely Find to ensure search results reflect the current content state.<br /><br /></p>
<h4>Step 2: Creating the Processor Action for Each Page Type</h4>
<p>To apply <code>IsDeleted</code> on each page type without reflection at runtime, we use an expression tree to create an action for each type. This approach avoids runtime performance overhead and prevents potential issues with reflection.<br /><br /></p>
<h4>Step 3: Defining the <code>ProcessContent</code> Method</h4>
<p>This method applies the <code>IsDeleted</code> flag to the specific content type and re-indexes it in Optimizely Find to ensure that it appears or disappears from search results based on its status.</p>
<p>Here's the code for the above steps:</p>
<pre class="language-csharp"><code>
[InitializableModule]
[ModuleDependency(typeof(EPiServer.Web.InitializationModule), typeof(EPiServer.Commerce.Initialization.InitializationModule))]
public class ContentEventInitialization : IInitializableModule
{
private IClient _findClient { get; set; }
private Injected<ICmsContentService> _cmsContentService;
private IContentTypeRepository _contentTypeRepository { get; set; }
private static readonly Injected<IHttpContextAccessor> _httpContextAccessor;
private static readonly Injected<IConfiguration> _configuration;
private static readonly Injected<IWebHostEnvironment> _environment;
private static readonly ILogger _logger = LogManager.GetLogger(typeof(ContentEventInitialization));
public void Initialize(InitializationEngine context)
{
_findClient = SearchClient.Instance;
_contentTypeRepository = context.Locate.Advanced.GetInstance<IContentTypeRepository>();
var contentEventsService = _contentEvents.Service;
contentEventsService.MovedContent += OnMovedContentToTrash;
contentEventsService.PublishedContent += OnContentPublished;
contentEventsService.CheckedInContent += OnCheckedInContent;
}
public void Uninitialize(InitializationEngine context)
{
var contentEventsService = _contentEvents.Service;
contentEventsService.MovedContent -= OnMovedContentToTrash;
contentEventsService.PublishedContent -= OnContentPublished;
contentEventsService.CheckedInContent -= OnCheckedInContent;
}
/// <summary>
/// Handles the event when content is moved to or from the trash. Updates the IsDeleted property
/// of specific custom page types and re-indexes the content in Optimizely Find.
/// </summary>
/// <param name="sender">The event sender.</param>
/// <param name="e">The content event arguments containing details about the moved content.</param>
private void OnMovedContentToTrash(object sender, ContentEventArgs e)
{
_logger.Information($"Moved content to trash fired for content {e.ContentLink.ID}");
if (e is MoveContentEventArgs eventArgs)
{
var contentRepository = ServiceLocator.Current.GetInstance<IContentRepository>();
// Dictionary to store processors for each custom page type
var contentProcessors = new Dictionary<Type, Action<IContent, bool>>();
var sitePageDataType = typeof(SitePageData);
// Get all types that inherit from SitePageData in the current assembly
var pageTypes = _contentTypeRepository
.List()
.Where(x => x.ModelType != null)
.Select(x => x.ModelType)
.Where(x => sitePageDataType.IsAssignableFrom(x) && x.IsClass && !x.IsAbstract);
// Populate the dictionary with actions for each page type
foreach (var pageType in pageTypes)
{
var processor = CreateProcessorAction(pageType);
contentProcessors[pageType] = processor;
}
// Determine if content is moved to or from the trash, setting IsDeleted accordingly
bool isDeleted = eventArgs.TargetLink.ID == ContentReference.WasteBasket.ID;
bool isRestored = eventArgs.OriginalParent.ID == ContentReference.WasteBasket.ID;
if (isDeleted || isRestored)
{
var contentType = e.Content.GetType().BaseType;
if (contentProcessors.TryGetValue(contentType, out var processor))
{
processor.Invoke(e.Content, isDeleted);
}
}
}
}
/// <summary>
/// Creates a strongly-typed action for processing a specific page type when content is moved
/// to or from the trash. This avoids the need for reflection at runtime.
/// </summary>
/// <param name="pageType">The type of the page for which to create the processor action.</param>
/// <returns>An action that processes the page type when content is moved to or from the trash.</returns>
private Action<IContent, bool> CreateProcessorAction(Type pageType)
{
// Define parameters for the lambda: (IContent content, bool isDeleted)
var contentParam = Expression.Parameter(typeof(IContent), "content");
var isDeletedParam = Expression.Parameter(typeof(bool), "isDeleted");
// Cast content to the specific page type
var castContent = Expression.Convert(contentParam, pageType);
// Create method call for ProcessContent<T> using the specific page type
var method = typeof(ContentEventInitialization)
.GetMethod(nameof(ProcessContent), BindingFlags.NonPublic | BindingFlags.Instance)
.MakeGenericMethod(pageType);
// Call ProcessContent<T>((T)content, isDeleted)
var body = Expression.Call(Expression.Constant(this), method, castContent, isDeletedParam);
// Compile into a lambda expression: (IContent content, bool isDeleted) => ProcessContent<T>((T)content, isDeleted)
var lambda = Expression.Lambda<Action<IContent, bool>>(body, contentParam, isDeletedParam);
return lambda.Compile();
}
/// <summary>
/// Updates the IsDeleted property for a specific content type and re-indexes it in Optimizely Find.
/// This method is intended to be called by actions generated for each page type.
/// </summary>
/// <typeparam name="T">The type of the content to process, which must inherit from PageData.</typeparam>
/// <param name="content">The content to be processed.</param>
/// <param name="isDeleted">A boolean indicating whether the content is marked as deleted (true) or restored (false).</param>
private void ProcessContent<T>(IContent content, bool isDeleted) where T : PageData
{
var contentRepository = ServiceLocator.Current.GetInstance<IContentRepository>();
if (contentRepository.Get<T>(content.ContentLink).CreateWritableClone() is T writableContent)
{
writableContent.IsDeleted = isDeleted;
if (isDeleted)
{
writableContent.Deleted = DateTime.Now;
writableContent.DeletedBy = PrincipalInfo.CurrentPrincipal.Identity.Name;
}
else
{
writableContent.Deleted = null;
writableContent.DeletedBy = null;
}
contentRepository.Save(writableContent, SaveAction.SkipValidation, AccessLevel.NoAccess);
_findClient.Index(writableContent);
}
}
}
</code></pre>
<h3><strong>Using ExcludeDeleted():</strong></h3>
<pre class="language-csharp"><code>var detailPageQuery = _searchClient.Search<StorytellingPage>()
.ExcludeDeleted()
.FilterForVisitor()
.FilterOnCurrentSite()
.CustomFilterForVisitor()
.Take(PAGINATION);</code></pre>
<h3>Conclusion</h3>
<p>By creating a generic solution using Optimizely Content Events, we can dynamically detect content type changes, set an <code>IsDeleted</code> flag, and update the search index in real time. This approach not only makes it easy to exclude trashed content from search results but also keeps our codebase clean and efficient, without runtime reflection overhead.</p>
<p>This solution can be adapted to any custom page type that inherits from <code>SitePageData</code>, making it versatile for projects that need better control over search visibility in Optimizely CMS.</p>
<p><br />P.S. Any input or alternative proposals would be gratefully received.</p>2024-11-07T06:19:16.0000000ZBlog post