Blog posts by pjangid

Boosting Indexing Efficiency: Reindex Pages Directly from Optimizely’s Navigation Pane

Wed, 11 Jun 2025 04:48:36 GMT

There can be various reasons why you might want to trigger indexing or reindexing of a page/node directly from the navigation pane. In my case, we were working with a large volume of content and needed to test newly introduced custom indexing fields. Waiting for the entire site to be reindexed through the standard indexing job wasn’t feasible.

While there are certainly other ways to handle this, adding a manual reindex trigger proved especially helpful in our upper environments (such as Integration and Preproduction), where faster feedback loops are critical.

Here's a quick look at how it appears in the UI:

To implement this, I used Dojo to create new navigation items and added them to Optimizely’s plug-in area within the navigation tree. Here's the setup from Initializer.js:

define([
    "dojo",
    'dojo/_base/declare',
    'epi-cms/plugin-area/navigation-tree',
    'epi/_Module',
    'optimizelyModules/ReIndexTree/ReIndexTree',
    'optimizelyModules/ReIndexTree/ReIndexChildren'
], function (
    dojo,
    declare,
    navigationTreePluginArea,
    _Module,
    ReIndexTree,
    ReIndexChildren
) {

    return declare([_Module], {
        initialize: function () {
            this.inherited(arguments);
            navigationTreePluginArea.add(ReIndexTree);
            navigationTreePluginArea.add(ReIndexChildren);
        }
    });
});

Both ReIndexChildren.js and ReIndexTree.js follow a similar pattern, differing mainly in naming and intent. For reference, here’s the code for ReIndexChildren.js:

define([
    "dojo/topic",
    "dojo/_base/declare",
    "epi/dependency",
    "epi/shell/XhrWrapper",
    "epi/shell/command/_Command"
], function (topic, declare, dependency, XhrWrapper, _Command) {

    return declare([_Command], {

        label: "Reindex Children",
        iconClass: "epi-iconReload epi-icon--success",

        constructor: function () {
            var registry = dependency.resolve("epi.storeregistry");
            this.store = registry.get("epi.cms.contentdata");
        },

        _execute: function () {
            var contentLinkId = this.model.contentLink;

            // Create an XhrWrapper for making the API call
            var xhr = new XhrWrapper();
            xhr.xhrGet({
                url: "/api/indexing/reindex-tree",
                handleAs: "json",

                content: {
                    contentLinkId: contentLinkId,
                    childrenOnly: true
                },

                failOk: true,

                load: function (response) {
                    // Handle the success response (e.g., show a message)
                    console.log("Reindexing successful:", response);
                },

                error: function (response) {
                    // Handle the error response (e.g., show an error message)
                    console.error("Error reindexing:", error);
                }
            });
        },

        _onModelChange: function () {
            this.set("canExecute", true);
        }
    });
});

In the above implementation, I’m calling a custom controller endpoint at /api/indexing/reindex-tree. This endpoint accepts two parameters:

childrenOnly: A flag indicating whether to reindex only the direct children or the entire content tree under the selected node.
contentLinkId: The ID of the selected node, which is used to identify the starting point for reindexing.

This approach gives editors or developers an easy way to trigger indexing selectively, without needing to reindex the entire site.

You can find the full code in the GitHub repository (branch) here: https://github.com/pjangid/OptimizelyReindexModule/tree/feature/opti-module-reindex-tree

As always, there’s room for improvement. I’d love to hear your thoughts—please feel free to leave suggestions or feedback in the comments below.

Thanks & Regard,

Praful

Optimizely SaaS vs PaaS: A Comparison from Client and Developer Perspectives

Mon, 03 Feb 2025 13:09:40 GMT

Optimizely, one of the leading digital experience platform. Offering both Software-as-a-Service (SaaS) and Platform-as-a-Service (PaaS) solutions. Organizations choosing between these options must consider factors such as scalability, customization, maintenance, and development flexibility. In this article we are going to talk about the key differences between Optimizely SaaS and PaaS from both client and developer perspectives.

Overview of Optimizely SaaS and PaaS

Optimizely SaaS

- Fully managed cloud-based service.
- Automatic updates and patches.
- Limited customization but quick deployment.
- Best suited for businesses looking for a low-maintenance, high-availability solution.

Optimizely PaaS

- Hosted in a managed cloud environment with more control.
- Requires ongoing maintenance, including updates and security.
- Offers greater flexibility for customization and integration.
- Best suited for businesses needing tailored solutions with specific functionalities.

Comparison from a Client’s Perspective

Cost & Pricing

- SaaS: Subscription-based pricing with predictable costs.
- PaaS: Higher upfront costs with variable hosting expenses.

Ease of Use & Maintenance

- SaaS: Managed by Optimizely, reducing IT overhead and maintenance efforts.
- PaaS: Requires internal IT resources for deployment, security, and scaling.

Scalability & Performance

- SaaS: Automatically scales with demand, ensuring uptime and performance.
- PaaS: Scaling requires configuration and monitoring from the client’s IT team.

Customization & Flexibility

- SaaS: Limited customization options; best for businesses with standard needs.
- PaaS: High degree of customization, allowing unique integrations and tailored workflows.

Security & Compliance

- SaaS: Security and compliance are managed by Optimizely, reducing client concerns.
- PaaS: Requires internal governance and security management, adding complexity.

Comparison from a Developer’s Perspective

Development Flexibility

- SaaS: Limited ability to customize backend functionalities; mostly front-end modifications.
- PaaS: Full control over development, with access to APIs, extensions, and third-party integrations.

DevOps & CI/CD

- SaaS: Minimal need for DevOps management, as infrastructure is handled by Optimizely.
- PaaS: Requires setup and maintenance of CI/CD pipelines, infrastructure, and monitoring.

Integration Capabilities

- SaaS: Predefined integrations and API limitations may restrict some use cases.
- PaaS: Allows deep integrations with custom systems, databases, and third-party services.

Deployment & Version Control

- SaaS: Automatic updates without client intervention; risk of breaking changes.
- PaaS: Controlled deployment cycles, allowing developers to test and release updates at their own pace.

Which One Should You Choose?

Factor	Optimizely SaaS	Optimizely PaaS
Cost & Pricing	Predictable, subscription-based	Higher upfront, variable costs
Maintenance	Fully managed by Optimizely	Requires internal IT management
Customization	Limited	Highly customizable
Scalability	Automatic	Requires configuration
Security & Compliance	Managed by Optimizely	Client-managed
Developer Flexibility	Limited backend access	Full control over development
Deployment Control	Automatic updates	Controlled release cycles

When to Choose Optimizely SaaS

- If you need a low-maintenance solution with automatic updates.
- If your business processes fit within standard Optimizely capabilities.
- If cost predictability and ease of use are top priorities.

When to Choose Optimizely PaaS

- If your business requires custom integrations and development flexibility.
- If you have an in-house IT team to manage updates, security, and scaling.
- If you need greater control over deployment cycles and infrastructure.

Short & Sweet Conclusion

Both Optimizely SaaS and PaaS offer robust solutions, but the right choice depends on your organization’s needs. Clients should weigh cost, maintenance, and customization, while developers should consider flexibility and control over the infrastructure. By carefully assessing these factors, businesses can ensure they select the best Optimizely platform for their digital experience strategy. You can read for more information on the Optimizely's documentations site.

References

https://world.optimizely.com/products/cms/saas/

Bulk publishing of unpublished content items/nodes

Sat, 06 Feb 2021 07:26:50 GMT

In Episerver, we don't have any built in feature that allows us to publish full site (bulk items) in one go. We recently faced one challenge to publish all category nodes.

In CMS, we have an option of Project to perform bulk item update (change of state or publish). But in commerce we don't. And, in our case, we did import of content using custom code and a huge number of items were not published (even we used the SaveAction.Publish).

Then, we decided to write custom code to do that (via scheduled job). And, after doing some RnD, I found that the following Method returns only published items.

ContentRepository.GetChildren<T>(ContentReference contentLink)

Then, the question is how to retrieve the unpublished node/items?

Here is the answer, use the Language option with GetChildren method.

ContentRepository.GetChildren<NodeContent>(parentNode.ContentLink, LanguageSelector.AutoDetect(true))

This is just a trick to get the unpublished items/nodes. And, for bulk publish, you can use the

ContentRepository.Publish(listOfPages);

That's it. You are done.

Thanks

Skip jobs to execute on specific day(s) of the week

Sat, 07 Dec 2019 09:09:18 GMT

Hi All,

Recently came across a requirement of skipping jobs execution on weekends. So, I thought why not allow editors to control all/any jobs to stop execute on specific days of week.

So, I took inspiration from @Paul's reply on this thread.

First, I created SelectionFactory for all existing jobs on StartPage (Home page), you can create this property on your setting item (as per your wish). Along with another property to select days of week to disable the jobs.

[Display(
    Name = "Scheduled jobs",
    Description = "Select jobs to stop execution on specific day",
    GroupName = Global.GroupNames.SiteSettings,
    Order = 1000)]
[SelectMany(SelectionFactoryType = typeof(ScheduledJobsSelectionFactory))]
public virtual string ScheduledJobs { get; set; }

[Display(
    Name = "Skip job execution on day(s)",
    Description = "Select days on which you don't want to execute jobs",
    GroupName = Global.GroupNames.SiteSettings,
    Order = 1010)]
[SelectMany(SelectionFactoryType = typeof(WeekDaysSelectionFactory))]
public virtual string SkipJobExecutionOnDays { get; set; }

Which something will look like this in our CMS (in below image).

[I selected some jobs and days to disable].

*I will add code of selection factories at the end

Next, our scheduled job that will scan all our jobs and check if their next execution is fallin on the skip day, then just updated next execution field and saved back. Here this code contains function to get HomePage.

[ScheduledPlugIn(DisplayName = "Skip JobExecution Scheduled Job")]
public class SkipJobExecutionScheduledJob : ScheduledJobBase
{
    private bool _stopSignaled;
    private readonly IContentLoader _contentLoader;
    private readonly IScheduledJobRepository _scheduledJobRepository;

    public SkipJobExecutionScheduledJob(
        IContentLoader contentLoader,
        IScheduledJobRepository scheduledJobRepository)
    {
        _contentLoader = contentLoader ?? throw new ArgumentNullException(nameof(contentLoader));
        _scheduledJobRepository = scheduledJobRepository ?? throw new ArgumentNullException(nameof(scheduledJobRepository));
        IsStoppable = true;
    }

    /// <summary>
    /// Called when a user clicks on Stop for a manually started job, or when ASP.NET shuts down.
    /// </summary>
    public override void Stop()
    {
        _stopSignaled = true;
    }

    /// <summary>
    /// Called when a scheduled job executes
    /// </summary>
    /// <returns>A status message to be stored in the database log and visible from admin mode</returns>
    public override string Execute()
    {
        //Call OnStatusChanged to periodically notify progress of job for manually started jobs
        OnStatusChanged($"Starting execution of {this.GetType()}");

        var sb = new StringBuilder();
        var homePage = this.GetHomePage();
        if (homePage == null) return $"Could not retrieve site settings";

        var jobs = homePage.ScheduledJobs?.Split(',').ToList();
        var jobToDisable = jobs?.Select(x => this._scheduledJobRepository.Get(Guid.Parse(x))).ToList()
               ?? new List<ScheduledJob>();
        var skipJobExecutionOnDays = homePage.SkipJobExecutionOnDays?.Split(',').ToList();
        if (jobToDisable.Count > 0 && skipJobExecutionOnDays != null && skipJobExecutionOnDays.Count > 0)
        {
            foreach (var job in jobToDisable)
            {
                if (skipJobExecutionOnDays.Contains(job.NextExecution.DayOfWeek.ToString()))
                {
                    job.NextExecution = job.NextExecution.AddDays(1);
                    this._scheduledJobRepository.Save(job);
                    OnStatusChanged($"Updated \"{job.Name}\" to run on \"{job.NextExecution}\"");
                    sb.AppendLine($"Updated \"{job.Name}\" to run on \"{job.NextExecution}\"");
                }

                //For long running jobs periodically check if stop is signaled and if so stop execution
                if (_stopSignaled)
                {
                    return "Stop of job was called";
                }
            }
        }

        //For long running jobs periodically check if stop is signaled and if so stop execution
        if (_stopSignaled)
        {
            return "Stop of job was called";
        }
        var rtn = sb.ToString();
        if (rtn == string.Empty)
        {
            rtn = "Job completed successfully. No updates required.";
        }
        return rtn;
    }

    private StartPage GetHomePage()
    {
        var pageLink = SiteDefinition.Current.StartPage;
        if (pageLink == null || pageLink == ContentReference.EmptyReference)
            return null;

        this._contentLoader.TryGet(pageLink, out PageData page);

        if (page == null)
            return null;

        return this.GetHomePage(page);
    }

    private StartPage GetHomePage(PageData page)
    {
        if (page == null)
            return null;

        if (page is StartPage homePage)
            return homePage;

        homePage = this._contentLoader
                .GetAncestors(page.ContentLink)
                .FirstOrDefault(x => x is StartPage)
            as StartPage;

        return homePage;
    }
}

In addition, I am adding selection factory code here.

public class ScheduledJobsSelectionFactory: ISelectionFactory
{
    public Injected<IScheduledJobRepository> ScheduledJobRepository { get; set; }

    public IEnumerable<ISelectItem> GetSelections(ExtendedMetadata metadata)
    {
        var scheduledJobs = this.ScheduledJobRepository.Service.List();

        var selections =
            scheduledJobs
                .Select(x => new SelectItem
                {
                    Text = x.Name,
                    Value = x.ID.ToString()
                })
                .ToList();

        return selections;
    }
}

public class WeekDaysSelectionFactory : ISelectionFactory
{
    public IEnumerable<ISelectItem> GetSelections(ExtendedMetadata metadata)
    {
        return Enum
            .GetNames(typeof(DayOfWeek))
            .Select(x => new SelectItem { Text = x, Value = x })
            .ToList();
    }
}

On a special note, you can add fields for time range to skip in that duration (Stop Execution Time and Start Execution Time).

Special Note: This implementation is more focused with single site implementation. If you have jobs that are site specific you can follow comment by @Antti (below in comments).

And to restrict the access you can follow this post.

Reach-out to me if you have any question or concern :)

Thanks & Regards

Praful Jangid

Happy Coding!

Disabling Cache for Test Driven (page with active A/B test) content

Wed, 13 Nov 2019 09:16:43 GMT

Caching is a great feature to improve the site performance. But recently we faced issue with test driven content being cached. The user was seeing the same test content that get loaded first because it get cached. And, there were no good solution to vary content based on test driven content. So, we came up with a solution to disable cache for test driven content (page with active A/B testing).

In order to do that you need to find if there is any active test for context item. I created an attribute by inheriting from default ContentOutputCacheAttribute.

public class CustomContentOutputCacheAttribute : ContentOutputCacheAttribute
{
     private static readonly Injected<IMarketingTestingWebRepository> _marketingTestingWebRepository;

    public CustomContentOutputCacheAttribute()
    {
        this.UseOutputCacheValidator = UseOutputCache;
    }

    private static bool UseOutputCache(IPrincipal principal, HttpContextBase context, TimeSpan duration)
    {
        var url = context.Request.Url?.ToString();
        var content = UrlResolver.Current.Route(new UrlBuilder(url));
        if (content == null) return false;
        return !_marketingTestingWebRepository.Service.GetActiveTestsByOriginalItemId(content.ContentGuid).Any();
    }
}

Now, next step is apply this attribute to your Page controller Index method. You can see the test content is not loading from cached.

public class StoryPageController : PageController<StoryPage>
{
    [CustomContentOutputCache(Duration = 7200)]
    public ActionResult Index(StoryPage currentPage)
    {
        return this.View(currentPage);
    }
}

Now, open your browser and check in network tab if the current page Response Headers > Cache-Control value. If you have any active test running for current page then the value should be private otherwise public with max-age=7200 [value set by you for how long you want to cache].

Thanks and regards

Happy Coding

Make property help text permanently visible

Sat, 19 Oct 2019 10:01:59 GMT

NOTE: Supported upto CMS version 12.9

In continuous efforts to make editors life easy, it will be helpful to make the property help text (shown in below image) permanently visible.

In reference to this blog post, I would like address one issue that, when we try to create block directly from content area those help text are not visible.

So, Let's start...

We will add CSS properties, that will add title text into html element's :after selector (for elements that contains help text in title attribute).

In Episerver, to add a css you will need module.config file, to be added in main project. Create a module.config file and paste the following lines (don't forget to update the path to your css file)

<module xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
  <clientResources>
    <!-- Add css file path in path attribute-->
    <add name="epi-cms.widgets.base" path="/ClientResources/epi-cms.css" resourceType="Style" />
  </clientResources>
</module>

The epi-cms.css is our css file, in which we are going to add our own css classes and properties. Copy paste below css into your css file.

/*  Set property descriptions to be visible */
.Sleek .dijitTabPaneWrapper .epi-form-container__section__row label[title]:after,
.Sleek .epi-createContent .epi-form-container__section__row > label[title]:after {
    content: attr(title);
    display: block;
    font-size: 0.8em;
    font-style: normal;
    margin: 0.3em 0 0 0;
}

This css class is for the normal edit window and when we create a block in assets pan. The second class is for, when you create a block from content area (by clicking on Create a new block).

And here we got our help text visible

Let me know if you have any question or concern.

Thanks & Regards

Praful Jangid

Happy coding :)

Adding icons/thumbnails to content tree items in Episerver CMS

Mon, 15 Jul 2019 21:18:55 GMT

Updates [2021/01/04]: Geta has updated the module to allow you to configure the tree icons. See below link

https://github.com/Geta/Epi.FontThumbnail#tree-icon-feature

You might not need this customization anymore.

In continuous efforts to make the content editor’s life easy, we will learn to add icons/thumbnails, to the items in our content tree. So that we can easily identify the type of an item.

In EpiServer, we have an attribute to add preview images to our custom types (Page/Block types). But that will only show while adding new item (as shown in below image). So, this is the default scenario. When we are using the Episerver’s ImageUrl attribute.

You can see the icons on the content types (on right side), but those are missing on the items in tree (in left panel).

So, I would recommend Geta module for thumbnails (Geta.Epi.FontThumbnail). That is very handy and easy to use. And, this (below image) is when using the Geta module.

The same situation we face here, icons are missing on content tree items.

Here, I will add some code along with Geta module to add icons to our items in tree.

Here we go.

Let’s start by adding an Initialization Module, named let's say TreeIconsInitialization inherited from IInitializableModule and dependencies as show below.

[InitializableModule]
[ModuleDependency(typeof(InitializableModule))]
[ModuleDependency(typeof(FontThumbnailInitialization))]
public class TreeIconsInitialization : IInitializableModule
{
}

Add the following code inside the Initialize function

public void Initialize(InitializationEngine context)
{
    if (context == null)
        return;

    var assemblies = AppDomain.CurrentDomain.GetAssemblies().ToList();
    assemblies = assemblies.Where(x => x.GetName().Name.StartsWith("AlloyDemo")).ToList();

    var types = assemblies.SelectMany(x => x.GetTypes()).ToList();
    var typesWithIcon = types
        .Where(type => type.IsDefined(typeof(ThumbnailIcon), false))
        .ToList();

    var iconClasses = typesWithIcon
        .Select(type => new
        {
            Type = type,
            IconClass = this.ParseIconClass(type)
        })
        .ToDictionary(key => key.Type, value => value.IconClass);

    foreach (var uiDescriptor in context
        .Locate
        .Advanced
        .GetInstance<UIDescriptorRegistry>().UIDescriptors)
    {
        if (iconClasses.ContainsKey(uiDescriptor.ForType))
        {
            uiDescriptor.IconClass += iconClasses[uiDescriptor.ForType];
        }
    }
}

In above code, we are scanning the project assemblies to retrieve the types that are defined with the ThumbnailIcon attribute. Here, function ParseIconClass() is responsible for parsing the icon class (font awesome icon class).

Here is the code for parsing the icon class:

private string ParseIconClass(Type type)
{
    if (type == null)
        return null;

    var attribute = Attribute.GetCustomAttribute(type, typeof(ThumbnailIcon)) as ThumbnailIcon;

    string path = attribute?.Path;

    if (string.IsNullOrWhiteSpace(path))
        return null;

    Uri.TryCreate($"http://localhost{path}", UriKind.RelativeOrAbsolute, out Uri uri);
    var query = System.Web.HttpUtility.ParseQueryString(uri.Query);
    string characterCodeString = query["Character"];

    if (!int.TryParse(characterCodeString, out var characterCode))
        return null;

    FontAwesome fa = (FontAwesome)characterCode;
    string name = System.Enum.GetName(typeof(FontAwesome), fa);
    string kebab = FromPascalCaseToKebabCase(name);
    string iconClass = $"fa fa-{kebab}";

    return iconClass;
}

In this function, we are getting the path value of the ThumbnailIcon attribute, as this path contains the icon code in querystring param “Character”. Then converting that code into the font awesome icon class.

The method FromPascalCaseToKebabCase() is for converting the icon name into actual font-awesome icon class.

private static string FromPascalCaseToKebabCase(string input)
{
    if (string.IsNullOrWhiteSpace(input))
        return null;

    StringBuilder retVal = new StringBuilder(32);

    retVal.Append(char.ToLowerInvariant(input[0]));
    for (int i = 1; i < input.Length; i++)
    {
        if (char.IsLower(input[i]))
        {
            retVal.Append(input[i]);
        }
        else
        {
            retVal.Append("-");
            retVal.Append(char.ToLower(input[i], CultureInfo.InvariantCulture));
        }
    }

    return retVal.ToString();
}

After all these, of course we will need to add reference to font awesome css file. To do so, add (if, not already added) module.config and following code.

<?xml version="1.0" encoding="utf-8"?>
<module>
  <clientResources>
    <add name="epi-cms.widgets.base" path="/Static/css/font-awesome.min.css" resourceType="Style" />
  </clientResources>
</module>

And, here we have our icons/thumnails to content tree items

RnD credit goes to our EMVP Drew Null.

If anyone need a hand on any issue or understanding any code line, do let me know.

Happy Coding, thanks and regards,

Praful Jangid

Indexing Block's Content to make it searchable

Fri, 12 Apr 2019 21:44:27 GMT

By default, the content of a block (that is added to ContentArea on a page) is not indexed and therefore you can’t search for the content of that block instance in your site.

So, the content of a page (including block's content) is indexed as normal text under "SearchText$$string". To check if the content from Block is being indexed or not. Go to Episerver CMS, Find -> Overview -> Explore, look for the page you want to confirm. Expand to see all its indexed properties. You can see here that, by default the content of the block is not being indexed.

Let's talk about how to enable it. Here we go....

There are several ways to do that, use any of them as per your requirement.

To allow content of all the instances of a block type to be indexed. Just add an attribute [IndexInContentArea] on your block.
```
[IndexInContentAreas]
public class CopyBlock : SectionBlock
```
Tip: If you still not see the content is being indexed. Perform some changes to your page and you will see it worked. It's only to reindex the page.
To exclude content of certain instances of the block, add a bool type property with exact name IndexInContentAreas on your block type.
```
public virtual bool IndexInContentAreas { get; set; }
```
And set its value to True, so that content of all instances will be indexed by default. To exclude content of any instance, uncheck the checkbox for property IndexInContentAreas (for that instance only).

Using search convention, changing the default behaviour of IContentIndexerConventions.ShouldIndexInContentAreaConvention.

To index a particular block type, create a class and inherit it with interface IShouldIndexInContentAreaConvention

public class ShouldIndexInContentAreaConvention : IShouldIndexInContentAreaConvention
{
       public bool? ShouldIndexInContentArea(IContent content)
       {
       	return content is CopyBlock;
       }
}

Now create an Initializable module

[InitializableModule]
[ModuleDependency(typeof(EPiServer.Find.Cms.Module.IndexingModule))]
public class SearchConventionInitializationModule : IInitializableModule
{
        public void Initialize(InitializationEngine context)
        {
            ContentIndexer.Instance.Conventions.ShouldIndexInContentAreaConvention = new ShouldIndexInContentAreaConvention();
        }

        public void Uninitialize(InitializationEngine context)
        {
        }
}

In addition, to control the depth of ContentArea to be indexed, can be controlled by MaxDepthContentAreaConverter (by default all nested ContentArea are indexed)

public class SearchConventionInitializationModule : IInitializableModule
{
        private const int MaxDepth = 4;

        public void Initialize(InitializationEngine context)
        {
            ContentIndexer.Instance.Conventions.ShouldIndexInContentAreaConvention = new ShouldIndexInContentAreaConvention();
            SearchClient.Instance.Conventions.ForInstancesOf<ContentArea>().ModifyContract(x => x.Converter = new MaxDepthContentAreaConverter(MaxDepth));
        }

        public void Uninitialize(InitializationEngine context)
        {
        }
}

Document reference: https://world.episerver.com/documentation/developer-guides/find/Integration/episerver-cms-7-5-with-updates/Indexing-content-in-a-content-area/

Happy Coding :)

Sorting dictionaries / translations with Episerver events

Wed, 27 Feb 2019 03:47:22 GMT

What we are trying to achieve here is, whenever I create a new entry in Translations Block (to create dictionary item), the latest entry goes at the end of the list. Which is not sorted in alphabetic order. Therefore, it is difficult to find any entry as the list size increases.

So, we have a TranslationsBlock, that contains Translations property list type. This Translations contains three properties (Key, Phrase and Description).

We will apply sorting in alphabetic ascending (a->z) order. First on Key, then Phrase and then Description.

Here we go,

Create an Initialization module named EventInitialization (whatever name you prefer) and decorate it with attributes

[InitializableModule]
[ModuleDependency(typeof(EPiServer.Web.InitializationModule))]

Also, don’t forget to inherit class with interface IInitializableModule.

public class EventInitialization : IInitializableModule

Implement the methods of this interface.

Now, inside the Initialize (implemented from interface) method bind your event.

var events = ServiceLocator.Current.GetInstance<IContentEvents>();
events.PublishedContent += this.OnSavedContent;

I attached it to PublishContent event, that will be raised as the content is being published.

Now, the finishing work goes inside the OnSavedContent method.

private void OnSavedContent(object sender, ContentEventArgs contentEventArgs)
{
    if (contentEventArgs.Content is TranslationsBlock translationsBlock)
    {
        var repository = ServiceLocator.Current.GetInstance<IContentRepository>();
        var block = (TranslationsBlock)translationsBlock.CreateWritableClone();
        block.Translations = block.Translations?
            .OrderBy(x => x.Key)
            .ThenBy(x => x.Phrase)
            .ThenBy(x => x.Description)
            .ToList();
        repository.Save((IContent)block, SaveAction.Publish);
    }
}

Here, first I checked for the content type is our required type TranslationsBlock or not. Then creating a writable clone to update it. Now apply your operations and save it with the help of Save method of ContentRepository.

Happy Coding :)

Thanks,

Praful Jangid